Why a CDN survives a flash crowd
A cache holding 100 objects out of 1,000 answers 37% of requests from memory. Hold 200 and it answers 52%. Those two numbers come from a seeded trace of 100,000 requests that I run through a least-recently-used cache in the simulator package and check against libCacheSim, a reference cache simulator. The miss ratios are stored in a fixture (0.62566 at 100 objects, 0.48246 at 200) and the test fails if my cache drifts more than 0.005 from them.
The trace works because popularity in a video catalogue is not even.
Popularity follows a curve
Rank every title by how often it is requested. In a Zipf distribution the probability of rank k is proportional to k^-alpha. At alpha 0 every title is equally likely, so the hit ratio is just the share of the catalogue the cache holds. As alpha rises, the head of the list takes a larger share of requests and a small cache covers more of them.
The fixture uses 1,000 titles and alpha 0.8, which is a gentle skew. The Media Network Lab's SVOD profile uses 4,000 objects at 1.25 with 1,500 cached per edge, and its source comment says those inputs were chosen so the hit ratio lands near 95%. That is a calibration of the inputs. The hit ratio itself is a result the simulation produces, and alpha is labelled in the code as a teaching parameter, not a measured fact about any real service.
The ratio to watch is the cache hit ratio: requests answered by the cache divided by all requests. A collapsed request still counts as a miss. That is consistent with libCacheSim and the Che approximation, though neither models in-flight fetches.
Two tiers, two different jobs
The edge cache sits near viewers and answers most requests. A miss goes upstream to an origin shield, a second cache tier in front of the origin. In the Media Network Lab each shield caches twice what an edge does (SHIELD_CACHE_FACTOR = 2), but the size is not why it exists.
What the shield does is request collapsing. When a segment is not in cache, the first miss starts one upstream fetch and every later request for the same object parks behind it. When the fetch succeeds, all of them are served. If it fails, the parked requests go upstream themselves. In media-sim that is the cache.collapse option, and parked requests are released after collapseTimeoutMs (10 seconds by default) if the fetch never reports back. The Platform Architectures Lab turns it on. The Media Network Lab models the shield differently: a second cache tier, plus an analytic factor that counts collapsing as one fetch per shield.
without a shield: 5 regions x many edges -> one origin fetch per edge miss
with a shield: 5 regions x many edges -> one origin fetch per shield
Edge hit ratio is the same in both cases. What changes is how many misses reach the origin, and the Media Network Lab has a challenge built on exactly that: the edge hit ratio sits above 98% and, the brief says, the origin bill still doubles, because nothing collapses the misses behind the edges.
What the crowd does
A steady audience warms the caches and then mostly leaves the origin alone. A flash crowd breaks that. The lab's flash audience preset is a piecewise curve over a 600-second window: a factor of 1 until second 20, 3 by second 40, then 3 for the rest. The audience triples in twenty seconds.
Tripling the audience would not hurt if the new viewers asked for old, warm segments. They don't. Live and event traffic has every viewer wanting the same new segment at the same moment, before any cache holds it. Each edge sees a miss for the same object, and without a shield each of them goes to the origin. With a shield, the crowd becomes one fetch per shield. The default topology has 3 shields for 5 regions.
The lab's flash-crowd challenge sets 12 million viewers on that curve with the shield off and asks for startup p95 under one second and the origin under 90% utilisation. Turning the shield on is the fix, and it works without changing a single edge setting.
That is also where the model gets honest about its limits. A separate challenge starts with a single shield (sh-na) and crashes it at ten seconds, and viewers see errors and rebuffering until you add shields for the other regions. Collapsing protects the origin, and the shield then becomes the thing that needs protecting.