#  LLM _in a flash_ :
Efficient Large Language Model Inference with Limited Memory

Keivan Alizadeh , Iman Mirzadeh , Dmitry Belenko , Karen Khatamifard,
Minsik Cho, Carlo C Del Mundo, Mohammad Rastegari, Mehrdad Farajtabar
Apple  Primary Author<EMAIL_ADDRESS>Major Contribution:
<EMAIL_ADDRESS>Major Contribution<EMAIL_ADDRESS>Senior Author:
<EMAIL_ADDRESS>
###### Abstract

Large language models (LLMs) are central to modern natural language
processing, delivering exceptional performance in various tasks. However,
their intensive computational and memory requirements present challenges,
especially for devices with limited DRAM capacity. This paper tackles the
challenge of efficiently running LLMs that exceed the available DRAM capacity
by storing the model parameters on flash memory but bringing them on demand to
DRAM. Our method involves constructing an inference cost model that harmonizes
with the flash memory behavior, guiding us to optimize in two critical areas:
reducing the volume of data transferred from flash and reading data in larger,
more contiguous chunks. Within this flash memory-informed framework, we
introduce two principal techniques. First, “windowing” strategically reduces
data transfer by reusing previously activated neurons, and second, “row-column
bundling”, tailored to the sequential data access strengths of flash memory,
increases the size of data chunks read from flash memory. These methods
collectively enable running models up to twice the size of the available DRAM,
with a 4-5x and 20-25x increase in inference speed compared to naive loading
approaches in CPU and GPU, respectively. Our integration of sparsity
awareness, context-adaptive loading, and a hardware-oriented design paves the
way for effective inference of LLMs on devices with limited memory.

LLM _in a flash_ :
Efficient Large Language Model Inference with Limited Memory

Keivan Alizadeh††thanks:  Primary Author<EMAIL_ADDRESS>, Iman
Mirzadeh††thanks:  Major Contribution<EMAIL_ADDRESS>, Dmitry
Belenko††thanks:  Major Contribution<EMAIL_ADDRESS>, Karen Khatamifard,
Minsik Cho, Carlo C Del Mundo, Mohammad Rastegari, Mehrdad Farajtabar††thanks:
Senior Author<EMAIL_ADDRESS>Apple

##  1 Introduction

In recent years, large language models (LLMs), such as GPT-3 (Brown et al.,
2020), OPT (Zhang et al., 2022b), and PaLM (Chowdhery et al., 2022), have
demonstrated strong performance across a wide range of natural language tasks.
However, the unprecedented capabilities of these models come with substantial
computational and memory requirements for inference. LLMs can contain hundreds
of billions or even trillions of parameters, making it challenging to load and
run them efficiently, especially on resource-constrained devices.

Currently, the standard approach is to load the entire model into DRAM for
inference (Rajbhandari et al., 2021; Aminabadi et al., 2022). However, this
severely limits the maximum model size that can be run. For example, a 7
billion parameter model requires over 14GB of memory just to load the
parameters in half-precision floating point format, exceeding the capabilities
of most edge devices.

Figure 1: Inference latency of 1 token when half the memory of the model is
available.

(a) Bandwidth in a unified memory architecture

(b) Random read throughput of flash memory

Figure 2: (a) Flash memory offers significantly higher capacity but suffers
from much lower bandwidth compared to DRAM and CPU/GPU caches and registers.
(b) The throughput for random reads in flash memory increases with the size of
sequential chunks and the number of threads.

To address this limitation, we propose to store the model parameters on flash
memory, which is at least an order of magnitude larger than DRAM. Then, during
inference, we directly and cleverly load the required parameters from the
flash memory, avoiding the need to fit the entire model in DRAM. Our
methodology is built on the top of recent works that have shown LLMs exhibit a
high degree of sparsity in the FeedForward Network (FFN) layers, with models
like OPT (Zhang et al., 2022b), Falcon (Almazrouei et al., 2023), exhibiting
more than 90% sparsity (Mirzadeh et al., 2023; Liu et al., 2023b). We exploit
this sparsity to selectively load only parameters from flash memory that
either have non-zero input or are predicted to have non-zero output.
Specifically, we discuss a hardware-inspired cost model that includes flash
memory, DRAM, and computing cores (CPU or GPU). Then, we introduce two
complementary techniques to minimize data transfer and maximize flash memory
throughput:

  * •

Windowing: We load parameters for only the past few tokens, reusing
activations from recently computed tokens. This sliding window approach
reduces the number of IO requests to load weights.

  * •

Row-column bundling: We store a concatenated row and column of the up-
projection and down-projection layers to read bigger contiguous chunks from
flash memory. This increases throughput by reading larger chunks.

To further minimize the number of weights to be transferred from flash memory
to DRAM, we also employ methods to predict FFN sparsity and avoid loading
zeroed-out parameters, akin to approaches documented in Deja Vu (Li and Lu,
2023). Together, windowing and sparsity prediction allow us to load only 2% of
the FFN layer from flash for each inference query. We also propose a static
memory preallocation to minimize transfers within DRAM and reduce inference
latency. Our load from flash cost model captures the tradeoff between loading
less data and reading bigger chunks. Optimizing this cost model and
selectively loading parameters on demand yields flash loading strategies that
can run models 2x larger than the device’s DRAM capacity and speed up
inference by 4-5x and 20-25x compared to naive implementation in CPU and GPU,
respectively.

##  2 Flash Memory & LLM Inference

In this section, we explore the characteristics of memory storage systems
(e.g., flash, DRAM), and their implications for large language model (LLM)
inference. Our aim is to elucidate the challenges and hardware-specific
considerations essential for algorithm design, particularly in optimizing
inference when working with flash memory.

###  2.1 Bandwidth and Energy Constraints

While a modern NAND flash memories offers high bandwidth and low latency, it
falls short of the performance levels of DRAM (Dynamic Random-Access Memory),
especially in memory-constrained systems. Figure 2(a) illustrates these
differences. A naive inference implementation that relies on NAND flash memory
might necessitate reloading the entire model for each forward pass. This
process is not only time-consuming, often taking seconds for even compressed
models, but it also consumes more energy than transferring data from DRAM to
the CPU or GPU’s internal memory.

In scenarios where DRAM is abundant, the cost of loading data is somewhat
mitigated, as the model can reside in DRAM. However, the initial loading of
the model still incurs a penalty, particularly in situations requiring rapid
response times for the first token. Our approach, leveraging activation
sparsity in LLMs, addresses these challenges by enabling selective reading of
model weights, thereby reducing both time and power costs.

###  2.2 Read Throughput

Flash memory systems perform optimally with large sequential reads. For
instance, benchmarks on an Apple MacBook Pro M2 with 2TB flash demonstrate
speeds exceeding 6GiB/s for a 1GiB linear read of an uncached file. However,
this high bandwidth is not replicated for smaller, random reads due to the
inherent multi-phase nature of these reads, encompassing the operating system,
drivers, interrupt handling, and the flash controller, among others. Each
phase introduces latency, disproportionately affecting smaller reads.

To circumvent these limitations, we advocate two primary strategies, which can
be employed jointly. The first involves reading larger chunks of data.
Although throughput growth is not linear (larger chunks take longer to
transfer), the latency for the initial byte becomes a smaller fraction of the
total request time, resulting in more efficient data reading. This principle
is depicted in Figure 2(b). Perhaps a counterintuitive yet interesting
observation is that in some scenarios, it will be faster to read more than
needed (but in larger chunks) and then discard, than only reading necessary
parts but in smaller chunks. The second strategy leverages parallelized reads,
utilizing the inherent parallelism within storage stacks and flash
controllers. Our results indicate that throughputs appropriate for sparse LLM
inference are achievable on standard hardware using 32KiB or larger random
reads across multiple threads.

Crucial to maximizing throughput is the way weights are stored, as a layout
that enhances the average chunk length can significantly boost bandwidth. In
some cases, it might be beneficial to read and subsequently discard excess
data, rather than splitting the data into smaller, less efficient chunks.

Motivated by the challenges described in this section, in section 3, we
propose methods to optimize data transfer volume and enhance read throughput
to significantly enhance inference speeds.

(a) predictor vs relu

(b) low rank predictor

Figure 3: (a) Preactivations of tokens in one sequence in OPT 6.7B. The blue
graph shows preactivation of elements that predictor detected positive while
the green graph is for up projection. As it can be seen most of the False
Positives are close to 0 and False Negatives constitute a small portion of the
elements. (b) A small low rank predictor finds out which intermediate neurons
are going to be activated instead of running heavy up projection.

##  3 Load From Flash

This section addresses the challenge of conducting inference on devices where
the available computational memory is substantially smaller than the size of
the model. This necessitates storing the full model weights in flash memory.
Our primary metric for evaluating various flash loading strategies is latency,
dissected into three distinct components: the I/O cost of loading from flash,
the overhead of managing memory with newly loaded data, and the compute cost
for inference operations.

Our proposed solutions for reducing latency under memory constraints are
categorized into three strategic areas, each targeting a specific aspect of
the latency:

  * •

Reducing Data Load: Aiming to decrease latency associated with flash I/O
operations by loading less data111It is notable that, by _data_ we mean
weights of the neural network. However, our developed techniques can be easily
generalized to other data types transferred and used for LLM inference, such
as activations or KV cache, as suggested by (Sheng et al., 2023)..

  * •

Optimizing Data Chunk Size: Enhancing flash throughput by increasing the size
of data chunks loaded, thereby mitigating latency.

  * •

Efficient Management of Loaded Data: Streamlining the management of data once
it is loaded into memory to minimize overhead.

It is important to note that our focus is not on the compute aspect of the
process, as it is orthogonal to the core concerns of our work. This
delineation allows us to concentrate on optimizing flash memory interactions
and memory management to achieve efficient inference on memory-constrained
devices.

Finally, we will elaborate on the implementation of these strategies in
subsequent sections.

###  3.1 Reducing Data Transfer

