Instantly share code, notes, and snippets.

Embed
What would you like to do?
Latency Numbers Every Programmer Should Know
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
@dominictarr

This comment has been minimized.

Show comment
Hide comment
@dominictarr

dominictarr May 31, 2012

need a solar system type visualization for this, so we can really appreciate the change of scale.

dominictarr commented May 31, 2012

need a solar system type visualization for this, so we can really appreciate the change of scale.

@jboner

This comment has been minimized.

Show comment
Hide comment
@jboner

jboner May 31, 2012

I agree, would be fun to see. :-)

Owner

jboner commented May 31, 2012

I agree, would be fun to see. :-)

@pmanvi

This comment has been minimized.

Show comment
Hide comment
@pmanvi

pmanvi May 31, 2012

useful information & thanks

pmanvi commented May 31, 2012

useful information & thanks

@marianposaceanu

This comment has been minimized.

Show comment
Hide comment
@marianposaceanu

marianposaceanu May 31, 2012

Looks nice kudos !
One comment about the Branch mispredict: if the cpu architecture is based on P4 or Bulldozer that would result in 20-30+ cycles on a mispredict that would translate to a much bigger number (and they do mispredict) :)

For SSD's would be something like:
Disk seek: 100 000 ns

marianposaceanu commented May 31, 2012

Looks nice kudos !
One comment about the Branch mispredict: if the cpu architecture is based on P4 or Bulldozer that would result in 20-30+ cycles on a mispredict that would translate to a much bigger number (and they do mispredict) :)

For SSD's would be something like:
Disk seek: 100 000 ns

@preinheimer

This comment has been minimized.

Show comment
Hide comment
@preinheimer

preinheimer May 31, 2012

Latency numbers between large cities: https://wondernetwork.com/pings/

preinheimer commented May 31, 2012

Latency numbers between large cities: https://wondernetwork.com/pings/

@alexismo

This comment has been minimized.

Show comment
Hide comment
@alexismo

alexismo May 31, 2012

@preinheimer Asia & Australasia have it bad.

alexismo commented May 31, 2012

@preinheimer Asia & Australasia have it bad.

@gandalfar

This comment has been minimized.

Show comment
Hide comment
@gandalfar

gandalfar commented May 31, 2012

@Eronarn

This comment has been minimized.

Show comment
Hide comment
@Eronarn

Eronarn May 31, 2012

"Latency numbers every programmer should know" - yet naturally, it has no information about humans!

http://biae.clemson.edu/bpc/bp/lab/110/reaction.htm

Eronarn commented May 31, 2012

"Latency numbers every programmer should know" - yet naturally, it has no information about humans!

http://biae.clemson.edu/bpc/bp/lab/110/reaction.htm

@hellerbarde

This comment has been minimized.

Show comment
Hide comment
@hellerbarde

hellerbarde May 31, 2012

maybe you want to incorporate some of this: https://gist.github.com/2843375

hellerbarde commented May 31, 2012

maybe you want to incorporate some of this: https://gist.github.com/2843375

@christopherscott

This comment has been minimized.

Show comment
Hide comment
@christopherscott

christopherscott May 31, 2012

Curious to see numbers for SSD read time

christopherscott commented May 31, 2012

Curious to see numbers for SSD read time

@klochner

This comment has been minimized.

Show comment
Hide comment
@klochner

klochner May 31, 2012

I think the reference you want to cite is here: http://norvig.com/21-days.html#answers

klochner commented May 31, 2012

I think the reference you want to cite is here: http://norvig.com/21-days.html#answers

@lucasces

This comment has been minimized.

Show comment
Hide comment
@lucasces

lucasces May 31, 2012

This remind me of this Grace Hopper's video about Nanoseconds. Really worthy.
http://www.youtube.com/watch?v=JEpsKnWZrJ8

lucasces commented May 31, 2012

This remind me of this Grace Hopper's video about Nanoseconds. Really worthy.
http://www.youtube.com/watch?v=JEpsKnWZrJ8

@mikea

This comment has been minimized.

Show comment
Hide comment
@mikea

mikea May 31, 2012

I find comparisons much more useful than raw numbers: https://gist.github.com/2844130

mikea commented May 31, 2012

