Age-Memory Trade-off in Read-Copy-Update

TL;DR

This work analyzes the age-memory trade-off in Read-Copy-Update (RCU) for shared-memory synchronization under real-time constraints. In a memoryless model with update rate $\alpha$ and read rate $\lambda$, it derives an exact expression for $\mathbb{E}[N]$, a tight upper bound, and the average update age $\mathbb{E}[\Delta]=2/\alpha$. The results show $\mathbb{E}[N]$ remains finite for finite $\lambda$, $\mu$, and $\alpha$, revealing a clear trade-off: faster updates reduce AoI but increase memory, whereas lowering read rate reduces memory. Numerical evaluations illustrate the bounds’ tightness and the asymptotic behavior as $\alpha \to \infty$, where $N$ converges to $1+N'$ with $N'$ ~ Poisson$(\lambda/\mu)$, with practical implications for real-time mobile workloads such as Visual SLAM.

Abstract

In the realm of shared memory systems, the challenge of reader-writer synchronization is closely coupled with the potential for readers to access outdated updates. Read-Copy-Update (RCU) is a synchronization primitive that allows for concurrent and non-blocking read access to fresh data. This is achieved through the creation of updated data copies, with each prior version retained until all associated read-locks are released. Given the principle that frequent updating keeps information fresh, the concern is whether we accumulate an infinite number of update copies, leading to excessively large memory usage. This paper analyzes trade-offs between memory usage and update age within real-time status updating systems, focusing specifically on RCU. The analysis demonstrates that with finite read time and read request rate, the average number of updates within the system remains bounded.

Figures (5)

• Figure 1: Memoryless RCU model: On behalf of an external source, a writer updates the shared memory at rate $\alpha$ with timestamped updates, denoted by timestamps $t_1, t_2, \ldots$. Read requests $R_1, R_2, \ldots, R_m$ access the version of the source update with the freshest timestamp. These read requests are generated at rate $\lambda$ and have a mean read time of $1/\mu$.
• Figure 2: Example evolution of age at shared memory in the unconstrained write model. Updates are published in memory at times marked $\blacktriangledown$.
• Figure 3: An example of the RCU read/write process (upper timeline) and the sample age evolution (shown only for illustration purpose) of update in memory (lower timeline). In the upper timeline: green triangles mark arrivals of read requests that finish before the next update is published; red triangles mark those reads that establish a grace period by holding a read lock after the next update is published; the red intervals beneath the upper timeline show the service times of such readers; the red arrows above the upper timeline (with labels $\Lambda_k$, $\Lambda_2$ and $\Lambda_1$) identify the grace periods of updates $k$, $2$, and $1$ that are active at time $t$.
• Figure 4: (a) Memory footprint in RCU as a function of read arrival rate $\lambda$. (b) Trade-off between the average age $\Delta$ and $\mathop{\mathrm{E}}\nolimits[[]]{N}$ as a function of writing rate $\alpha$. In both $(a)$ and $(b)$, the read service rate is $\mu=1$.
• Figure 5: (a) The expected number of active updates are written at rate $\alpha$. The black, blue and red curves are when $\lambda/\mu = 10$, $\lambda/\mu = 5$, and $\lambda/\mu = 1$ respectively; the read service rate is $\mu=1$. (b) Zoomed in version of (a)).

Theorems & Definitions (3)

• Theorem 1
• Lemma 1
• proof