Our methodology leverages the inherent sparsity found in Feed-Forward Network
(FFN) models, as documented in preceding research. The OPT 6.7B model, for
instance, exhibits a notable 97% sparsity within its FFN layer. Similarly, the
Falcon 7B model has been adapted through fine-tuning, which involves swapping
their activation functions to ReLU, resulting in 95% sparsity while being
almost similar in accuracy (Mirzadeh et al., 2023). In light of this
information, our approach involves the iterative transfer of only the
essential, non-sparse data from flash memory to DRAM for processing during
inference.

It’s notable that, we employ the 7B models as a practical example to elucidate
our approach, but our findings are adaptable and can be extrapolated to both
larger and smaller scale models with ease.

Selective Persistence Strategy. We opt to retain the embeddings and matrices
within the attention mechanism of the transformer constantly in RAM. For the
Feed-Forward Network (FFN) portions, only the non-sparse segments are
dynamically loaded into DRAM as needed. Storing attention weights, which
constitute approximately one-third of the model’s size, in memory, allows for
more efficient computation and quicker access, thereby enhancing inference
performance without the need for full model loading.

Anticipating ReLU Sparsity. The ReLU activation function naturally induces
over 90% sparsity in the FFN’s intermediate outputs, which reduces the memory
footprint for subsequent layers that utilize these sparse outputs. However,
the preceding layer, namely the up project for OPT and Falcon, must be fully
present in memory. To circumvent loading the entire up project matrix, we
follow Liu et al. (2023b) and employ a low-rank predictor to identify the
zeroed elements post-ReLU (see Figure 3(b)). In contrast to their work, our
predictor needs only the output of the current layer’s attention module, and
not the previous layer’s FFN module. We have observed that, postponing the
prediction to current layer is sufficient for a hardware aware weight loading
algorithm design, but, leads to more accurate outcome due to deferred inputs.
We thereby only load elements indicated by the predictor.

Table 1:  Using predictors doesn’t change the accuracy of zero-shot metrics
significantly as predictor of each layer accurately identifies sparsity

Zero-Shot Task | OPT 6.7B | with Predictor
---|---|---
Arc Easy | 66.1 | 66.2
Arc Challenge | 30.6 | 30.6
HellaSwag | 50.3 | 49.8

Neuron Data Management via Sliding Window Technique. In our study, we define
an active neuron as one that yields a positive output in our predictive model.
Our approach focuses on managing neuron data by employing a Sliding Window
Technique. This methodology entails maintaining neuron data only for a recent
subset of input tokens in the memory. The key aspect of this technique is the
selective loading of neuron data that differs between the current input token
and its immediate predecessors. This strategy allows for efficient memory
utilization, as it frees up memory resources previously allocated to neuron
data from older tokens that are no longer within the sliding window (as
depicted in Figure 4(b)).

From a mathematical standpoint, let $s_{\text{agg}}(k)$ denote the cumulative
use of neuron data across a sequence of $k$ input tokens. Our memory
architecture is designed to store an average of $s_{\text{agg}}(k)$ in Dynamic
Random-Access Memory (DRAM). As we process each new token, the incremental
neuron data, which is mathematically represented as
$s_{\text{agg}}(k+1)-s_{\text{agg}}(k)$, is loaded from flash memory into
DRAM. This practice is grounded in the observed trend of decreasing aggregated
neuron usage over time. Consequently, larger values of $k$ result in a lesser
volume of data being loaded for each new token. (refer to Figure 4(a)) This
reduction in data loading is counterbalanced by the memory cost associated
with storing $s_{\text{agg}}(k)$. In determining the size of the sliding
window, the aim is to maximize it within the constraints imposed by the
available memory capacity.

(a) aggregated neuron use

(b) sliding window

Figure 4: (a) Aggregated neuron use of the tenth layer of Falcon 7B, as it can
be seen the slop of aggregated neuron use is decreasing. Other layers exhibit
the same pattern. (b) Instead of deleting neurons that brought to DRAM we keep
the active neurons of past 5 tokens: when the new token "Was" is being
processed only a few amount of data needs to be changed.

###  3.2 Improving Transfer Throughput with Increased Chunk Sizes

To increase data throughput from flash memory, it is crucial to read data in
more substantial chunks. In this section, we detail the strategy we have
employed to augment the chunk sizes for more efficient flash memory reads.

Bundling Columns and Rows. For OPT and Falcon models, the usage of the $i$th
column from the upward projection and the $i$th row from the downward
projection coincides with the activation of the $i$th intermediate neuron.
Consequently, by storing these corresponding columns and rows together in
flash memory, we can consolidate the data into larger chunks for reading.
Refer to Figure 7 for an illustration of this bundling approach. If each
element of weights of the network is stored in _num_bytes_ such bundling
doubles the chunk size from $d_{model}\times$_num_bytes_ to
$2d_{model}\times$_num_bytes_ as shown in Figure 7. Our analysis and
experiment show this increases the throughput of the model.

Bundling Based on Co-activation.

(a) coactivation intensity

(b)  Closest friend

(c)  4th closest friend

(d) 8th closest friend

Figure 5: (a) coactivation of the neurons of 10th layer with one random neuron
in the same layer shows a few neurons are highly coactivated with it and can
be grouped (b) closest friend of a neuron is the one that gets coactivated
with it the most, coactivation of closest friend of every neuron in opt125m
shows closest friend of each neuron almost always gets coactivated with it.
(c) The 3rd closest friend gets coactivatd with each neuron 86% of the time in
average (d) The 7th closest friend seems to be less relevant and doesnt
coactivate with the neuron very often

We had a conjecture that neurons may be highly correlated in their activity
patterns, which may enable further bundling. To verify this we calculated the
activations of neurons over C4 validation dataset. For each neuron the
coactivation of that neuron with other ones forms a power law distribution as
depicted in Figure 5(a). Now, let’s call the neuron that coactivates with a
neuron the most _closest friend_. Indeed, the closest friend of each neuron
coactivates with it very often. As Figure 5(b) demonstrates, it is interesting
to see each neuron and its closest friend coactivate with each other at least
95% of the times. The graphs for the 4th closest friend and 8th closest friend
are also drawn. Based on this information we decided to put a bundle of each
neuron and its closest friend in the flash memory; whenever a neuron is
predicted to be active we’ll bring its closes friend too. Unfortunately, this
resulted in loading highly active neurons multiple times and the bundling
worked against our original intention. It means, the neurons that are very
active are ‘closest friend‘ of almost everyone. We intentionally present this
negative result, as we believe it may lead to interesting future research
studies on how to effectively bundle the neurons and how to leverage it for
efficient inference.

###  3.3 Optimized Data Management in DRAM

Figure 6:  Memory management, first we copy last elements to deleting neurons
to maintain a consecutive block of memory then the required ones are stack to
the end, this prevents from copying whole data multiple times

Although data transfer within DRAM is more efficient compared to accessing
flash memory, it still incurs a non-negligible cost. When introducing data for
new neurons, reallocating the matrix and appending new matrices can lead to
significant overhead due to the need for rewriting existing neurons data in
DRAM. This is particularly costly when a substantial portion (approximately
25%) of the Feed-Forward Networks (FFNs) in DRAM needs to be rewritten. To
address this issue, we adopt an alternative memory management strategy. This
involves the preallocation of all necessary memory and the establishment of a
corresponding data structure for efficient management. The data structure
comprises elements such as pointers, matrix, bias, num_used, and last_k_active
shown in Figure 6.

Each row in the matrix represents the concatenated row of the ’up project’ and
the column of the ’down project’ of a neuron. The pointer vector indicates the
original neuron index corresponding to each row in the matrix. The bias for
the ’up project’ in the original model is represented in the corresponding
bias element. The num_used parameter tracks the number of rows currently
utilized in the matrix, initially set to zero. The matrix for the $i$th layer
is pre-allocated with a size of $\texttt{Req}_{i}\times 2d_{\text{model}}$,
where $\texttt{Req}_{i}$ denotes the maximum number of neurons required for
the specified window size in a subset of C4 validation set. By allocating a
sufficient amount of memory for each layer in advance, we minimize the need
for frequent reallocation. Finally, the last_k_active component identifies the
neurons from the original model that were most recently activated using the
last $k$ tokens.

The following operations are done during inference as depicted in Figure 6.

  1. 1.

Deleting Neurons: Neurons that are no longer required are identified
efficiently in linear time, utilizing the last_k_active data and the current
prediction. The matrix, pointer, and scalars of these redundant neurons are
replaced with the most recent elements, and their count is subtracted from
num_rows. For $O(c)$ neurons to be deleted, a memory rewrite of the order
$O(c\times d_{\text{model}})$ is required.

  2. 2.

Bringing in New Neurons: Necessary neuron data is retrieved from flash memory.
The corresponding pointers and scalars are read from DRAM, and these rows are
then inserted into the matrix, extending from num_row to num_row + num_new.
This approach eliminates the need for reallocating memory in DRAM and copying
existing data, reudcing inference latency.

  3. 3.

Inference Process: For the inference operation, the first half of the
matrix[:num_rows,:d_model] is used as the ’up project’, and the transposed
second half, matrix[:num_rows,d_model:].transpose(), serves as the ’down
project’. This configuration is possible because the order of neurons in the
intermediate output of the feed-forward layer does not alter the final output,
allowing for a streamlined inference process.

These steps collectively ensure efficient memory management during inference,
optimizing the neural network’s performance and resource utilization.

Figure 7:  By bundling columns of up project and rows of down project in OPT
6.7B we will load 2x chunks instead of reading columns or rows separately.

##  4 Results

Experimental Setup: Our experiment is designed to optimize inference
efficiency on personal devices. To this end, we process sequences
individually, running only one sequence at a time. This approach allows us to
allocate a specific portion of DRAM for the Key-Value (KV) cache while
primarily focusing on the model size. This strategy is particularly effective
when dealing with only one sequence/query at a time.222 For OPT 6.7 B model
with context length 2048 KV-cache requires $2048\times 2d_{\text{model}}$
elements which is only $8\%$ of model size. Also the KV-cache itself can be
held in flash memory.