I find comparisons much more useful than raw numbers: https://gist.github.com/2844130

@briangordon

This comment has been minimized.

Show comment
Hide comment
@briangordon

briangordon May 31, 2012

I'm surprised that mechanical disk reads are only 80x the speed of main memory reads.

briangordon commented May 31, 2012

I'm surprised that mechanical disk reads are only 80x the speed of main memory reads.

@marianposaceanu

This comment has been minimized.

Show comment
Hide comment
@marianposaceanu

marianposaceanu May 31, 2012

my version : https://gist.github.com/2842457 includes SSD number, would love some more

marianposaceanu commented May 31, 2012

my version : https://gist.github.com/2842457 includes SSD number, would love some more

@newphoenix

This comment has been minimized.

Show comment
Hide comment
@newphoenix

newphoenix May 31, 2012

Does L1 and L2 cache latency depends on processor type? and what about L3 cache.

newphoenix commented May 31, 2012

Does L1 and L2 cache latency depends on processor type? and what about L3 cache.

@marianposaceanu

This comment has been minimized.

Show comment
Hide comment
@marianposaceanu

marianposaceanu May 31, 2012

Ofc it does ... those are averages I think.

marianposaceanu commented May 31, 2012

Ofc it does ... those are averages I think.

@cayblood

This comment has been minimized.

Show comment
Hide comment
@cayblood

cayblood May 31, 2012

Would be nice to right-align the numbers so people can more easily compare orders of magnitude.

cayblood commented May 31, 2012

Would be nice to right-align the numbers so people can more easily compare orders of magnitude.

@jboner

This comment has been minimized.

Show comment
Hide comment
@jboner

jboner May 31, 2012

Good idea. Fixed.

Owner

jboner commented May 31, 2012

Good idea. Fixed.

@jhclark

This comment has been minimized.

Show comment
Hide comment
@jhclark

jhclark May 31, 2012

And expanded even a bit more: https://gist.github.com/2845836 (SSD numbers, relative comparisons, more links)

jhclark commented May 31, 2012

And expanded even a bit more: https://gist.github.com/2845836 (SSD numbers, relative comparisons, more links)

@nicowilliams

This comment has been minimized.

Show comment
Hide comment
@nicowilliams

nicowilliams May 31, 2012

TLB misses would be nice to list too, so people see the value of large pages...

Context switches (for various OSes), ...

Also, regarding packet sends, that must be latency from send initiation to send completion -- I assume.

If you're going to list mutex lock/unlock, how about memory barriers?

Thanks! This is quite useful, particularly for flogging at others.

nicowilliams commented May 31, 2012

TLB misses would be nice to list too, so people see the value of large pages...

Context switches (for various OSes), ...

Also, regarding packet sends, that must be latency from send initiation to send completion -- I assume.

If you're going to list mutex lock/unlock, how about memory barriers?

Thanks! This is quite useful, particularly for flogging at others.

@lry

This comment has been minimized.

Show comment
Hide comment
@lry

lry Jun 1, 2012

Quick pie chart of data with scales in time (1 sec -> 9.5 years) for fun.

Spreadsheet with chart

lry commented Jun 1, 2012

Quick pie chart of data with scales in time (1 sec -> 9.5 years) for fun.

Spreadsheet with chart

@vickychijwani

This comment has been minimized.

Show comment
Hide comment
@vickychijwani

vickychijwani Jun 1, 2012

"Read 1 MB sequentially from disk - 20,000,000 ns". Is this with or without disk seek time?

vickychijwani commented Jun 1, 2012

"Read 1 MB sequentially from disk - 20,000,000 ns". Is this with or without disk seek time?

@pgroth

This comment has been minimized.

Show comment
Hide comment
@pgroth

pgroth Jun 1, 2012

I made a fusion table for this at:
https://www.google.com/fusiontables/DataSource?snapid=S523155yioc

Maybe be helpful for graphing, etc. Thanks for putting this together

pgroth commented Jun 1, 2012

I made a fusion table for this at:
https://www.google.com/fusiontables/DataSource?snapid=S523155yioc

Maybe be helpful for graphing, etc. Thanks for putting this together

@jboner

This comment has been minimized.

Show comment
Hide comment
@jboner

jboner Jun 1, 2012

