Little's Law

How it behaves

One input on the horizontal axis, the others held fixed.

Worked examples, recomputed

Every number the mechanisms quote for this relationship is recomputed from it, so none of them disagrees with it.

• one flush per commit at 1 ms → 1,000 commits/s
• 50 commits per 1 ms flush → 50,000 commits/s
• 300 calls/s × 50 ms → 15 connections busy
• 100 records per call, 1 ms RTT → 100,000 records/s
• 10,000/s × 5 ms → 50 transactions in flight
• 667 conflicting operations/s × 20 ms lag → ≈ 13 in the window
• lag of 2 s → ≈ 1,333
• 200/s with the read-modify-write in application code (50 ms) → 10
• 200/s inside one SQL statement (50 µs) → 0.01
• 2,000,000 events/s × 5 ms of backlog → 10,000 slots
• spilling triples residence: 0.5/s × 180 s → 90 queries holding grants
• 1,500 requests/s × 2 s → 3,000 identical queries
• 2,000 requests/s with a 100 ms deadline → at most 200 in flight
• 1,000 items/s, 200 ms target → 200 queue slots
• a dependency slows to 10 s at 100 req/s → 1,000 threads held
• 1,000 records/s with K = 5 s of disorder → 5,000 in the heap
• one request in flight at 5 ms → 200 records/s per task
• 50 in flight → 10,000 records/s
• 10⁶ events/s × 200 B × 600 s × 2 sides = 240 GB
• 20 planning requests/s × 0.5 s → 10 slots busy
• planning slows to 2 s → 40 slots
• 50,000 spans/s × 10 s traces → 500,000 spans in memory
• 300 sensors an hour waiting 4 h → 1,200 slots held
• 200 credentials/s with a 60-minute TTL → 720,000 live
• closed loop, 200 users, 40 ms → 5,000 requests/s
• the same users at 400 ms → 500 requests/s: the generator slows itself
• open loop at 5,000/s and 400 ms → 2,000 in the system
• a pool at 1,000/s, 10 ms inside → 10 requests held
• 50 connections × 100 ms → 500 queries per second
• QD = 1 at 80 µs → 12,500 IOPS
• 12 misses × 64 B ÷ 80 ns → 9.6 GB/s
• 10 Gb/s × 100 ms → 125 MB in flight

Where it appears

Each mechanism states it in its own names. The general symbol each name stands for is shown with it.

• Physical Substrate & Performance Laws

  Why do trade-offs exist at all?

  $$L=\lambda \times W$$

  Read it in place →

• Physical Substrate & Performance Laws

  Why do trade-offs exist at all?

  $$\text{Concurrency}=\text{Throughput}\times \text{Latency}$$

  Concurrency = $L$ · Throughput = $\lambda$ · Latency = $W$

  Read it in place →

• Physical Substrate & Performance Laws

  Why do trade-offs exist at all?

  $$\text{Bandwidth}=\frac{\text{Concurrency}\times \text{Line size}}{\text{Latency}}$$

  Concurrency = $L$ · Bandwidth = $\lambda \times \text{line size}$ · Latency = $W$

  Read it in place →

• Physical Substrate & Performance Laws

  Why do trade-offs exist at all?

  $$\text{Bytes in flight}=\text{Bandwidth}\times \text{RTT}$$

  Bytes in flight = $L$ · Bandwidth = $\lambda$ · RTT = $W$

  Read it in place →

• Data Movement

  How do records cross between two systems that have independent rates, independent availability and independent lifetimes, and what are you willing to lose when the assumption underneath the crossing breaks?

  $$L=\lambda \times W$$

  Read it in place →

• Storage: Physical Organization

  What should sit next to what, given that I must decide at write time and find out at read time?

  $$\text{items in flight}=\text{throughput}\times \text{latency}$$

  items in flight = $L$ · throughput = $\lambda$ · latency = $W$

  Read it in place →