For the implementation of our inference process, we utilize the HuggingFace’s
transformers and KV caching. This setup is tested under the condition where
approximately half of the model size is available in DRAM. We select this
amount as a showcase of the idea of hosting the LLM in flash. With a different
level of sparsity or employing quantization, one can work with smaller
available DRAM capacity as well. Such a configuration demonstrates the
practicality of executing inference with lower memory footprints.

Hardware Configuration. Our models are evaluated using two distinct hardware
setups. The first setup includes an Apple M1 Max with a 1TB solid-state drive
(SSD) for flash memory. In this configuration, computations are performed on
the CPU, and the models are maintained in a 32-bit format. The second setup
involves a Linux machine equipped with a 24 GB NVIDIA GeForce RTX 4090
graphics card. For this machine, computations are GPU-based, and models are
run in the bfloat16 format. For both setups, we operate under the assumption
that almost half of the total available memory (DRAM plus GPU memory) is
allocated for model computations.

Models. We use OPT 6.7B (Zhang et al., 2022b) and a sparsified Falcon 7B
(Mirzadeh et al., 2023) model for our evaluations.

Baselines. For methods not employing sparsity or weight sharing, at least half
of the model must be transferred from flash memory during the forward pass.
This necessity arises because, initially, only half of the model is available
in DRAM, but as the forward pass progresses, the entire model capacity is
utilized. Consequently, any data not present at the start must be transferred
at least once. Thus, the most efficient theoretical baseline involves loading
half of the model size from the flash memory into DRAM. This optimal I/O
scenario serves as our primary baseline. Comparative methods, such as FlexGen
(Sheng et al., 2023) and Petals (Borzunov et al., 2023), are also constrained
by the limited available DRAM or GPU memory, and therefore cannot surpass this
theoretical I/O efficiency.

Flash memory Data Loading Implementation. To optimize data loading from flash
memory, our system employs a 32-thread reading process. This multithreading
approach is specifically designed to enhance data retrieval efficiency,
allowing for simultaneous access to multiple data segments (Figure 2(b)).

Caching Considerations for Data Loading from Flash Memory. When data is read
from flash memory, the operating system typically caches these pages,
anticipating future reuse. However, this caching mechanism consumes additional
memory in DRAM beyond what is allocated for the model. To accurately assess
the real throughput of flash memory under limited DRAM conditions, benchmarks
should be conducted without relying on caching.

For the purpose of our hardware benchmarking in this study, we deliberately
constrain our NVMe throughput measurements. On macOS and iOS, we employ the
F_NOCACHE flag with the fcntl() function, while on Linux, we use DirectIO.
Additionally, on macOS, we clear any resident buffers before initiating the
benchmark using the purge command. This approach provides a conservative
estimate of throughput in scenarios where no caching is permitted. It’s worth
noting that these figures can improve if either the inference code or the
operating system caches some part of the weights.

While OS-level buffer caching is advantageous for general applications with
high cache hit rates, it lacks fine-grained control over cache usage per
process or buffer eviction at the application level. In the context of on-
device memory constraints and large model sizes, this could lead to
ineffective caching cycles and buffer eviction, leading to minimal gains and
potential issues with memory allocation and Translation Lookaside Buffer (TLB)
churn.

###  4.1 Results for OPT 6.7B Model

This section presents the outcomes for the OPT 6.7B model, specifically under
conditions where the memory allocated for the model in DRAM is approximately
half of its baseline requirement.

Predictors. For the initial 28 layers of the OPT 6.7B model, we train
predictors with a rank of $r=128$. To reduce the occurrence of false
negatives, the final four layers employ predictors with a higher rank of
$r=1024$. These predictors achieve an average of 5% false negatives and 7%
false positives in the OPT 6.7B model. As depicted in Figure 3(a), our
predictor accurately identifies most activated neurons, while, occasionally
misidentifying inactive ones with values near zero. Notably, these false
negatives, being close to zero, do not significantly alter the final output
when they are excluded. Furthermore, as demonstrated in Table 1, this level of
prediction accuracy does not adversely affect the model’s performance in
0-shot tasks.

Windowing in the OPT 6.7B Model. Utilizing a windowing method with $k=5$ in
the OPT 6.7B model significantly reduces the necessity for fresh data loading.
Using active neurons of predictor would require about 10% of the DRAM memory
capacity in average; however, with our method, it drops to 2.4%. This process
involves reserving DRAM memory for a window of the past 5 tokens, which, in
turn, increases the DRAM requirement for the Feed Forward Network (FFN) to
24%.

The overall memory retained in DRAM for the model comprises several
components: Embeddings, the Attention Model, the Predictor, and the Loaded
Feed Forward layer. The Predictor accounts for 1.25% of the model size, while
Embeddings constitute 3%. The Attention Model’s weights make up 32.3%, and the
FFN occupies 15.5% (calculated as $0.24\times 64.62$). Summing these up, the
total DRAM memory usage amounts to 52.1% of the model’s size.

Latency Analysis: Using a window size of 5, each token requires access to 2.4%
of the Feed Forward Network (FFN) neurons. For a 32-bit model, the data chunk
size per read is $2d_{\text{model}}\times 4\text{ bytes}=32\text{ KiB}$, as it
involves concatenated rows and columns. On an M1 Max, this results in a
latency of $125ms$ per token for loading from flash and $65ms$ for memory
management (involving neuron deletion and addition). Thus, the total memory-
related latency is less than $190ms$ per token (refer to Figure 1). In
contrast, the baseline approach, which requires loading 13.4GB of data at a
speed of 6.1GB/s, leads to a latency of approximately $2330ms$ per token.
Therefore, our method represents a substantial improvement over the baseline.

For a 16-bit model on a GPU machine, the flash load time is reduced to
$40.5ms$, and memory management takes $40ms$, slightly higher due to the
additional overhead of transferring data from CPU to GPU. Nevertheless, the
baseline method’s I/O time remains above 2000 milliseconds.

Detailed comparisons of how each method impacts performance are provided in
Table 2.

Table 2: The I/O latency of OPT 6.7B 16 bit on M1 max for different techniques
when half the memory is available

Configuration | Performance Metrics
---|---
Hybrid | Predictor | Windowing | Bundling | DRAM (GB) | Flash$\rightarrow$ DRAM(GB) | Throughput (GB/s) | I/O Latency (ms)
✗ | ✗ | ✗ | ✗ | 0 | 13.4 GB | 6.10 GB/s | 2130 ms
✓ | ✗ | ✗ | ✗ | 6.7 | 6.7 GB | 6.10 GB/s | 1090 ms
✓ | ✓ | ✗ | ✗ | 4.8 | 0.9 GB | 1.25 GB/s | 738 ms
✓ | ✓ | ✓ | ✗ | 6.5 | 0.2 GB | 1.25 GB/s | 164 ms
✓ | ✓ | ✓ | ✓ | 6.5 | 0.2 GB | 2.25 GB/s | 87 ms

###  4.2 Results for Falcon 7B Model

To verify that our findings generalize beyond OPT models we also apply the
idea of LLM in flash to Falcon model. Since, the base line Falcon model is not
sparse, we used a sparsified (relufied) version with almost the same
performance as that of the base version (Mirzadeh et al., 2023). Similar to
previous section, we present the results obtained under the condition that
approximately half of the model size is available for use in DRAM.

Predictors. In the Falcon 7B model, predictors of rank $r=256$ are used for
the initial 28 layers, and $r=1152$ for the last four layers.

Window Configuration. Our model reserves memory for a window containing the
last 4 tokens. This setup utilizes 33% of the Feed Forward Network (FFN). In
terms of memory allocation, embeddings take 4.2% of the model size, attention
weights account for 19.4%, and predictors require 4%. The active portion of
the FFN, given our window size, is 25.3% (calculated as $0.33\times 76.8$).
Overall, this amounts to 52.93% of the model’s total size.

Latency Analysis. Using a window size of 4 in our model requires accessing
3.1% of the Feed Forward Network (FFN) neurons for each token. In a 32-bit
model, this equates to a data chunk size of 35.5 KiB per read (calculated as
$2d_{\text{model}}\times 4\text{ bytes}$). On an M1 Max device, the time taken
to load this data from flash memory is approximately 161ms, and the memory
management process adds another 90ms, leading to a total latency of 250ms per
token. In comparison, the baseline latency is around 2330 milliseconds, making
our method approximately 9 to 10 times faster.

##  5 Related Works

Efficient Inference for Large Language Models. As LLMs grow in size, reducing
their computational and memory requirements for inference has become an active
area of research. Approaches broadly fall into two categories: model
compression techniques like pruning and quantization (Han et al., 2016b; Sun
et al., 2023; Jaiswal et al., 2023; Xia et al., 2023), (Zhang et al., 2022a;
Xu et al., 2023; Shao et al., 2023; Lin et al., 2023; Hoang et al., 2023; Zhao
et al., 2023; Ahmadian et al., 2023; Liu et al., 2023a; Li et al., 2023), and
selective execution like sparse activations (Liu et al., 2023b), (Mirzadeh et
al., 2023) or conditional computation (Graves, 2016; Baykal et al., 2023). Our
work is complementary, focusing on minimizing data transfer from flash memory
during inference.

Selective Weight Loading. Most related to our approach is prior work on
selective weight loading. SparseGPU (Narang et al., 2021) exploits activation
sparsity to load a subset of weights for each layer. However, it still
requires loading from RAM. Flexgen (Sheng et al., 2023) offloads the weights
and kv-cache from GPU memory to DRAM and DRAM to flash memory, in contrast we
consider only the cases the full model can’t reside in the whole DRAM and GPU
memory on the edge devices. Flexgen is theoretically bound by the slow
throughput of flash to DRAM in such scenarios. Firefly (Narang et al., 2022)
shares our goal of direct flash access but relies on a hand-designed schedule
for loading. In contrast, we propose a cost model to optimize weight loading.
Similar techniques have been explored for CNNs (Parashar et al., 2017), (Rhu
et al., 2013). Concurrently, Adapt (Subramani et al., 2022) has proposed
adaptive weight loading for vision transformers. We focus on transformer-based
LLMs and introduce techniques like neuron bundling tailored to LLMs.