Cool. Thanks.
Thanks everyone for all the great improvements.

Owner

jboner commented Jun 1, 2012

Cool. Thanks.
Thanks everyone for all the great improvements.

@ayshen

This comment has been minimized.

Show comment
Hide comment
@ayshen

ayshen Jun 1, 2012

Here is a chart version. It's a bit hard to read, but I hope it conveys the perspective.
http://i.imgur.com/k0t1e.png

ayshen commented Jun 1, 2012

Here is a chart version. It's a bit hard to read, but I hope it conveys the perspective.
http://i.imgur.com/k0t1e.png

@gchatelet

This comment has been minimized.

Show comment
Hide comment
@gchatelet

gchatelet Jun 2, 2012

It would also be very interesting to add memory allocation timings to that : )

gchatelet commented Jun 2, 2012

It would also be very interesting to add memory allocation timings to that : )

@PerWiklander

This comment has been minimized.

Show comment
Hide comment
@PerWiklander

PerWiklander Jun 5, 2012

How long does it take before this shows up in XKCD?

PerWiklander commented Jun 5, 2012

How long does it take before this shows up in XKCD?

@talltyler

This comment has been minimized.

Show comment
Hide comment
@talltyler

talltyler Jun 5, 2012

You guys are talking about is the powers of ten http://vimeo.com/819138

talltyler commented Jun 5, 2012

You guys are talking about is the powers of ten http://vimeo.com/819138

@BillKress

This comment has been minimized.

Show comment
Hide comment
@BillKress

BillKress Jun 5, 2012

If it does show up on xkcd it will be next to a gigantic "How much time it takes for a human to react to any results", hopefully with the intent to show people that any USE of this knowledge should be tempered with an understanding of what it will be used for--possibly showing how getting a bit from the cache is pretty much identical to getting a bit from china when it comes to a single fetch of information to show a human being.

BillKress commented Jun 5, 2012

If it does show up on xkcd it will be next to a gigantic "How much time it takes for a human to react to any results", hopefully with the intent to show people that any USE of this knowledge should be tempered with an understanding of what it will be used for--possibly showing how getting a bit from the cache is pretty much identical to getting a bit from china when it comes to a single fetch of information to show a human being.

@hellerbarde

This comment has been minimized.

Show comment
Hide comment
@hellerbarde

hellerbarde Jun 5, 2012

@BillKress yes, this is specifically for Programmers, to make sure they have an understanding about the bottlenecks involved in programming. If you know these numbers, you know that you need to cut down on disk access before cutting down on in-memory shuffling.
If you don't properly follow these numbers and what they stand for, you will make programs that don't scale well. That is why they are important on their own and (in this context) should not be dwarfed by human reaction times.

hellerbarde commented Jun 5, 2012

@BillKress yes, this is specifically for Programmers, to make sure they have an understanding about the bottlenecks involved in programming. If you know these numbers, you know that you need to cut down on disk access before cutting down on in-memory shuffling.
If you don't properly follow these numbers and what they stand for, you will make programs that don't scale well. That is why they are important on their own and (in this context) should not be dwarfed by human reaction times.

@PerWiklander

This comment has been minimized.

Show comment
Hide comment
@PerWiklander

PerWiklander Jun 5, 2012

@BillKress If we were only concerned with showing information to a single human being at a time we could just as well shut down our development machines and go out into the sun and play. This is about scalability.

PerWiklander commented Jun 5, 2012

@BillKress If we were only concerned with showing information to a single human being at a time we could just as well shut down our development machines and go out into the sun and play. This is about scalability.

@klochner

This comment has been minimized.

Show comment
Hide comment
@klochner

klochner Jun 5, 2012

this is getting out of hand, how do i unsubscribe from this gist?

klochner commented Jun 5, 2012

this is getting out of hand, how do i unsubscribe from this gist?

@gemclass

This comment has been minimized.

Show comment
Hide comment
@gemclass

gemclass Jun 7, 2012

Saw this via @smashingmag . While you guys debate the fit for purpose, here is another visualization of your quick reference latency data with Prezi ow.ly/bnB7q

gemclass commented Jun 7, 2012

Saw this via @smashingmag . While you guys debate the fit for purpose, here is another visualization of your quick reference latency data with Prezi ow.ly/bnB7q

