Ferkans — Interactive Telecom Tutor

Who Owns the Cache?

Up to now, each user had its own cache — a dedicated-cache model. Many real architectures have a different structure: shared caches, where multiple users share access to a single cache. Examples:

A Wi-Fi access point's cache serves all devices in its coverage.
An apartment building's edge cache serves all residents.
A content-delivery gateway serves many subscribers.

Shared caches change the coded-caching analysis. The placement must anticipate that several users might draw from the same cache — caching popular content here is more valuable; caching user- specific content makes less sense. This section formalizes the two models and compares their rate-memory tradeoffs.

Definition:
Dedicated-Cache Model

In the dedicated-cache model, each user $k \in [K]$ has its own cache $\mathcal{Z}_k$ of size $M$ files. This is the standard MAN model (Chapter 2) and all prior chapters. The coded caching gain is $t = K M/N$ .

Definition:
Shared-Cache Model

In the shared-cache model, there are $\Lambda$ caches, each of size $M_{s}$ files. Each user is associated with exactly one cache; a group of users sharing cache $\lambda$ all have access to $\mathcal{Z}_\lambda$ . Let $K_s = K/\Lambda$ denote the average number of users per cache. The aggregate cache budget is $\Lambda M_s$ files; the per-user effective memory is $M_\text{eff} = M_s \Lambda/K = M_s/K_s$ .

For fair comparison with the dedicated model: set $M_s = K_s M$ so that the total system storage is the same as a dedicated-cache system with per-user cache $M$ .

Shared caches are a natural fit for small-cell deployments where several nearby users share a micro-cell's cache. The number of users per cache $K_s$ depends on user density and cache distribution.

Theorem: Shared-Cache MAN Rate

For the shared-cache model with $\Lambda$ caches, each of size $M_s$ , and $K_s$ users per cache (so $K = \Lambda K_s$ ), the achievable multicast rate under a MAN-style scheme is $R_\text{shared}(M_{s}, K_s, \Lambda) \;=\; K_s \cdot \frac{\Lambda(1 - M_{s}/N)}{1 + \Lambda M_{s}/N}.$ For $K_s = 1$ (one user per cache), this reduces to the standard MAN rate with $K = \Lambda$ users. For $K_s > 1$ , the rate scales with $K_s$ linearly — each extra user per cache adds its own demand without helping the multicast.

Users sharing a cache have access to the same $\mathcal{Z}_\lambda$ . They do not get individualized XOR cancellation opportunities beyond what any one of them would. The MAN scheme effectively runs on $\Lambda$ "super-users" (one per cache) plus $K_s$ duplicates each. Rate: $K_s \cdot R_\text{MAN}(\Lambda, M_s)$ where $R_\text{MAN}$ is the dedicated-cache rate at size $\Lambda$ .

Proof

Placement

Apply MAN placement to $\Lambda$ caches (not $K$ users). Each cache holds a fraction $M_s/N$ of the library, with the MAN combinatorial structure across $\Lambda$ caches.

Delivery

Each user sharing cache $\lambda$ demands one file. Within a cache group, the delivery needs $K_s$ individual deliveries (since users in the same group don't help each other via XOR). Across cache groups, the MAN structure applies.

Rate counting

Per cache group: $K_s$ file deliveries. Across $\Lambda$ groups with MAN: aggregate rate $= K_s \cdot R_\text{MAN}(\Lambda, M_s) = K_s \Lambda(1-M_s/N)/(1 + \Lambda M_s/N)$ .

Equivalent memory-sharing

If we keep aggregate storage fixed ( $\Lambda M_s = KM$ or $M_s = K_s M$ ), the effective rate is $R = K_s \Lambda(1 - K_s \mu)/(1 + \Lambda K_s \mu)$ vs. dedicated $K(1 - \mu)/(1 + K\mu)$ . Comparing is non-trivial; see next example. $\blacksquare$

Shared vs Dedicated Caches

Comparing shared-cache and dedicated-cache rates at equal aggregate storage. The dedicated model has one cache per user; the shared model pools users into groups of $K_s$ . For large $K_s$ (fewer but larger caches), rate changes non-trivially; the optimal depends on $\mu$ .

Parameters

Users K20

Users per shared cache K_s4

Example: Shared vs Dedicated at Equal Total Storage

Compare the rate of shared-cache model with $\Lambda = 5$ caches, $K_s = 4$ users per cache ( $K = 20$ total), $M_s = 4M$ (per-cache size) vs the dedicated model with $K = 20$ users each with cache $M$ . Use $M/N = 0.1$ .

Solution

Dedicated rate

$t = 20 \cdot 0.1 = 2$ . $R_\text{ded} = 20 \cdot 0.9/3 = 6$ .

Shared parameters

$M_s = 4M$ , so $M_s/N = 0.4$ . $\Lambda M_s/N = 5 \cdot 0.4 = 2$ . $R_\text{shared} = K_s \cdot \Lambda(1 - M_s/N)/(1 + \Lambda M_s/N) = 4 \cdot 5 \cdot 0.6/3 = 4$ .

Comparison

Shared rate (4) < dedicated rate (6). Shared-cache model is more efficient here! Intuition: 5 larger caches with combined MAN is more efficient than 20 smaller caches with the same aggregate storage — fewer caches means each cache holds more content (40% of the library vs 10%), enabling larger coded multicasting gains.

Caveat

This is model-specific. For some parameter regimes the dedicated model is better (e.g., when users have very different demand patterns, dedicated caches can specialize). The parrinello-unsal-elia paper characterizes the crossover.

Hybrid Models

Real deployments often blend the two: each user has a small personal cache (phone), plus access to a shared network cache (gateway). The hybrid model's analysis is:

Total aggregate cache = $K M_\text{personal} + \Lambda M_\text{shared}$ .

Coded caching operates on two "layers": personal caches give per-user XOR gain; shared caches give cache-group-level XOR gain. The rate combines the two. Parrinello et al. (2020) treat this; the resulting rate tradeoff is a generalization of both the dedicated and shared formulas.

The practical design challenge: balance personal vs shared storage under a total-budget constraint. Shared is typically cheaper (larger caches with lower per-byte cost) but less flexible (no personalized content).

Common Mistake: The 'Caching Gain' is per Cache, not per User

Mistake:

Applying the dedicated-cache formula $t = KM/N$ to the shared model.

Correction:

In the shared model, the relevant parameter is $t_\text{shared} = \Lambda M_s/N$ — the cache count (not user count) times per-cache size. Each cache contributes to the coded multicast opportunity; users sharing a cache don't contribute independently. At equal aggregate storage, $\Lambda M_s = K M$ , so $t_\text{shared} = K M/N = t$ . The caching gain is the same. The difference is the user-facing rate: it scales linearly in $K_s$ (users per cache).

Shared vs Dedicated Cache Models