To hide flash latency, we build on speculative execution techniques like
SpAtten (Dai et al., 2021), (Bae et al., 2023). However, we introduce
lightweight speculation tailored to adaptive weight loading.

Hardware Optimizations. There is a rich body of work on hardware optimizations
for efficient LLM inference, including efficient memory architectures (Agrawal
et al., 2022), (Gao et al., 2022), dataflow optimizations (Han et al., 2016a),
(Shao et al., 2022), hardware evaluation frameworks Zhang2023AHE, and flash
optimizations (Ham et al., 2016), (Meswani et al., 2015). We focus on
algorithmic improvements, but these could provide additional speedups.

Speculative Execution. Speculative decoding (Leviathan et al., 2022; Zhang et
al., 2023; He et al., 2023) is a technique that uses a draft model for
generation and uses the larger model to verify those tokens. This technique is
orthogonal to us and can be used for further improvement. In case of
speculative decoding, the window in our method should be updated with multiple
tokens rather one.

Mixture of Experts. Mixture of Experts (Yi et al., 2023) have a sparse
structure in their feed forward layer. This property can be used to combine
with our method for enabling larger MoEs on device.

In summary, we propose algorithmic techniques to minimize weight loading from
flash memory during LLM inference. By combining cost modeling, sparsity
prediction, and hardware awareness, we demonstrate 4-5x and 20-25x speedup on
CPU and GPU, respectively.

##  6 Conclusion

In this study, we have tackled the significant challenge of running large
language models (LLMs) on devices with constrained memory capacities. Our
approach, deeply rooted in the understanding of flash memory and DRAM
characteristics, represents a novel convergence of hardware-aware strategies
and machine learning. By developing an inference cost model that aligns with
these hardware constraints, we have introduced two innovative techniques:
’windowing’ and ’row-column bundling.’ These methods collectively contribute
to a significant reduction in the data load and an increase in the efficiency
of memory usage.

The practical outcomes of our research are noteworthy. We have demonstrated
the ability to run LLMs up to twice the size of available DRAM, achieving an
acceleration in inference speed by 4-5x compared to traditional loading
methods in CPU, and 20-25x in GPU. This breakthrough is particularly crucial
for deploying advanced LLMs in resource-limited environments, thereby
expanding their applicability and accessibility.

Our work not only provides a solution to a current computational bottleneck
but also sets a precedent for future research. It underscores the importance
of considering hardware characteristics in the development of inference-
optimized algorithms, suggesting a promising direction for further
explorations in this domain. We believe as LLMs continue to grow in size and
complexity, approaches like this work will be essential for harnessing their
full potential in a wide range of devices and applications.

## Acknowledgements

We’d like to thank Itay Sagron, Lailin Chen, Mahyar Najibi, Qichen Fu, Moin
Nabi, Sachin Mehta, Mohammad Samragh, Matt Johnson, Etai Zaltsman, Lin Chang,
Dominic Giampaolo, Taal Uliel, Aftab Munshi for the valuable discussion.