@briangordon

This comment has been minimized.

Show comment
Hide comment
@briangordon

briangordon Jul 3, 2012

Does anybody know how to stop receiving notifications from a gist's activity?

briangordon commented Jul 3, 2012

Does anybody know how to stop receiving notifications from a gist's activity?

@colin-scott

This comment has been minimized.

Show comment
Hide comment
@colin-scott

colin-scott commented Dec 25, 2012

Here's a tool to visualize these numbers over time: http://www.eecs.berkeley.edu/~rcs/research/interactive_latency.html

@JensRantil

This comment has been minimized.

Show comment
Hide comment
@JensRantil

JensRantil Jan 6, 2013

I just created flash cards for this: https://ankiweb.net/shared/info/3116110484 They can be downloaded using the Anki application: http://ankisrs.net

JensRantil commented Jan 6, 2013

I just created flash cards for this: https://ankiweb.net/shared/info/3116110484 They can be downloaded using the Anki application: http://ankisrs.net

@JensRantil

This comment has been minimized.

Show comment
Hide comment
@JensRantil

JensRantil Jan 14, 2013

I'm also missing something like "Send 1MB bytes over 1 Gbps network (within datacenter over TCP)". Or does that vary so much that it would be impossible to specify?

JensRantil commented Jan 14, 2013

I'm also missing something like "Send 1MB bytes over 1 Gbps network (within datacenter over TCP)". Or does that vary so much that it would be impossible to specify?

@kofemann

This comment has been minimized.

Show comment
Hide comment
@kofemann

kofemann Feb 9, 2013

If L1 access is a second, then:

L1 cache reference : 0:00:01
Branch mispredict : 0:00:10
L2 cache reference : 0:00:14
Mutex lock/unlock : 0:00:50
Main memory reference : 0:03:20
Compress 1K bytes with Zippy : 1:40:00
Send 1K bytes over 1 Gbps network : 5:33:20
Read 4K randomly from SSD : 3 days, 11:20:00
Read 1 MB sequentially from memory : 5 days, 18:53:20
Round trip within same datacenter : 11 days, 13:46:40
Read 1 MB sequentially from SSD : 23 days, 3:33:20
Disk seek : 231 days, 11:33:20
Read 1 MB sequentially from disk : 462 days, 23:06:40
Send packet CA->Netherlands->CA : 3472 days, 5:20:00

kofemann commented Feb 9, 2013

If L1 access is a second, then:

L1 cache reference : 0:00:01
Branch mispredict : 0:00:10
L2 cache reference : 0:00:14
Mutex lock/unlock : 0:00:50
Main memory reference : 0:03:20
Compress 1K bytes with Zippy : 1:40:00
Send 1K bytes over 1 Gbps network : 5:33:20
Read 4K randomly from SSD : 3 days, 11:20:00
Read 1 MB sequentially from memory : 5 days, 18:53:20
Round trip within same datacenter : 11 days, 13:46:40
Read 1 MB sequentially from SSD : 23 days, 3:33:20
Disk seek : 231 days, 11:33:20
Read 1 MB sequentially from disk : 462 days, 23:06:40
Send packet CA->Netherlands->CA : 3472 days, 5:20:00

@kofemann

This comment has been minimized.

Show comment
Hide comment
@kofemann

kofemann Feb 9, 2013

You can add LTO4 tape seek/access time, ~ 55 sec, or 55.000.000.000 ns

kofemann commented Feb 9, 2013

You can add LTO4 tape seek/access time, ~ 55 sec, or 55.000.000.000 ns

@metakeule

This comment has been minimized.

Show comment
Hide comment
@metakeule

metakeule Jul 29, 2013

I'm missing things like sending 1K via Unix pipe/ socket / tcp to another process.
Has anybody numbers about that?

metakeule commented Jul 29, 2013

I'm missing things like sending 1K via Unix pipe/ socket / tcp to another process.
Has anybody numbers about that?

@shiplunc

This comment has been minimized.

Show comment
Hide comment
@shiplunc

shiplunc Nov 27, 2013

@metakeule its easily measurable.

shiplunc commented Nov 27, 2013

@metakeule its easily measurable.

@mnem

This comment has been minimized.

Show comment
Hide comment
@mnem

