Ivan's wiki

Site Tools

numbers-every-programmer-should-know

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revisionPrevious revision
Next revision		Previous revision
numbers-every-programmer-should-know [February 15, 2026 at 13:24] – yanevskivnumbers-every-programmer-should-know [May 23, 2026 at 00:12] (current) – Ivan Janevski
Line 1: Line 1:
 +# Numbers every programmer should know
 +**Numbers every programmer should know** is a short document listing latencies of various computer operations. The list is given by a computer scientist [Jeff Dean](https://en.wikipedia.org/wiki/Jeff_Dean).
 +
 +It illustrates how various high-level operations exponentially take longer time to perform compared to various low-level operations.
 +
 +## Content
 +```
 +Latency Comparison Numbers (~2012)
 +----------------------------------
 +L1 cache reference                           0.5 ns
 +Branch mispredict                            5   ns
 +L2 cache reference                           7   ns                      14x L1 cache
 +Mutex lock/unlock                           25   ns
 +Main memory reference                      100   ns                      20x L2 cache, 200x L1 cache
 +Compress 1K bytes with Zippy             3,000   ns        3 us
 +Send 1K bytes over 1 Gbps network       10,000   ns       10 us
 +Read 4K randomly from SSD*             150,000   ns      150 us          ~1GB/sec SSD
 +Read 1 MB sequentially from memory     250,000   ns      250 us
 +Round trip within same datacenter      500,000   ns      500 us
 +Read 1 MB sequentially from SSD*     1,000,000   ns    1,000 us    1 ms  ~1GB/sec SSD, 4X memory
 +Disk seek                           10,000,000   ns   10,000 us   10 ms  20x datacenter roundtrip
 +Read 1 MB sequentially from disk    20,000,000   ns   20,000 us   20 ms  80x memory, 20X SSD
 +Send packet CA->Netherlands->CA    150,000,000   ns  150,000 us  150 ms
 +
 +Notes
 +-----
 +1 ns = 10^-9 seconds
 +1 us = 10^-6 seconds = 1,000 ns
 +1 ms = 10^-3 seconds = 1,000 us = 1,000,000 ns
 +
 +Credit
 +------
 +By Jeff Dean:               http://research.google.com/people/jeff/
 +Originally by Peter Norvig: http://norvig.com/21-days.html#answers
 +
 +Contributions
 +-------------
 +'Humanized' comparison:    https://gist.github.com/hellerbarde/2843375
 +Visual comparison chart:   http://i.imgur.com/k0t1e.png
 +Interactive Prezi version: https://prezi.com/pdkvgys-r0y6/latency-numbers-for-programmers-web-development/latency.txt
 +```
 +
 +## Criticism (Opinion)
 +While the list is illustrative, the claim that every programmer needs to "know" these numbers is not justified. Certainly it's not necessary to know these numbers by heart for one to be an effective programmer. The name "numbers every programmer should know" is thus a misnomer.
 +
 +The list mixes different categories of programming which sit at completely different hierarchies. A high-level web programmer almost never needs to know about mutex lock/unlock or branch misprediction; A low-level embedded programmer almost never needs to know the packet roundtrip between California and Netherlands.
 +
 +In addition, these numbers evolve as the technology continues to evolve. Because we're talking about latencies, they are subjected to eternal factors (electromagnetic interference, network congestion, ...). Therefore, even if you do know these numbers by heart, there is no context in which you will find their value useful.
 +
 +As mentioned, the list should only be understood as illustrative.
 +```
 +L1 cache < Branch mispredict < ... < Send packet CA -> Netherlands -> CA
 +```
 +
 +## Source
 +
 + - https://gist.github.com/jboner/2841832