## References

  * Agrawal et al. (2022) Udit Agrawal, Rangharajan Venkatesan, Brucek Khailany, Stephen W Keckler, and William J Dally. 2022.  Atomlayer: minimizing dram data movement for ultra-sparse models on gpus.  In _Proceedings of the 27th ACM International Conference on Architectural Support for Programming Languages and Operating Systems_ , pages 223–238.
  * Ahmadian et al. (2023) Arash Ahmadian, Saurabh Dash, Hongyu Chen, Bharat Venkitesh, Stephen Gou, Phil Blunsom, A. Ustun, and Sara Hooker. 2023.  Intriguing properties of quantization at scale.  _ArXiv_ , abs/2305.19268.
  * Almazrouei et al. (2023) Ebtesam Almazrouei, Hamza Alobeidli, Abdulaziz Alshamsi, Alessandro Cappelli, Ruxandra Cojocaru, Maitha Alhammadi, Mazzotta Daniele, Daniel Heslow, Julien Launay, Quentin Malartic, Badreddine Noune, Baptiste Pannier, and Guilherme Penedo. 2023.  The falcon series of language models: Towards open frontier models.
  * Aminabadi et al. (2022) Reza Yazdani Aminabadi, Samyam Rajbhandari, Ammar Ahmad Awan, Cheng Li, Du Li, Elton Zheng, Olatunji Ruwase, Shaden Smith, Minjia Zhang, Jeff Rasley, et al. 2022\.  Deepspeed-inference: enabling efficient inference of transformer models at unprecedented scale.  In _SC22: International Conference for High Performance Computing, Networking, Storage and Analysis_ , pages 1–15. IEEE.
  * Bae et al. (2023) Sangmin Bae, Jongwoo Ko, Hwanjun Song, and Se-Young Yun. 2023.  Fast and robust early-exiting framework for autoregressive language models with synchronized parallel decoding.  _ArXiv_ , abs/2310.05424.
  * Baykal et al. (2023) Cenk Baykal, Dylan Cutler, Nishanth Dikkala, Nikhil Ghosh, Rina Panigrahy, and Xin Wang. 2023.  Alternating updates for efficient transformers.  _ArXiv_ , abs/2301.13310.
  * Borzunov et al. (2023) Alexander Borzunov, Dmitry Baranchuk, Tim Dettmers, Maksim Riabinin, Younes Belkada, Artem Chumachenko, Pavel Samygin, and Colin Raffel. 2023.  Petals: Collaborative inference and fine-tuning of large models.  In _Proceedings of the 61st Annual Meeting of the Association for Computational Linguistics (Volume 3: System Demonstrations)_ , pages 558–568, Toronto, Canada. Association for Computational Linguistics.
  * Brown et al. (2020) Tom Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared D Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. 2020.  Language models are few-shot learners.  _Advances in neural information processing systems_ , 33:1877–1901.
  * Chowdhery et al. (2022) Aakanksha Chowdhery, Sharan Narang, Jacob Devlin, Maarten Bosma, Gaurav Mishra, Adam Roberts, Paul Barham, Hyung Won Chung, Charles Sutton, Sebastian Gehrmann, et al. 2022.  Palm: Scaling language modeling with pathways.  _arXiv preprint arXiv:2204.02311_.
  * Dai et al. (2021) Han Dai, Yi Zhang, Ziyu Gong, Nanqing Yang, Wei Dai, Eric Song, and Qiankun Xie. 2021.  Spatten: Efficient sparse attention architecture with cascade token and head pruning.  In _Advances in Neural Information Processing Systems_ , volume 34.
  * Gao et al. (2022) Mingyu Gao, Jie Yu, Wentai Li, Michael C Dai, Nam Sung Kim, and Krste Asanovic. 2022\.  computedram: In-memory compute using off-the-shelf dram.  In _Proceedings of the 27th ACM International Conference on Architectural Support for Programming Languages and Operating Systems_ , pages 1065–1079.
  * Graves (2016) Alex Graves. 2016.  Adaptive computation time for recurrent neural networks.  In _International Conference on Machine Learning_ , pages 3500–3509. PMLR.
  * Ham et al. (2016) Jongmin Ham, Jinha Kim, Jinwoong Choi, Cheolwoo Cho, Seulki Hong, Kyeongsu Han, and Taejoo Chung. 2016.  Graphssd: a high performance flash-based storage system for large-scale graph processing.  In _2016 USENIX Annual Technical Conference (USENIXATC 16)_ , pages 243–256.
  * Han et al. (2016a) Song Han, Xingyu Liu, Huizi Mao, Jing Pu, Ardavan Pedram, Mark A Horowitz, and William J Dally. 2016a.  Eie: efficient inference engine on compressed deep neural network.  _arXiv preprint arXiv:1602.01528_.
  * Han et al. (2016b) Song Han, Huizi Mao, and William J Dally. 2016b.  Deep compression: Compressing deep neural networks with pruning, trained quantization and huffman coding.  In _International Conference on Learning Representations (ICLR)_.
  * He et al. (2023) Zhenyu He, Zexuan Zhong, Tianle Cai, Jason D Lee, and Di He. 2023.  Rest: Retrieval-based speculative decoding.  _ArXiv_ , abs/2311.08252.
  * Hoang et al. (2023) Duc Nien Hoang, Minsik Cho, Thomas Merth, Mohammad Rastegari, and Zhangyang Wang. 2023.  (dynamic) prompting might be all you need to repair compressed llms.  _ArXiv_ , abs/2310.00867.
  * Jaiswal et al. (2023) Ajay Jaiswal, Zhe Gan, Xianzhi Du, Bowen Zhang, Zhangyang Wang, and Yinfei Yang. 2023.  Compressing llms: The truth is rarely pure and never simple.  _ArXiv_ , abs/2310.01382.
  * Leviathan et al. (2022) Yaniv Leviathan, Matan Kalman, and Yossi Matias. 2022.  Fast inference from transformers via speculative decoding.
  * Li and Lu (2023) Jiaxi Li and Wei Lu. 2023.  Contextual distortion reveals constituency: Masked language models are implicit parsers.  In _Proceedings of the 61st Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers)_ , pages 5208–5222, Toronto, Canada. Association for Computational Linguistics.
  * Li et al. (2023) Liang Li, Qingyuan Li, Bo Zhang, and Xiangxiang Chu. 2023.  Norm tweaking: High-performance low-bit quantization of large language models.  _ArXiv_ , abs/2309.02784.
  * Lin et al. (2023) Ji Lin, Jiaming Tang, Haotian Tang, Shang Yang, Xingyu Dang, and Song Han. 2023\.  Awq: Activation-aware weight quantization for llm compression and acceleration.  _ArXiv_ , abs/2306.00978.
  * Liu et al. (2023a) Zechun Liu, Barlas Oğuz, Changsheng Zhao, Ernie Chang, Pierre Stock, Yashar Mehdad, Yangyang Shi, Raghuraman Krishnamoorthi, and Vikas Chandra. 2023a.  Llm-qat: Data-free quantization aware training for large language models.  _ArXiv_ , abs/2305.17888.
  * Liu et al. (2023b) Zichang Liu, Jue Wang, Tri Dao, Tianyi Zhou, Binhang Yuan, Zhao Song, Anshumali Shrivastava, Ce Zhang, Yuandong Tian, Christopher Re, et al. 2023b.  Deja vu: Contextual sparsity for efficient llms at inference time.  In _International Conference on Machine Learning_ , pages 22137–22176. PMLR.
  * Meswani et al. (2015) Moinuddin K Meswani, Sergey Blagodurov, David Roberts, John Slice, Mike Ignatowski, and Gabriel Loh. 2015.  Neural cache: Bit-serial in-cache acceleration of deep neural networks.  In _2015 48th Annual IEEE/ACM International Symposium on Microarchitecture (MICRO)_ , pages 383–394. IEEE.
  * Mirzadeh et al. (2023) Iman Mirzadeh, Keivan Alizadeh, Sachin Mehta, Carlo C Del Mundo, Oncel Tuzel, Golnoosh Samei, Mohammad Rastegari, and Mehrdad Farajtabar. 2023.  Relu strikes back: Exploiting activation sparsity in large language models.
  * Narang et al. (2022) Sharan Narang, Logan Feistel, Erich Elsen Undersander, Cindy Song, and Gregory Diamos. 2022.  Firefly: A lightweight system for running multi-billion parameter models on commodity hardware.  In _2022 ACM/IEEE 49th Annual International Symposium on Computer Architecture (ISCA)_ , pages 757–771. IEEE.
  * Narang et al. (2021) Sharan Narang, Erich Elsen Undersander, and Gregory Diamos. 2021.  Sparse gpu kernels for deep learning.  In _International Conference on Learning Representations_.
  * Parashar et al. (2017) Angshuman Parashar, Minsoo Rhu, Anurag Mukkara, Antonio Puglielli, Rangharajan Venkatesan, Brucek Khailany, Joel Emer, Stephen W Keckler, and William J Dally. 2017.  Timeloop: A systematic approach to dnn accelerator evaluation.  In _2017 IEEE International Symposium on Performance Analysis of Systems and Software (ISPASS)_ , pages 241–251. IEEE.
  * Rajbhandari et al. (2021) Samyam Rajbhandari, Olatunji Ruwase, Jeff Rasley, Shaden Smith, and Yuxiong He. 2021\.  Zero-infinity: Breaking the gpu memory wall for extreme scale deep learning.  In _SC21: International Conference for High Performance Computing, Networking, Storage and Analysis_ , pages 1–14.
  * Rhu et al. (2013) Minsoo Rhu, Natalia Gimelshein, Jason Clemons, Arslan Zulfiqar, and Stephen W Keckler. 2013.  vdnn: Virtualized deep neural networks for scalable, memory-efficient neural network design.  In _2016 49th Annual IEEE/ACM International Symposium on Microarchitecture (MICRO)_ , page Article 13. IEEE Computer Society.
  * Shao et al. (2023) Wenqi Shao, Mengzhao Chen, Zhaoyang Zhang, Peng Xu, Lirui Zhao, Zhiqiang Li, Kaipeng Zhang, Peng Gao, Yu Jiao Qiao, and Ping Luo. 2023.  Omniquant: Omnidirectionally calibrated quantization for large language models.  _ArXiv_ , abs/2308.13137.
  * Shao et al. (2022) Yifan Shao, Mengjiao Li, Wenhao Cai, Qi Wang, Dhananjay Narayanan, and Parthasarathy Ranganathan. 2022.  Hotpot: Warmed-up gigascale inference with tightly-coupled compute and reuse in flash.  In _Proceedings of the 55th Annual IEEE/ACM International Symposium on Microarchitecture_ , pages 335–349.
  * Sheng et al. (2023) Ying Sheng, Lianmin Zheng, Binhang Yuan, Zhuohan Li, Max Ryabinin, Beidi Chen, Percy Liang, Christopher Ré, Ion Stoica, and Ce Zhang. 2023.  Flexgen: High-throughput generative inference of large language models with a single GPU.  In _International Conference on Machine Learning, ICML 2023, 23-29 July 2023, Honolulu, Hawaii, USA_ , volume 202 of _Proceedings of Machine Learning Research_ , pages 31094–31116. PMLR.
  * Subramani et al. (2022) Vedant Subramani, Marios Savvides, Li Ping, and Sharan Narang. 2022.  Adapt: Parameter adaptive token-wise inference for vision transformers.  In _Proceedings of the 55th Annual IEEE/ACM International Symposium on Microarchitecture_.
  * Sun et al. (2023) Mingjie Sun, Zhuang Liu, Anna Bair, and J. Zico Kolter. 2023.  A simple and effective pruning approach for large language models.  _ArXiv_ , abs/2306.11695.
  * Xia et al. (2023) Haojun Xia, Zhen Zheng, Yuchao Li, Donglin Zhuang, Zhongzhu Zhou, Xiafei Qiu, Yong Li, Wei Lin, and Shuaiwen Leon Song. 2023.  Flash-llm: Enabling low-cost and highly-efficient large generative model inference with unstructured sparsity.  _Proc. VLDB Endow._ , 17:211–224.
  * Xu et al. (2023) Zhaozhuo Xu, Zirui Liu, Beidi Chen, Yuxin Tang, Jue Wang, Kaixiong Zhou, Xia Hu, and Anshumali Shrivastava. 2023.  Compress, then prompt: Improving accuracy-efficiency trade-off of llm inference with transferable prompt.  _ArXiv_ , abs/2305.11186.
  * Yi et al. (2023) Rongjie Yi, Liwei Guo, Shiyun Wei, Ao Zhou, Shangguang Wang, and Mengwei Xu. 2023\.  Edgemoe: Fast on-device inference of moe-based large language models.  _ArXiv_ , abs/2308.14352.
  * Zhang et al. (2023) Jinchao Zhang, Jue Wang, Huan Li, Lidan Shou, Ke Chen, Gang Chen, and Sharad Mehrotra. 2023.  Draft & verify: Lossless large language model acceleration via self-speculative decoding.  _ArXiv_ , abs/2309.08168.
  * Zhang et al. (2022a) Shizhao Zhang, Han Dai, Tian Sheng, Jiawei Zhang, Xiaoyong Li, Qun Xu, Mengjia Dai, Yunsong Xiao, Chao Ma, Rui Tang, et al. 2022a.  Llm quantization: Quantization-aware training for large language models.  In _Advances in Neural Information Processing Systems_ , volume 35.
  * Zhang et al. (2022b) Susan Zhang, Stephen Roller, Naman Goyal, Mikel Artetxe, Moya Chen, Shuohui Chen, Christopher Dewan, Mona T. Diab, Xian Li, Xi Victoria Lin, Todor Mihaylov, Myle Ott, Sam Shleifer, Kurt Shuster, Daniel Simig, Punit Singh Koura, Anjali Sridhar, Tianlu Wang, and Luke Zettlemoyer. 2022b.  OPT: open pre-trained transformer language models.  _CoRR_ , abs/2205.01068.
  * Zhao et al. (2023) Yilong Zhao, Chien-Yu Lin, Kan Zhu, Zihao Ye, Lequn Chen, Size Zheng, Luis Ceze, Arvind Krishnamurthy, Tianqi Chen, and Baris Kasikci. 2023.  Atom: Low-bit quantization for efficient and accurate llm serving.  _ArXiv_ , abs/2310.19102.


11institutetext: Grupo de Dinâmica Orbital e Planetologia, São Paulo State
University, UNESP, Guaratinguetá, CEP 12516-410, São Paulo, Brazil
11email<EMAIL_ADDRESS>22institutetext: 22email:
<EMAIL_ADDRESS>
# Constraining the nature of the possible extrasolar PDS110b ring system

Tiago F. L. L. Pinheiro 11 Rafael Sfair 22

(Received —; accepted June 17, 2021)

The young star PDS110 in the Ori OB1a association underwent two similar
eclipses in 2008 and 2011, each of which lasted for a period of at least 25
days. One plausible explanation for these events is that the star was eclipsed
by an unseen giant planet (named PDS110b) circled by a ring system that fills
a large fraction of its Hill sphere. Through thousands of numerical
simulations of the three-body problem, we constrain the mass and eccentricity
of this planet as well the size and inclination of its ring, parameters that
are not well determined by the observational data alone. We carried out a
broad range of different configurations for the PDS110b ring system and ruled
out all that did not match with the observations. The result shows that the
ring system could be prograde or retrograde; the preferred solution is that
the ring has an inclination lower than $60^{\circ}$ and a radius between 0.1
and 0.2 au and that the planet is more massive than $35M_{\mathrm{Jup}}$ and
has a low eccentricity (¡ 0.05).

###### Key Words.:

Planets and satellites: rings – Planets and satellites: dynamical evolution
and stability – Eclipses

##  1 Introduction

The first exoplanet discovered was around a pulsar, PSR1257+12 (Wolszczan &
Frail, 1992), and three years later the first detection of a planet (51 Pegasi
b) orbiting a solar-type star occurred (Mayor & Queloz, 1995). In our Solar
System, all four giant planets host ring systems; however, as of now, no
extrasolar ring system (exoring) has been detected, and the detection of a
Saturn-like ring system requires high time-resolution photometry (Barnes &
Fortney, 2004). The most useful method for detecting the presence of a ring is
the planetary transit (Akinsanmi et al., 2020), and several works have
searched for signatures of a planetary ring system around extrasolar Kepler
planet candidates (e.g., Heising et al. 2015, Aizawa et al. 2017, and Aizawa
et al. 2018).

Schlichting & Chang (2011) analyzed the nature of possible ring systems that
could exist around an exoplanet with an orbital period of about one year or
less. Their results show that $24\%$ of the evaluated planets have the
necessary conditions to support sizable rings, and, since these planets would
be very close to their host star, the orbiting disk around them probably
consists of rocky material.

The first exoring candidate was reported in 2007, when the star J1407
underwent a complex series of eclipses that lasted about 56 days and achieved
a depth greater than three magnitudes (Mamajek et al., 2012). One potential
solution for this event is the passage of a giant ring that extends out to a
radius of 0.6 au, surrounding an unseen secondary companion that is in front
of the star. The structure has a gap at 0.4 au, which, according to Kenworthy
& Mamajek (2015), could be a result of an exomoon clearing out this region.
This exosatellite is expected to have a mass comparable to that of the Earth.
Rieder & Kenworthy (2016) investigated, through numerical simulation, the
effect on the stability of the ring system around J1407b in an eccentric orbit
(0.6 $\leq$ $e$ $\leq$ 0.7) and with an orbital period of 11 years. The
results strongly suggest that a retrograde ring and a secondary companion with
a mass of 60-100 $M_{\mathrm{Jup}}$ can fit the observable eclipse.

Speedie & Zanazzi (2020) investigated the stability and structure of a
circumplanetary ring system around an oblate and oblique planet under the
influence of the spinning planet’s mass quadrupole coefficient ($J_{2}$)
through N-body integrations. Their results show that a massive planet
($10M_{\mathrm{Jup}}$) orbiting a Sun-like star either in circular or
eccentric orbit can wrap a stable ring that extends out to a $2$ Laplace
radius. The authors identified two main instability mechanisms. The first is
the Lidov-Kozai instability, which occurs for a planet with an obliquity of
$80^{\circ}$, and the second is ivection instability. Even though there is no
measurement of the oblateness coefficient, they assumed $J_{\mathrm{2}}=0.5$
for J1407b (30 times larger than Saturn’s), finding that the likely mass for
the planet is greater than $13M_{\mathrm{Jup}}$.

Another possible exoring structure was found in the PDS110 system. The young
star PDS110 ($\sim$ 11 Myr old), which is roughly two times more massive than
the Sun, underwent two series of eclipses in 2008 and 2011, with each dimming
event lasting about 25 days with a depth of 30%. The infrared excess in the
total luminosity of PDS110 indicates the presence of a dust disk encircling
the star, and the similarity between the events suggests the presence of a
periodic unseen secondary companion surrounded by a circum-secondary disk
structure (Osborn & Rodriguez, 2017). Another eclipse was predicted to happen
in 2017, and a ground-based observing campaign was organized to monitor the
event. However, no drop greater than $1\%$ was detected. Osborn & Kenworthy
(2019) propose that, instead of a ring, a circumstellar dust disk around
PDS110 could be the source of variability. Future observations can confirm the
existence of this ring system and the secondary companion.

A number of characteristics of the secondary companion could not be well
determined from the observations. Osborn & Rodriguez (2017) reported that the
hypothetical companion orbits the PDS110 star at 2 au and that its mass is in
the range of [1.8 - 70] $M_{\mathrm{Jup}}$, which would indicate it is a
planet or a brown dwarf. The presumed ring would have a radius of about 0.15
au.

The goal of this work is to analyze the stability of a putative exoring system
around an eccentric, massive planet at 2 au from the PDS110 star that matches
with the eclipses that occurred in 2008 and 2011. Given the extensive range of
possible values for a planet’s mass and eccentricity, ring size, and
inclination, we aim to restrict the physical and orbital parameters of this
system through numerical simulation.

In Sect. 2 we describe in detail the ring system and the two main eclipses. In
Sect. 3 we present the first constraints on the upper limit for the
eccentricity of the planet, while in Sect. 4 we report the numerical model for
the putative systems, exploring different values for the mass and eccentricity
of the planet and for the orbital inclination of the ring. The results of the
numerical simulations are discussed in Sect. 5, for both prograde and
retrograde cases. Our final remarks are presented in the last section.

##  2 The PDS110b ring system

The star PDS110, also identified as IRAS 05209-0107 or HD290380, is an $\sim$
11 Myr old GE/FE-type star and a member of the Ori OB1a association at a
distance of 345 $\pm$ 40 pc (Brown et al., 2016). It has a radius roughly
equivalent to the diameter of the Sun (2.23 $R_{\mathrm{\astrosun}}$) and a
mass $\sim$ 1.6 times the solar mass. The presence of infrared excess,
approximately 25% of the total luminosity ($L_{\mathrm{IR}}/L_{\mathrm{bol}}$
= 0.25; Osborn & Rodriguez, 2017), indicates the presence of two
protoplanetary disks surrounding the star: an inner one with an extension of
approximately 0.2 au, too small to be directly detected by images, and a
second inclined outer disk, formed by dust with an extension of up to 300 au.

The PDS110 system underwent two similar dimming events, each over 25 days and
with a brightness drop of $\sim$ 30%. The events were observed in 2008 and
2011, as reported by Osborn & Rodriguez (2017) and Osborn & Kenworthy (2019).
An analysis by Osborn & Rodriguez (2017) investigated two different
interpretations for the eclipses. The first possible explanation was the
passage of an inclined disk around an unseen low mass secondary companion,
possibly a brown dwarf or a giant planet. The authors concluded that any large
disk around PDS110 would have been detected in the optical spectra, as would
any indication of a secondary star in the system. The second and more probable
explanation for the eclipses is that a circumplanetary disk around PDS110b
caused them.

The interval of two years between eclipses suggests an orbital period for the
secondary companion of 808 days. Considering that the mass of the star is 1.6
$M_{\odot}$, the estimated semimajor axis of PDS110b would be $\sim$ 2 au. An
analytical analysis of the eclipse made by Osborn & Rodriguez (2017), assuming
a circular orbit for the planet, implies that the secondary companion may have
a mass between 1.8 and 70 $M_{\mathrm{Jup}}$. Furthermore, from the orbital
speed and eclipse duration, and assuming the secondary has a circular orbit,
the authors estimated the disk diameter to be around 0.3 au. Based on the
observational data, no constraint on the planet eccentricity was made.

Here we explore the case that the secondary body is a planet (hereafter called
PDS110b) that hosts an extensive ring system that was invisible during the
eclipses. Our goal is to better constrain the physical and orbital parameters
of the PDS110b system through numerical simulations and some analytical
analysis in order to explain the dimming events.

##  3 Constraints on the eccentricity of PDS110b

Initially, we performed an analytic analysis to constrain an upper limit for
the eccentricity of PDS110b by correlating the ring orbital radius with the
Hill region of the planet.

The Hill radius ($r_{\mathrm{Hill}}$) is the distance from the planet where
the gravitational influence of the host planet dominates over the stellar
perturbation. In the case of an eccentric orbit, the Hill radius can be
estimated as (Hamilton & Burns, 1992)

$\displaystyle r_{\mathrm{Hill}}\approx
a(1-e)\sqrt[3]{\frac{m_{\mathrm{p}}}{3M_{\mathrm{s}}}},$ (1)

where $a$ is the semimajor axis, $e$ is the eccentricity, and $m_{\mathrm{p}}$
and $M_{\mathrm{s}}$ are the masses of the planet and the star, respectively.

Since the disk inclination and the planet obliquity are unknown, we assume the
ring inclination observed from Earth is $0^{\circ}$ (face-on) and that the
ring is in the equatorial plane of the planet. Now let $t_{\mathrm{e}}$ be the
eclipse duration time, assuming the planet travels in a straight line with a
constant velocity $v_{\mathrm{e}}$. The radial size of the projected ring,
$r_{\mathrm{ring}}$, can be written as

$\displaystyle r_{\mathrm{ring}}=\frac{t_{\mathrm{e}}v_{\mathrm{e}}}{2},$ (2)

and the two parameters can be combined to define $\xi$ as the ratio between
the ring and the Hill radius

$\displaystyle\xi=\frac{r_{\mathrm{ring}}}{r_{\mathrm{Hill}}},$ (3)

which helps us understand the stability of the ring.

We considered the mass of the star to be $M_{\mathrm{s}}$ = 1.6
$M_{\mathrm{\astrosun}}$, the observed period of the planet to be $P=808$
days, and the eclipse to last $t_{\mathrm{e}}=25$ days. To explore an extreme
configuration, we assumed the ring to be in the orbital plane of the planet
and the eclipse to happen during the passage of the planet through the
apocenter (when the planet velocity is at its minimum). With these
assumptions, $\xi$ was calculated for the secondary companion mass in the
range of [1.8-70] $M_{\mathrm{Jup}}$ (Osborn & Rodriguez, 2017) and for
different values of eccentricity.

If $\xi<1$, the ring is within the gravitational domain of the planet. Hunter
(1967) studied the stability orbits of hypothetical satellites around Jupiter
disturbed by the Sun, with different values for the semimajor axis,
eccentricity, and inclination. Their results showed that the stability region
for prograde orbits is smaller than $0.45\leavevmode\nobreak\
r_{\mathrm{Hill}}$, while for retrograde orbits the extension of this region
is limited to $0.75r_{\mathrm{Hill}}$. Domingos et al. (2006) studied the
stability zone of satellites around extrasolar giant planets and verified that
the limit of the stable region is $\sim 0.5\leavevmode\nobreak\
r_{\mathrm{Hill}}$ for prograde orbits and around $\sim
0.95\leavevmode\nobreak\ r_{\mathrm{Hill}}$ for the retrograde case (they
restricted the analysis to a mass ratio between the massive bodies of a
maximum of $10^{-3}$). Therefore, in our analysis we consider systems to be
stable when $\xi<0.5$.

Figure 1 shows $\xi$ as a function of the mass of the planet for different
values of the planet’s eccentricity ($e_{\mathrm{p}}$). The horizontal line
corresponds to the stability limit of $\xi=0.5$, allowing us to constrain the
mass of the planet to be greater than $35M_{\mathrm{Jup}}$ and to rule out
systems where the eccentricity of the planet is larger than 0.5.

Figure 1: Factor $\xi$ in terms of planet mass ($m_{\mathrm{p}}$) and its
eccentricity ($e_{\mathrm{p}}$). The line at $\xi$ = 0.5 delineates the
stability zone (which is below this line).

The high eccentricity implies that the planet transit velocity is greater than
$15$ km/s, which is consistent with the minimal eclipse velocity detected by
Osborn & Rodriguez (2017) through observational data. From the flux increase
in the light curve, they calculated the minimum velocity of the object during
the event to be $v_{min}=13kms^{-1}$.

##  4 Numerical method

To investigate the possible physical and orbital parameters of the PDS110b
ring system, we numerically modeled the system as an ensemble of three-body
problems: the star, a planet, and the ring particle, where each numerical
simulation represents one different initial condition of the system. In total,
we ran $1.3\times 10^{6}$ different simulations.

For all models, we set the values of PDS110 and its companion, PDS110b, to be
in agreement with the values from Osborn & Rodriguez (2017). The mass of the
star is 1.6 $M_{\mathrm{\astrosun}}$, and its radius is 2.23
$M_{\mathrm{\astrosun}}$. The parameters of the hypothetical planet were
assumed considering the following grid of parameters: The semimajor axis
($a_{\mathrm{p}}$) is fixed to 2 au, while the eccentricity ($e_{\mathrm{p}}$)
and the mass ($m_{\mathrm{p}}$) are randomly chosen within the ranges of 0 to
0.5 and 1.8 to 70 $M_{\mathrm{Jup}}$, respectively. These intervals were
determined based on the references presented in Sect. 2; however, for the sake
of completeness, we decided to analyze the entire mass range proposed in
Osborn & Rodriguez (2017). The radius of the planet ($r_{p}$) was calculated
assuming a density of 1.326 kg/m3 (the same as Jupiter’s).

We considered the ring particle as a test particle orbiting the planet and
gravitationally perturbed by the star. The particle is initially in a circular
orbit, and the semimajor axis ($a$) is chosen randomly from the range 0.01 to
0.5 au and the true anomaly ($f$) from $0^{\circ}$ to $360^{\circ}$. We
assumed the other parameters of the particles, the longitude of the ascending
node ($\Omega$) and the argument of pericenter ($\omega$), to be $0^{\circ}$.
Assuming the possibility that the eclipses occurred via an inclined ring
(Osborn & Rodriguez, 2017), we varied, for each set of $10^{5}$ numerical
simulations, the inclination of the particle ($i$), defined as the angle
between the ring plane and the orbital planet of the planet, from $0^{\circ}$
to $180^{\circ}$ in steps of $\Delta i=15^{\circ}$.

The time span for all numerical simulations was set as $250\times 10^{4}$
days, the equivalent of $10^{4}$ orbital periods of the particle with a
semimajor axis a = 0.5 au and orbiting a planet with a mass of 1.8
$M_{\mathrm{Jup}}$. Among all the possible scenarios, this is the largest
period that one particle could have. The numerical integrations were carried
out with the Rebound package using the IAS15 integrator (Rein & Spiegel,
2014).

Whenever the particle collided with one of the massive bodies or was ejected
from the system, the simulation was interrupted. The collisions were defined
when the distance between the particle and a massive body (star or planet) was
smaller than the body’s radius, and particles were considered ejected when
their orbit became hyperbolic ($e<1$) in reference to the planet. All the
particles that survived the entire time of integration were considered to be
stable.

We divided our set of simulations into 1820 different groups according to the
inclination of the ring particle, the eccentricity, and the mass of the
planet, by grouping them within the following intervals: $\Delta
i=15^{\circ}$, $\Delta e_{\mathrm{p}}$ = 0.05, and $\Delta
m_{\mathrm{p}}\approx$ 5 $M_{\mathrm{Jup}}$. For each set, we determined the
radial distribution of the surviving particles throughout the entire
integration. To remove outliers, the ring extension ($r_{\mathrm{ring}}$) in
each group was defined as the semimajor axis distance from the farthest
particle within the area where the nearest 98% of the ensemble remained.

##  5 Numerical results

Given the large number of variables, we explored thousands of different sets
of initial conditions within the ranges described in Sect. 4. For the complete
ensemble, the overall outcome was as follows: 6.3% of the cases ended in
collision and 72.2% ended in escape, while in the remaining 21.5% of the cases
the particles remained stable throughout the entire integration. It is
interesting to note that the majority of the unstable particles ($\sim$ 93%)
were ejected or collided with one of the massive bodies in less than 40
orbital periods of the planet (¡ 80 years).

We also verified the relation between the orbital inclination of the particle
and the ring radius (Fig. 2). Each dot represents a group of simulations. We
see that the ring extension varies largely depending on the inclination, going
from less than $0.05$ au for the smallest scenario up to almost $0.4$ au.

When the inclination is $90^{\circ}$, all particles are unstable, regardless
of the mass of the planet. The figure also shows that the range of the ring
size increases for larger inclinations. For prograde rings ($i<90^{\circ}$)
the maximum extension is around 0.22 au, while for retrograde rings, where the
systems are more stable, the ring reaches 0.38 au in radius.

Figure 2: Ring radius of each group of simulations based on a ring inclination
from i = [$0^{\circ}$ to $180^{\circ}$].

The numerical results presented in Figs. 3 and 4 (prograde and retrograde
cases, respectively) are the diagrams of the particles’ semimajor axis ($a$)
versus particle eccentricity ($e$) for the stable particles. Each plot
represents systems with different planet masses but the same ring inclination.

(a)

(b)

(c)

(d)

(e)

(f)

Figure 3: Set of diagrams: the semimajor axis versus the eccentricity of the
stable particles (in black) for the prograde case. In the different plots the
ring particle inclination is: (a) $0^{\circ}$; (b) $15^{\circ}$; (c)
$30^{\circ}$; (d) $45^{\circ}$; (e) $60^{\circ}$; and (f) $75^{\circ}$.

(a)

(b)

(c)

(d)

(e)

(f)

Figure 4: Set of diagrams: the semimajor axis ($a$) versus the eccentricity of
the stable particles (in black) for the retrograde case. The ring particle
inclination is: (a) $105^{\circ}$; (b) $120^{\circ}$; (c) $135^{\circ}$; (d)
$150^{\circ}$; (e) $165^{\circ}$; and (f) $180^{\circ}$. The diagram for i=
$90^{\circ}$ is missing because no stable region exists in this case.

The initially circular ring particles quickly became eccentric, and this
effect is more prominent for highly inclined rings. Figure 3 shows that for
$i\leq 30^{\circ}$ (panels a to c) the majority of particles are found within
$e<0.3$ and $a<0.2$ au. For $i=45^{\circ}$ the stable particles are mostly
confined to $e\leq 0.4$ and $a\leq 0.2$ au. In the range of $i=$
[$60^{\circ}$, $75^{\circ}$], a significant number of particles present large
eccentricities, reaching values close to unity with $a\leq 0.22$ au.

No stable particle is found with an inclination around $90^{\circ}$. In the
retrograde case (Fig. 4), for $i=105^{\circ}$ the maximum semimajor axis
distance of the stable region is around $0.13$ au, and these values increase
when the ring inclination is $180^{\circ}$, reaching as high as $a\sim 0.4$
au. The maximum particle eccentricity decreases as the ring inclination rises:
The value of $e$ goes from almost 1 for $i=105^{\circ}$ (Fig. 4a) to $e\leq
0.7$ for $i=180^{\circ}$ (Fig. 4f).

###  5.1 Eclipse duration

For each group of simulations, we calculated the theoretic eclipse time
($t_{\mathrm{e}}$) according to Eq. 2, always assuming a face-on
configuration. To identify the physical and orbital parameters of the PDS110b
system from the numerical results, we assumed the planet semimajor axis to be
2 au and its orbital period to be 808 days. We considered the ring radius to
be the semimajor axis of the most distant particle and considered the planet
velocity derived in two different positions of its orbit, at pericenter and
apocenter (extreme cases).

The interval of all possible theoretical eclipse times ($t_{e}$) for each
group of simulations is presented in Figs. 5 to 11. In each plot the
horizontal line corresponds to the observed eclipse duration (25 days), thus
indicating which configurations (planet mass and eccentricity, ring extension,
and inclination) for the PDS110b ring system could reproduce the observed
events.

Figure 5 shows that both prograde and retrograde ring systems may explain the
transit events when considering orbital inclinations smaller than $60^{\circ}$
or higher than $120^{\circ}$. In the range $i=[75^{\circ}\leavevmode\nobreak\
-\leavevmode\nobreak\ 105^{\circ}]$ the stable ring is not large enough to
reproduce an eclipse that matches the observation. We now divide the
discussion into two sections, the prograde and retrograde cases.

Figure 5:  Eclipse duration for different ring system inclinations. Each
vertical bar represents the possible duration of the eclipses for a given
inclination assuming the different ring extensions. The dot indicates the
average value of each box, and the dashed line represents the observed eclipse
(25 days).

###  5.2 Prograde case

Out of our set of 1820 groups of simulations, half correspond to prograde
orbits of the planet. In this case, the ring inclination is required to be
smaller than $60^{\circ}$ to produce an eclipse that lasts 25 days. It is most
likely that in these systems the mass of the secondary companion is larger
than 35 $M_{\mathrm{Jup}}$ (Fig. 6), which is consistent with the results
presented in Fig. 3.

Figure 6: Influence of the mass of the planet on the eclipse time, for
prograde systems. The rectangles indicate the duration of the possible
eclipses within a specific mass range, grouped every $\Delta
m_{\mathrm{p}}\approx$ 5 $M_{\mathrm{Jup}}$.

It is also possible to group the ring extension for the simulated systems
according to the eccentricity of the planet (Fig. 7). Assuming the eclipse
occurred at the apocenter of the planet, any eccentricity $e_{\mathrm{p}}$ ¡
0.3 is possible. However, if we consider that the eclipse took place at the
pericenter, only a planet with a circular or slightly eccentric orbit
($e_{\mathrm{p}}<0.05$) could have a disk capable of consistently explaining
the transit time, suggesting that a planet with a lower eccentricity is more
plausible.

Planets with a higher eccentricity present a less extensive ring system, and
this directly influences the eclipse duration. This is expected since the
planet is reasonably close to the star (2 au) and since the outermost
particles are increasingly perturbed by the star as the orbit becomes more
eccentric.

Figure 7: Time span of the duration of the eclipses for a prograde ring
grouped according to the eccentricity of the planet ($e_{\mathrm{p}}$). In the
panel on the left, the eclipse is occurring at the pericenter, and on the
right the eclipse is occurring during the planet passage at the apocenter. The
dashed line represents the observable eclipse (25 days).

We computed the eclipse duration for each of the 910 prograde cases, assuming
that the planet is either in the pericenter or the apocenter (Fig. 8). Given
that the velocity of the planet is maximum at the pericenter, the planet
requires a ring with an extension of $\sim 0.2$ au to produce a 25-day eclipse
when viewed face-on. Conversely, at the apocenter (thus, at a lower velocity),
a ring extension from 0.1 to 0.2 au matches the observation. This range
corresponds to less than 0.5 $r_{\mathrm{Hill}}$, which is compatible with
previous works.

Figure 8: Eclipse time according to the ring radius for planets with a
prograde orbit. The eclipse duration changes if it is assumed that the event
occurs at the pericenter of the orbit (open circles) or the apocenter (filled
circles). The dashed line indicates the observed eclipse.

###  5.3 Retrograde case

Retrograde systems can also sustain a ring that is large enough to be
consistent with a transit that lasts 25 days. In fact, given the more
extensive distribution of stable particles (see Fig. 4), more retrograde
systems fit the eclipse than prograde orbit systems. When grouping the
simulations according to the mass of the planet (Fig. 4), we see that only
systems where $m_{\mathrm{p}}<5\leavevmode\nobreak\ M_{\mathrm{Jup}}$ cannot
explain the eclipse.

Figure 9: Influence of the mass of the planet on the eclipse time, for
retrograde systems. The rectangles indicate the duration of the possible
eclipses within a specific mass range, grouped every $\Delta
m_{\mathrm{p}}\approx$ 5 $M_{\mathrm{Jup}}$.

Regarding the possible eccentricities of the planet, if the eclipse happens at
the apocenter (right panel in Fig. 10), any value smaller than 0.5 is allowed.
However, at the pericenter, where the orbital velocity is at its maximum, only
systems with a smaller eccentricity ($e_{\mathrm{p}}<0.25$) are plausible
solutions.

Figure 10: Time span of the duration of the eclipses for a retrograde system
according to the eccentricity of the planet ($e_{\mathrm{p}}$). In the panel
on the left, the eclipse is occurring at the pericenter, and on the right
during the planet passage at the apocenter.

Figure 11 shows the eclipse time as a function of the ring extension of each
retrograde system. In this case, the eclipse could be explained by some
systems with a ring radius from 0.1 au up to 0.25 au, depending on whether we
assume the eclipse happens at the pericenter or apocenter of the planetary
orbit. Due to the stability of the retrograde system, the size of the ring
could be much larger than what is necessary to explain the eclipse, reaching
almost 0.4 au ($\sim 0.95\leavevmode\nobreak\ r_{\mathrm{Hill}}$) in extreme
cases.

Figure 11: Eclipse time according to the ring radius for planets with a
retrograde orbit. The eclipse duration changes if it is assumed that the event
occurs at the pericenter of the orbit (open circles) or the apocenter (filled
circles). The dashed line indicates the observed eclipse.

##  6 Final comments

The two eclipses of the star PDS110 in 2008 and 2011 were initially
interpreted as results of the transit of the edge of a gigantic and inclined
ring (Osborn & Rodriguez, 2017). This ring could be around an unseen secondary
companion, either a brown dwarf or a giant planet (named PDS110b). This
secondary would be 2 au from the star, with a mass $>1.8M_{\mathrm{Jup}}$. No
other constraints on the system could be made through the observational data.

We proposed to find possible limits on the mass and eccentricity for the
secondary body, as well as the ring radius and inclination that could produce
an equivalent transit duration assuming we have a face-on view of the system.
To do so, we performed numerical simulations, assigning random values for the
parameters of the system within the ranges derived from the observations.

Initially, we found that the limit of the stability zone for a circumplanetary
disk sets the maximum eccentricity of the planet as 0.5, which is in agreement
with an analytical approach. If the planet is more eccentric, the ring is more
disturbed by the star, and its size is not large enough to create a 25-day
eclipse.

We also simulated rings with inclinations from 0∘ to 180∘. The largest
prograde stable ring system we found filled a fraction of $\sim
0.5r_{\mathrm{Hill}}$, compatible with theoretical studies. In retrograde
simulations, this stability zone can extend to almost one Hill radius ($\sim
0.95r_{\mathrm{Hill}}$).

The approach we followed to determine the stability resulted in a large ring
and cannot be directly compared to the method presented by Speedie & Zanazzi
(2020). Our instability criteria rely on ejection or collision, while their
analysis is related to a torque balance between the tidal torques from the
star and a planet, and they also have a stricter stability classification
related to the variation in the inclination and eccentricity of the particle.
Furthermore, the torque from the planet is directly dependent on the $J_{2}$
coefficient, which is an unknown parameter for the PDS110b and would introduce
an extra degree of freedom in our analysis.

The eclipse duration depends on the orbital velocity of the planet. Thus, we
computed the extreme cases for transit at the pericenter and at the apocenter,
both for prograde and retrograde ring systems. When the ring inclination is
smaller than $90^{\circ}$, it requires a more massive planet
($m_{\mathrm{p}}>35M_{\mathrm{Jup}}$) and its eccentricity is limited to 0.2
for transit at the pericenter. If the eclipse occurs at the apocenter, any
value of $e_{\mathrm{p}}<0.5$ could explain the eclipse. In a retrograde
configuration, the imposed constraints are looser since the eclipse could be
explained for systems with $m_{\mathrm{p}}>5M_{\mathrm{Jup}}$.

Although the retrograde ring system may have a broader range of possible
configurations to explain the eclipse, we consider a prograde system to be
more likely since it is hard to justify the origin of such a large ring
($\sim$ 0.2 au) in retrograde motion. In our Solar System, we do not have any
example of a retrograde ring system, just some irregular moons of Jupiter,
Saturn, and Neptune; in these cases, the moons were captured into orbit by the
planet’s gravity.

In summary, the most likely result from our simulations is the configuration
for the PDS110b system with a ring radius in the range [0.1 - 0.2] au and an
inclination $i<60^{\circ}$. The planet probably has a small eccentricity
($e<0.05$) and is probably very massive $m_{\mathrm{p}}>35M_{\mathrm{Jup}}$.

It is worth recalling that we assumed that we are always observing the system
face-on in our analysis. If the disk is inclined in the sky plane, the
observed radial extension of the ring is reduced, and therefore many of the
possible configurations that we considered acceptable vanish.

Since the results we present are derived from numerical simulations carried
out for more than 6,000 years ($10^{4}$ orbital periods), it is beyond the
scope our analysis to explain why the predicted dimming event in 2017 was
negative after two positive detections in 2008 and 2011. Osborn & Kenworthy
(2019) argued that these eclipses might be some aperiodic event and not
related to the transit of an exoring.

## Acknowledgements

The authors are grateful to the anonymous referee that contributed
significantly to the improvement of the paper.

This research was financed in part by the Coordenação de Aperfeiçoamento de
Pessoal de Nível Superior - Brasil (CAPES) - Finance Code 001, and Fundação de
Amparo a Pesquisa no Estado de São Paulo (FAPESP) Proc. 2016/24561-0

## References

  * Aizawa et al. (2018) Aizawa, M., Masuda, K., Kawahara, H., & Suto, Y. 2018, The Astronomical Journal, 155, 206
  * Aizawa et al. (2017) Aizawa, M., Uehara, S., Masuda, K., Kawahara, H., & Suto, Y. 2017, The Astronomical Journal, 153, 193
  * Akinsanmi et al. (2020) Akinsanmi, B., Santos, N., Faria, J., et al. 2020, Astronomy & Astrophysics, 635, L8
  * Barnes & Fortney (2004) Barnes, J. W. & Fortney, J. J. 2004, The Astrophysical Journal, 616, 1193
  * Brown et al. (2016) Brown, A. G., Vallenari, A., Prusti, T., et al. 2016, Astronomy & Astrophysics, 595, A2
  * Domingos et al. (2006) Domingos, R. C., Winter, O. C., & Yokoyama, T. 2006, Monthly Notices of the Royal Astronomical Society, 373, 1227
  * Hamilton & Burns (1992) Hamilton, D. P. & Burns, J. A. 1992, Icarus, 96, 43
  * Heising et al. (2015) Heising, M., Marcy, G., & Schlichting, H. 2015, The Astrophysical Journal, 814
  * Hunter (1967) Hunter, R. 1967, Monthly Notices of the Royal Astronomical Society, 136, 245
  * Kenworthy & Mamajek (2015) Kenworthy, M. A. & Mamajek, E. E. 2015, The Astrophysical Journal, 800, 126
  * Mamajek et al. (2012) Mamajek, E. E., Quillen, A. C., Pecaut, M. J., et al. 2012, The Astronomical Journal, 143, 72
  * Mayor & Queloz (1995) Mayor, M. & Queloz, D. 1995, Nature, 378, 355
  * Osborn & Kenworthy (2019) Osborn, H. P. & Kenworthy, e. a. 2019, Monthly Notices of the Royal Astronomical Society, 485, 1614
  * Osborn & Rodriguez (2017) Osborn, H. P. & Rodriguez, e. a. 2017, Monthly Notices of the Royal Astronomical Society, 471, 740
  * Rein & Spiegel (2014) Rein, H. & Spiegel, D. S. 2014, Monthly Notices of the Royal Astronomical Society, 446, 1424
  * Rieder & Kenworthy (2016) Rieder, S. & Kenworthy, M. A. 2016, Astronomy & Astrophysics, 596, A9
  * Schlichting & Chang (2011) Schlichting, H. E. & Chang, P. 2011, The Astrophysical Journal, 734, 117
  * Speedie & Zanazzi (2020) Speedie, J. & Zanazzi, J. 2020, Monthly Notices of the Royal Astronomical Society, 497, 1870
  * Wolszczan & Frail (1992) Wolszczan, A. & Frail, D. A. 1992, Nature, 355, 145