mnem Jan 9, 2014

Related page from "Systems Performance" with similar second scaling mentioned by @kofemann: https://twitter.com/rzezeski/status/398306728263315456/photo/1

mnem commented Jan 9, 2014

Related page from "Systems Performance" with similar second scaling mentioned by @kofemann: https://twitter.com/rzezeski/status/398306728263315456/photo/1

@izard

This comment has been minimized.

Show comment
Hide comment
@izard

izard May 29, 2014

L1D hit on a modern Intel CPU (Nehalem+) is at least 4 cycles. For a typical server/desktop at 2.5Ghz it is at least 1.6ns.
Fastest L2 hit latency is 11 cycles(Sandy Bridge+) which is 2.75x not 14x.
May be the numbers by Norwig were true at some time, but at least caches latency numbers are pretty constant since Nehalem which was 6 years ago.

izard commented May 29, 2014

L1D hit on a modern Intel CPU (Nehalem+) is at least 4 cycles. For a typical server/desktop at 2.5Ghz it is at least 1.6ns.
Fastest L2 hit latency is 11 cycles(Sandy Bridge+) which is 2.75x not 14x.
May be the numbers by Norwig were true at some time, but at least caches latency numbers are pretty constant since Nehalem which was 6 years ago.

@richa03

This comment has been minimized.

Show comment
Hide comment
@richa03

richa03 Aug 21, 2014