• Persistence & Durability

  When a system says "yes, your data is safe", what exactly has it promised, and what did it have to do to keep that promise?

  $$\text{commit\_rate}=\frac{\text{commits\_in\_flight}}{\text{commit\_latency}}$$

  commits_in_flight = $L$ · commit_rate = $\lambda$ · commit_latency = $W$

  Read it in place →

• Core Data Structures

  How do we choose a data structure when the real cost is set by the hardware, not by Big-O?

  $$F\times \text{buffer}\ge \text{bandwidth}\times \text{latency}$$

  F × buffer = $L$ · bandwidth = $\lambda$ · latency = $W$

  Read it in place →

• Transactions & Concurrency Control

  What happens when many users change the same data at the same time, and how do we keep the result correct?

  $$L=\lambda \times W$$

  L = $L$ · λ = $\lambda$ · W = $W$

  Read it in place →

• Consistency & Isolation Models

  When many users, many objects and many copies exist at once, which histories does the system promise never to show, and who writes the code for the histories it does show?

  $$\text{inconsistencies in flight}\approx {\lambda }_{\text{conflicting}}\times W$$

  inconsistencies in flight = $L$ · λ_conflicting (operations that can conflict) = $\lambda$ · W (lag, snapshot age, TTL) = $W$

  Read it in place →

• Caching

  What happens when we deliberately keep a second copy of data that no protocol forces to be correct?

  $$L={\lambda }_k\cdot W$$

  λ_k (requests for the key) = $\lambda$ · W (recompute time) = $W$ · L (duplicate recomputes) = $L$

  Read it in place →

• Distributed Systems Coordination

  Who is allowed to decide, and how does everyone else learn the decision without asking?

  $$L=\lambda \times W$$

  W (deadline) = $W$

  Read it in place →

• Fault Tolerance & Delivery Semantics

  What is the cheapest thing that can be safely done twice?

  $$\text{keys held}=\text{keys per second}\times \text{window}$$

  Read it in place →

• Emergent Failure Dynamics

  What happens when nothing is broken, every component is healthy, and the system's own response to stress makes the stress worse?

  $$L_{\max }={\lambda }_{\text{service}}\times D_{\text{target}}$$

  L_max (queue slots) = $L$ · λ_service = $\lambda$ · D_target (latency target) = $W$

  Read it in place →

• Scheduling & Workload Management

  Which work runs now, which work waits, and who pays for the waiting?

  $$\text{worst-case wait}=\text{queue depth}÷\text{service rate}$$

  queue depth = $L$ · service rate = $\lambda$ · worst-case wait = $W$

  Read it in place →

• Streaming

  What does it cost to remember, when the input never ends?

  $$\text{throughput}=\frac{N\text{in flight}}{\text{RTT}}$$

  N (requests in flight) = $L$ · RTT = $W$

  Read it in place →

• Streaming

  What does it cost to remember, when the input never ends?

  $$\text{state}=\text{rate}\times \text{window}\times \text{both sides}$$

  Read it in place →

• Metadata, Catalog & Lineage

  What can a system prove about its data without reading the data, and how does it know that proof is still true?

  $$\text{slots busy}=\text{planning requests per second}\times \text{planning time}$$

  Read it in place →

• Orchestration & Workflow

  How do you make unreliable, unobservable, irreversible side effects behave like a pure function of a time interval?

  $$L=\lambda W\text{sensor slots held}$$

  Read it in place →

• Observability & Operations

  What is the smallest description of a running system from which we can find a fault, fast enough to matter, at a cost we can still pay while the system is failing?

  $$\text{spans held}=\text{span rate}\times \text{trace duration}$$

  Read it in place →

• Security & Privacy

  How do you protect data from someone who watches your design and then chooses how to attack it?

  $$\text{live credentials}=\text{issue rate}\times \text{TTL}$$

  Read it in place →

• Measurement & Experimental Method

  What would have to be true for this number to mean what I think it means?

  $$\text{closed loop: }\lambda =N/W;\text{open loop: }L=\lambda W$$

  N (virtual users) = $L$

  Read it in place →