Please note that Peter Norvig first published this expanded version (at that location - http://norvig.com/21-days.html#answers) ~JUL2010 (see wayback machine). Also, note that it was "Approximate timing for various operations on a typical PC".

richa03 commented Aug 21, 2014

Please note that Peter Norvig first published this expanded version (at that location - http://norvig.com/21-days.html#answers) ~JUL2010 (see wayback machine). Also, note that it was "Approximate timing for various operations on a typical PC".

@pdjonov

This comment has been minimized.

Show comment
Hide comment
@pdjonov

pdjonov Oct 3, 2014

One light-nanosecond is roughly a foot, which is considerably less than the distance to my monitor right now. It's kind of surprising to realize just how much a CPU can get done in the time it takes light to traverse the average viewing distance...

pdjonov commented Oct 3, 2014

One light-nanosecond is roughly a foot, which is considerably less than the distance to my monitor right now. It's kind of surprising to realize just how much a CPU can get done in the time it takes light to traverse the average viewing distance...

@junhe

This comment has been minimized.

Show comment
Hide comment
@junhe

junhe Jan 16, 2015

@jboner, I would like to cite some numbers in a formal publication. Who is the author? Jeff Dean? Which url should I cite? Thanks.

junhe commented Jan 16, 2015

@jboner, I would like to cite some numbers in a formal publication. Who is the author? Jeff Dean? Which url should I cite? Thanks.

@weidagang

This comment has been minimized.

Show comment
Hide comment
@weidagang

weidagang Jan 26, 2015

I'd like to see the number for "Append 1 MB to file on disk".

weidagang commented Jan 26, 2015

I'd like to see the number for "Append 1 MB to file on disk".

@dhartford

This comment has been minimized.

Show comment
Hide comment
@dhartford

dhartford Mar 11, 2015

The "Send 1K bytes over 1 Gbps network" doesn't feel right, if you were comparing the 1MB sequential read of memory, SSD, Disk, the Gbps network for 1MB would be faster than disk (x1024), that doesn't feel right.

dhartford commented Mar 11, 2015

The "Send 1K bytes over 1 Gbps network" doesn't feel right, if you were comparing the 1MB sequential read of memory, SSD, Disk, the Gbps network for 1MB would be faster than disk (x1024), that doesn't feel right.

@leotm

This comment has been minimized.

Show comment
Hide comment
@leotm

leotm commented May 2, 2015

A great solar system type visualisation: http://joshworth.com/dev/pixelspace/pixelspace_solarsystem.html

@ali

This comment has been minimized.

Show comment
Hide comment
@ali

ali Sep 14, 2015

I turned this into a set of flashcards on Quizlet: https://quizlet.com/_1iqyko

ali commented Sep 14, 2015

I turned this into a set of flashcards on Quizlet: https://quizlet.com/_1iqyko

@misgeatgit

This comment has been minimized.

Show comment
Hide comment
@misgeatgit

misgeatgit Dec 11, 2015

Can you update the the Notes section with the following
1 ns = 10^-9 seconds
1 ms = 10^-3 seconds

Thanks.

misgeatgit commented Dec 11, 2015

Can you update the the Notes section with the following
1 ns = 10^-9 seconds
1 ms = 10^-3 seconds

Thanks.

@jboner

This comment has been minimized.

Show comment
Hide comment
@jboner
Owner

jboner commented Dec 13, 2015

@misgeatgit Updated

@juhovuori

This comment has been minimized.

Show comment
Hide comment
@juhovuori

juhovuori Dec 25, 2015

Zippy is nowadays called snappy. Might be worth updating. Tx for the gist.

juhovuori commented Dec 25, 2015

Zippy is nowadays called snappy. Might be worth updating. Tx for the gist.

@georgevreilly

This comment has been minimized.

Show comment
Hide comment
@georgevreilly

georgevreilly Jan 10, 2016

Several of the recent comments are spam. The links lead to sites in India which have absolutely nothing to do with latency.

georgevreilly commented Jan 10, 2016

Several of the recent comments are spam. The links lead to sites in India which have absolutely nothing to do with latency.

@wenjianhn

This comment has been minimized.

Show comment
Hide comment
@wenjianhn

wenjianhn Jan 12, 2016

Are there any numbers about latency between NUMA nodes?

wenjianhn commented Jan 12, 2016

Are there any numbers about latency between NUMA nodes?

@vitaut

This comment has been minimized.

Show comment
Hide comment
@vitaut

vitaut Jan 31, 2016

Sequential SSD speed is actually more like 500 MB/s, not 1000 MB/s for SATA drives (http://www.tomshardware.com/reviews/ssd-recommendation-benchmark,3269.html).

vitaut commented Jan 31, 2016

Sequential SSD speed is actually more like 500 MB/s, not 1000 MB/s for SATA drives (http://www.tomshardware.com/reviews/ssd-recommendation-benchmark,3269.html).

@BruceGooch

This comment has been minimized.

Show comment
Hide comment
@BruceGooch

BruceGooch Mar 9, 2016

You really should cite the folks at Berkeley. Their site is interactive, has been up for 20 years, and it is where you "sourced" your visualization. http://www.eecs.berkeley.edu/~rcs/research/interactive_latency.html

BruceGooch commented Mar 9, 2016

You really should cite the folks at Berkeley. Their site is interactive, has been up for 20 years, and it is where you "sourced" your visualization. http://www.eecs.berkeley.edu/~rcs/research/interactive_latency.html

@aerovistae

This comment has been minimized.

Show comment
Hide comment
@aerovistae

aerovistae Mar 10, 2016

Question~ do these numbers not vary from one set of hardware to the next? How can these be accurate for all different types of RAM, CPU, motherboard, hard drive, etc?

(I am primarily a front-end JS dev, I know little-to-nothing about this side of programming, where one must consider numbers involving RAM and CPU. Forgive me if I'm missing something obvious.)

aerovistae commented Mar 10, 2016

Question~ do these numbers not vary from one set of hardware to the next? How can these be accurate for all different types of RAM, CPU, motherboard, hard drive, etc?

(I am primarily a front-end JS dev, I know little-to-nothing about this side of programming, where one must consider numbers involving RAM and CPU. Forgive me if I'm missing something obvious.)

@jlleblanc

This comment has been minimized.

Show comment
Hide comment
@jlleblanc

jlleblanc Mar 21, 2016

The link to the animated presentation is broken, here's the correct one: http://prezi.com/pdkvgys-r0y6/latency-numbers-for-programmers-web-development

jlleblanc commented Mar 21, 2016

The link to the animated presentation is broken, here's the correct one: http://prezi.com/pdkvgys-r0y6/latency-numbers-for-programmers-web-development

@keenkit

This comment has been minimized.

Show comment
Hide comment
@keenkit

keenkit Aug 15, 2016

Love this one.

keenkit commented Aug 15, 2016

Love this one.

@profuel

This comment has been minimized.

Show comment
Hide comment
@profuel

profuel Oct 5, 2016

Mentioned gist : https://gist.github.com/2843375 is private or was removed.
can someone restore it?
Thanks!

profuel commented Oct 5, 2016

Mentioned gist : https://gist.github.com/2843375 is private or was removed.
can someone restore it?
Thanks!

@trans

This comment has been minimized.

Show comment
Hide comment
@trans

trans Oct 9, 2016

It would be nice to be able to compare this to computation times -- How long to do an add, xor, multiply, or branch operation?

trans commented Oct 9, 2016

It would be nice to be able to compare this to computation times -- How long to do an add, xor, multiply, or branch operation?

@mpron

This comment has been minimized.

Show comment
Hide comment
@mpron

mpron Oct 12, 2016

Last year, I came up with this concept for an infographic illustrating these latency numbers with time analogies (if 1 CPU cycle = 1 second). Here was the result: http://imgur.com/8LIwV4C

mpron commented Oct 12, 2016

Last year, I came up with this concept for an infographic illustrating these latency numbers with time analogies (if 1 CPU cycle = 1 second). Here was the result: http://imgur.com/8LIwV4C

@pawel-dubiel

This comment has been minimized.

Show comment
Hide comment
@pawel-dubiel

pawel-dubiel Jan 29, 2017

Most of these number were valid in 2000-2001, right now some of these numbers are wrong by an order of magnitude. ( especially reading from main memory, as DRAM bandwidth doubles every 3 years )

pawel-dubiel commented Jan 29, 2017

Most of these number were valid in 2000-2001, right now some of these numbers are wrong by an order of magnitude. ( especially reading from main memory, as DRAM bandwidth doubles every 3 years )

@maranomynet

This comment has been minimized.

Show comment
Hide comment
@maranomynet

maranomynet commented Jan 31, 2017

µs, not us

@GLMeece

This comment has been minimized.

Show comment
Hide comment
@GLMeece

GLMeece Jan 31, 2017

I realize this was published some time ago, but the following URLs are no longer reachable/valid:

However, the second URL should now be: https://prezi.com/pdkvgys-r0y6/latency-numbers-for-programmers-web-development/

Oh, and @mpron - nice!

GLMeece commented Jan 31, 2017

I realize this was published some time ago, but the following URLs are no longer reachable/valid:

However, the second URL should now be: https://prezi.com/pdkvgys-r0y6/latency-numbers-for-programmers-web-development/

Oh, and @mpron - nice!

@JustinNazari

This comment has been minimized.

Show comment
Hide comment
@JustinNazari

JustinNazari commented Jan 31, 2017

Thank you @jboner

@GLMeece

This comment has been minimized.

Show comment
Hide comment
@GLMeece

GLMeece commented Jan 31, 2017

Note: I created my own "fork" of this.

@ValerieAnne563

This comment has been minimized.

Show comment
Hide comment
@ValerieAnne563

ValerieAnne563 commented May 2, 2017

Thank you @GLMeece

@orestotel

This comment has been minimized.

Show comment
Hide comment
@orestotel

orestotel commented Jun 11, 2017

Google it

@knbknb

This comment has been minimized.

Show comment
Hide comment
@knbknb

knbknb Jun 24, 2017

Median human reaction time (to some stimulus showing up on a screen): 270 ms
(value probably increases with age)
https://www.humanbenchmark.com/tests/reactiontime/statistics

knbknb commented Jun 24, 2017

Median human reaction time (to some stimulus showing up on a screen): 270 ms
(value probably increases with age)
https://www.humanbenchmark.com/tests/reactiontime/statistics

@SonalJha

This comment has been minimized.

Show comment
Hide comment
@SonalJha

SonalJha Aug 15, 2017

Awesome info. Thanks!

SonalJha commented Aug 15, 2017

Awesome info. Thanks!

@keynan

This comment has been minimized.

Show comment
Hide comment
@keynan

keynan Sep 22, 2017

Could you please add printf & fprintf to this list

keynan commented Sep 22, 2017

Could you please add printf & fprintf to this list

@awilkins

This comment has been minimized.

Show comment
Hide comment
@awilkins

awilkins Oct 13, 2017

Heh, imagine this transposed into human distances.

1ns = 1 step, or 2 feet.

L1 cache reference = reaching 1 foot across your desk to pick something up
Datacentre roundtrip = 94 mile hike.
Internet roundtrip (California to Netherlands) = Walk around the entire earth. Wait! You're not done. Then walk from London, to Havana. Oh, and then to Jacksonville, Florida. Then you're done.

awilkins commented Oct 13, 2017

Heh, imagine this transposed into human distances.

1ns = 1 step, or 2 feet.

L1 cache reference = reaching 1 foot across your desk to pick something up
Datacentre roundtrip = 94 mile hike.
Internet roundtrip (California to Netherlands) = Walk around the entire earth. Wait! You're not done. Then walk from London, to Havana. Oh, and then to Jacksonville, Florida. Then you're done.

@benirule

This comment has been minimized.

Show comment
Hide comment
@benirule

benirule Oct 23, 2017

The last link is giving a 404

benirule commented Oct 23, 2017

The last link is giving a 404

@ahartmetz

This comment has been minimized.

Show comment
Hide comment
@ahartmetz

ahartmetz Nov 16, 2017

The numbers "Read 1 MB sequentially from memory" mean a memory bandwidth of 4 GB/s. That is a very old number. Can you update it? The time should be roughly 1/5th - one core can do about 20 GB/s today, all cores of a 4 or 8 core about 40 GB/s together. I remember seeing 18-19 GB/s in memtest86 for single core on my Ryzen 1800X and there are several benchmarks floating around where all cores do about 40 GB/s. It is very hard to find anything on the web about single core memory bandwidth...

ahartmetz commented Nov 16, 2017

The numbers "Read 1 MB sequentially from memory" mean a memory bandwidth of 4 GB/s. That is a very old number. Can you update it? The time should be roughly 1/5th - one core can do about 20 GB/s today, all cores of a 4 or 8 core about 40 GB/s together. I remember seeing 18-19 GB/s in memtest86 for single core on my Ryzen 1800X and there are several benchmarks floating around where all cores do about 40 GB/s. It is very hard to find anything on the web about single core memory bandwidth...

@jamalahmedmaaz

This comment has been minimized.

Show comment
Hide comment
@jamalahmedmaaz

jamalahmedmaaz Jan 25, 2018

Good information, thanks.

jamalahmedmaaz commented Jan 25, 2018

Good information, thanks.

@ryazo

This comment has been minimized.

Show comment
Hide comment
@ryazo

ryazo commented Jan 28, 2018

@ldavide

This comment has been minimized.

Show comment
Hide comment
@ldavide

ldavide Feb 14, 2018

there is an updated version of the latency table?

ldavide commented Feb 14, 2018

there is an updated version of the latency table?

@rcosnita

This comment has been minimized.

Show comment
Hide comment
@rcosnita

rcosnita Mar 21, 2018

Nice gist. Thanks @jboner.

rcosnita commented Mar 21, 2018

Nice gist. Thanks @jboner.

@calimeroteknik

This comment has been minimized.

Show comment
Hide comment
@calimeroteknik

calimeroteknik Apr 9, 2018

https://prezi.com/pdkvgys-r0y6/latency-numbers-for-programmers-web-development/

This prezi presentation is reversed: the larger numbers are inside the smaller ones, instead of the logical opposite.

calimeroteknik commented Apr 9, 2018

https://prezi.com/pdkvgys-r0y6/latency-numbers-for-programmers-web-development/

This prezi presentation is reversed: the larger numbers are inside the smaller ones, instead of the logical opposite.

@achiang

This comment has been minimized.

Show comment
Hide comment
@achiang

achiang commented Apr 17, 2018

Humanized version can be found: https://gist.github.com/hellerbarde/2843375

@jboner

This comment has been minimized.

Show comment
Hide comment
@jboner

jboner Apr 22, 2018

Thanks. Updated.

Owner

jboner commented Apr 22, 2018

Thanks. Updated.

@amirouche

This comment has been minimized.

Show comment
Hide comment
@amirouche

amirouche Apr 28, 2018

Where is the xkcd version?

amirouche commented Apr 28, 2018

Where is the xkcd version?

@amirouche

This comment has been minimized.

Show comment
Hide comment
@negrinho

This comment has been minimized.

Show comment
Hide comment

negrinho commented Jul 17, 2018

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment