This article delves into looking up Interesting Numbers within (as of now) the following sections:

• Networking
  • Numbers (with sheet screenshot)
  • Mitigation / Solutions
  • Resources
• SLOCs – Source Lines Of Code
  • Cars
  • OS’s
• Powers of 2  [Edit: 09 Jun 2015]

Enjoy!

Networking

• In general, one requires 1 MHz CPU power to drive 1 Mbps of data (or put another way, 1 CPU cycle per bit of data)
• Given the (heavy legacy baggage) fact that the standard Ethernet MTU (Maximum Transmission Unit) size is typically 1500 bytes:
  • A 10 Gbps network link running at wire speed, will require to transfer over 800,000 packets per second
  • The table below enumerates the story for differing Ethernet packet sizes and wire rate to be maintained

Screenshot of a sheet describing the relationship between Ethernet frame size and Line Rate to Maintain (click to enlarge)

Below Source: “Diving into Linux Networking Stack I”, MJ Schultz

Thus, at a rate of 10 Gbps, for MTU-size packets, we require to sustain a rate of processing approximately 1 packet per microsecond! (and that’s half-duplex, effectively cutting the time down to half for full-duplex)!

How is this possible?

Well, it’s not- not over sustained periods. For one, the interrupt load would be far too high for the processor to effectively handle (leading to https://en.wikipedia.org/wiki/Source_lines_of_codewhat’s called “receive livelock”). For another, the IP (and above) protocol stack processing would also be hard put to sustain these rates.

The solution is two-fold:

• hardware interrupt mitigation is achieved via the NAPI technique (which many modern drivers use as the default processing mode, switching to interrupt mode only when there are no or few packets left to process)
• Modern hardware NICs and operating systems use high performance offloading techniques (TSO / LRO / GRO). These essentially offload work from the host processor to the hardware NIC, and effectively allow large packet sizes as well.

TSO effectively lets us offload 64KB of data (to the hardware NIC for segmentation and processing). If the host did the usual TCP processing at typical MSS sizes, this works out to approximately (MTU-40)-sized segments ~= 1460 bytes.
Thus, with TSO, we get an ~ > 40X saving (65536/1460 = 44.88) on CPU utilization!

Also:

NIC Adapter	Time available between packets for MTU-size (1538 bytes) packets	Packets per second (pps)
10 Gbps	1,230 ns (1.23 us)	813,008 (~ 0.8 M pps)
40 Gbps	120 ns	8,333,333 (~ 8M pps)
100 Gbps	~ 48 ns	~ 20,833,333 (nearly 21M pps) !

[Update: 25 May 2016]:

See this presentation made by Jasper D Brouer, Principal Kernel Engineer, RedHat at DevConf, Feb 2016 : Kernel network stack challenges at increasing speeds [ODP]

 

[Update: 09 Aug 2015]:

[Inputs below from this LWN article “Improving Linux Networking Performance”, Jan 2015]

Latency-sensitive workloads:
So, we’ve got approx 48 ns to process a packet on a 100 Gbe capable network adapter. Assuming we have a 3 GHz processor, it give us:

• ~ 200 cycles to process each packet
• a cache miss will take about 32ns to resolve
• an SKB on 64-bit requires around 4 cache lines, and they’re written to during packet handling
• thus, more than 2 cache misses will wipe out the available time budget!
• what makes it worse: critical code sections require locking
  • the Intel LOCK prefix instruction (used to implement atomic operations at the machine level via cmpxchg or similar) takes ~ 8.25 ns
  • thus a spin_lock/spin_unlock section will take at least 16 ns
• System call
  • with SELinux and auditing support- ~ 75 ns
  • without SELinux and auditing support- ~ just under 42 ns

“The (Linux) kernel, today, can only forward something between 1M (M=million) and 2M packets per core every second, while some of the bypass alternatives approach a rate of 15M packets per core per second.” Source: “Improving Linux networking performance”, Jon Corbet, Jan 2015.

 

Resources

Presentation slides by Jasper D Brouer, Principal Kernel Engineer, RedHat at DevConf, Feb 2016 : Kernel network stack challenges at increasing speeds [ODP]

Large Segmentation Offload (LSO) on Wikipedia

“Improving Linux networking performance”, LWN, Jon Corbet, Jan 2015

JLS2009: Generic receive offload

Linux and TCP Offload Engines [LWN]

Whitepaper: “Introduction to TCP Offload Engines” (Dell)

Whitepaper: “Boosting Data Transfer with TCP Offload Engine Technology” (Dell, Broadcom, MS; benchmarks displayed here)

“The Ethernet standard assumes it will take roughly 50 microseconds for a signal to reach its destination.” – Source: Basic-Networking-Tutorial

---

SLOCs – Source Lines Of Code

First, please view this brilliant infographic from the “informationisbeautiful” book (and website).
And, here’s the same numbers in a Google sheet!

Cars

Below snippet directly quoted from “This Car Runs on Code”

“The avionics system in the F-22 Raptor, the current U.S. Air Force frontline jet fighter, consists of about 1.7 million lines of software code. The F-35 Joint Strike Fighter, scheduled to become operational in 2010, will require about 5.7 million lines of code to operate its onboard systems. And Boeing’s new 787 Dreamliner, scheduled to be delivered to customers in 2010, requires about 6.5 million lines of software code to operate its avionics and onboard support systems.

These are impressive amounts of software, yet if you bought a premium-class automobile recently, ”it probably contains close to 100 million lines of software code,” says Manfred Broy, a professor of informatics at Technical University, Munich, and a leading expert on software in cars. All that software executes on 70 to 100 microprocessor-based electronic control units (ECUs) networked throughout the body of your car.

…”

Edit: 04 jan 2017
“Car Software: 100M Lines of Code and Counting” – Article on LinkedIn.

 

Operating Systems

Source: Wikipedia article on SLOCs

… According to Vincent Maraia,^[1] the SLOC values for various operating systems in Microsoft‘s Windows NT product line are as follows:

Year	Operating System	SLOC (Million)
1993	Windows NT 3.1	4-5[1]
1994	Windows NT 3.5	7–8[1]
1996	Windows NT 4.0	11–12[1]
2000	Windows 2000	more than 29[1]
2001	Windows XP	45[2][3]
2003	Windows Server 2003	50[1]

David A. Wheeler studied the Red Hat distribution of the Linux operating system, and reported that Red Hat Linux version 7.1^[4] (released April 2001) contained over 30 million physical SLOC. He also extrapolated that, had it been developed by conventional proprietary means, it would have required about 8,000 man-years of development effort and would have cost over $1 billion (in year 2000 U.S. dollars).

A similar study was later made of Debian GNU/Linux version 2.2 (also known as “Potato”); this operating system was originally released in August 2000. This study found that Debian GNU/Linux 2.2 included over 55 million SLOC, and if developed in a conventional proprietary way would have required 14,005 man-years and cost $1.9 billion USD to develop. Later runs of the tools used report that the following release of Debian had 104 million SLOC, and as of year 2005, the newest release is going to include over 213 million SLOC.

One can find figures of major operating systems (the various Windows versions have been presented in a table above).

Year	Operating System	SLOC (Million)
2000	Debian 2.2	55–59[5][6]
2002	Debian 3.0	104[6]
2005	Debian 3.1	215[6]
2007	Debian 4.0	283[6]
2009	Debian 5.0	324[6]
2012	Debian 7.0	419[7]
2009	OpenSolaris	9.7
	FreeBSD	8.8
2005	Mac OS X 10.4	86[8][n 1]
2001	Linux kernel 2.4.2	2.4[4]
2003	Linux kernel 2.6.0	5.2
2009	Linux kernel 2.6.29	11.0
2009	Linux kernel 2.6.32	12.6[9]
2010	Linux kernel 2.6.35	13.5[10]
2012	Linux kernel 3.6	15.9[11]

…

---

Powers of 2

Often, especially for nerdy programmers, it’s a good idea to be familiar with powers of 2. I won’t bore you with the “usual” ones (do it yourself IOW 🙂 ).

^2 Quick Summary:

MULTIPLES OF BYTES
DECIMAL VALUE METRIC 1000 kB kilobyte 10002 MB megabyte 10003 GB gigabyte 10004 TB terabyte 10005 PB petabyte 10006 EB exabyte 10007 ZB zettabyte 10008 YB yottabyte	BINARY VALUE IEC JEDEC 1024 KiB kibibyte KB kilobyte 10242 MiB mebibyte MB megabyte 10243 GiB gibibyte GB gigabyte 10244 TiB tebibyte – – 10245 PiB pebibyte – – 10246 EiB exbibyte – – 10247 ZiB zebibyte – – 10248 YiB yobibyte – –
Orders of magnitude of data

For example, on an x86_64 running the Linux OS (kernel ver >= 2.6.x), the memory management layer divides the 64-bit process VAS (Virtual Address Space) into two regions:

• a 128 TB region at the low end for Userland (this includes the text, data, library/memory mapping and stack segments)
• a 128 TB region at the upper end for kernel VAS (the kernel segment)

How large is the entire VAS?
It’s 2^64 of course, which is 18,446,744,073,709,551,616 bytes !
Wow. What the heck’s that, you ask??
Ok easier: it’s 16 EB (exabytes)    🙂
(see the Summary Table below too).

From the Wikipedia page on Powers of 2 :

The first 96 powers of two
(sequence A000079 in OEIS)

…

Some selected powers of two

2⁸ = 256

The number of values represented by the 8 bits in a byte, more specifically termed as an octet. (The term byte is often defined as a collection of bits rather than the strict definition of an 8-bit quantity, as demonstrated by the term kilobyte.)

2¹⁰ = 1,024

The binary approximation of the kilo-, or 1,000 multiplier, which causes a change of prefix. For example: 1,024 bytes = 1 kilobyte (or kibibyte).

This number has no special significance to computers, but is important to humans because we make use of powers of ten.

2¹² = 4,096

The hardware page size of Intel x86 processor.

2¹⁶ = 65,536

The number of distinct values representable in a single word on a 16-bit processor, such as the original x86 processors.^[4]

The maximum range of a short integer variable in the C#, and Java programming languages. The maximum range of a Word or Smallint variable in the Pascal programming language.

2²⁰ = 1,048,576

The binary approximation of the mega-, or 1,000,000 multiplier, which causes a change of prefix. For example: 1,048,576 bytes = 1 megabyte (or mibibyte).

This number has no special significance to computers, but is important to humans because we make use of powers of ten.

2²⁴ = 16,777,216

The number of unique colors that can be displayed in truecolor, which is used by common computer monitors.

This number is the result of using the three-channel RGB system, with 8 bits for each channel, or 24 bits in total.

2³⁰ = 1,073,741,824

The binary approximation of the giga-, or 1,000,000,000 multiplier, which causes a change of prefix. For example, 1,073,741,824 bytes = 1 gigabyte (or gibibyte).

This number has no special significance to computers, but is important to humans because we make use of powers of ten.

2³¹ = 2,147,483,648

The number of non-negative values for a signed 32-bit integer. Since Unix time is measured in seconds since January 1, 1970, it will run out at 2,147,483,647 seconds or 03:14:07 UTC on Tuesday, 19 January 2038 on 32-bit computers running Unix, a problem known as the year 2038 problem.

2³² = 4,294,967,296

The number of distinct values representable in a single word on a 32-bit processor. Or, the number of values representable in a doubleword on a 16-bit processor, such as the original x86 processors.^[4]

The range of an int variable in the Java and C# programming languages.

The range of a Cardinal or Integer variable in the Pascal programming language.

The minimum range of a long integer variable in the C and C++ programming languages.

The total number of IP addresses under IPv4. Although this is a seemingly large number, IPv4 address exhaustion is imminent.

2⁴⁰ = 1,099,511,627,776

The binary approximation of the tera-, or 1,000,000,000,000 multiplier, which causes a change of prefix. For example, 1,099,511,627,776 bytes = 1 terabyte (or tebibyte).

This number has no special significance to computers, but is important to humans because we make use of powers of ten.

2⁵⁰ = 1,125,899,906,842,624

The binary approximation of the peta-, or 1,000,000,000,000,000 multiplier. 1,125,899,906,842,624 bytes = 1 petabyte (or pebibyte).

2⁶⁰ = 1,152,921,504,606,846,976

The binary approximation of the exa-, or 1,000,000,000,000,000,000 multiplier. 1,152,921,504,606,846,976 bytes = 1 exabyte (or exbibyte).

2⁶⁴ = 18,446,744,073,709,551,616

The number of distinct values representable in a single word on a 64-bit processor. Or, the number of values representable in a doubleword on a 32-bit processor. Or, the number of values representable in a quadword on a 16-bit processor, such as the original x86 processors.^[4]

The range of a long variable in the Java and C# programming languages.

The range of a Int64 or QWord variable in the Pascal programming language.

The total number of IPv6 addresses generally given to a single LAN or subnet.

One more than the number of grains of rice on a chessboard, according to the old story, where the first square contains one grain of rice and each succeeding square twice as many as the previous square. For this reason the number 2⁶⁴ – 1 is known as the “chess number”.

2⁷⁰ = 1,180,591,620,717,411,303,424

The binary approximation of yotta-, or 1,000,000,000,000,000,000,000 multiplier, which causes a change of prefix. For example, 1,180,591,620,717,411,303,424 bytes = 1 Yottabyte (or yobibyte).

2⁸⁶ = 77,371,252,455,336,267,181,195,264

2⁸⁶ is conjectured to be the largest power of two not containing a zero.^[5]

2⁹⁶ = 79,228,162,514,264,337,593,543,950,336

The total number of IPv6 addresses generally given to a local Internet registry. In CIDR notation, ISPs are given a /32, which means that 128-32=96 bits are available for addresses (as opposed to network designation). Thus, 2⁹⁶ addresses.

2¹²⁸ = 340,282,366,920,938,463,463,374,607,431,768,211,456

The total number of IP addresses available under IPv6. Also the number of distinct universally unique identifiers (UUIDs).

2³³³ =
17,498,005,798,264,095,394,980,017,816,940,970,922,825,355,447,145,699,491,406,164,851,279,623,
993,595,007,385,788,105,416,184,430,592

The smallest power of 2 which is greater than a googol (10¹⁰⁰).

2¹⁰²⁴ ≈ 1.7976931348E+308

The maximum number that can fit in an IEEE double-precision floating-point format, and hence the maximum number that can be represented by many programs, for example Microsoft Excel.

2^57,885,161 = 581,887,266,232,246,442,175,100,…,725,746,141,988,071,724,285,952

One more than the largest known prime number as of 2013. It has more than 17 million digits.^[6]

---

Again, from the Wikipedia page on Terabyte:

–snip–

Illustrative usage examples

Examples of the use of terabyte to describe data sizes in different fields are:

• Library data: The U.S. Library of Congress Web Capture team claims that as of March 2014 “the Library has collected about 525 terabytes of web archive data” and that it adds about 5 terabytes per month.^[20]
• Online databases: Ancestry.com claims approximately 600 TB of genealogical data with the inclusion of US Census data from 1790 to 1930.^[21]
• Computer hardware: Hitachi introduced the world’s first one terabyte hard disk drive in 2007.^[22]
• Historical Internet traffic: In 1993, total Internet traffic amounted to approximately 100 TB for the year.^[23] As of June 2008, Cisco Systems estimated Internet traffic at 160 TB/s (which, assuming to be statistically constant, comes to 5 zettabytes for the year).^[24] In other words, the amount of Internet traffic per second in 2008 exceeded all of the Internet traffic in 1993.
• Social networks: As of May 2009, Yahoo! Groups had “40 terabytes of data to index”.^[25]
• Video: Released in 2009, the 3D animated film Monsters vs. Aliens used 100 TB of storage during development.^[26]
• Usenet: In October 2000, the Deja News Usenet archive had stored over 500 million Usenet messages which used 1.5 TB of storage.^[27]
• Encyclopedia: In January 2010, the database of Wikipedia consists of a 5.87 terabyte SQL dataset.^[28]
• Climate science: In 2010, the German Climate Computing Centre (DKRZ) was generating 10000 TB of data per year, from a supercomputer with a 20 TB memory and 7000 TB disk space.^[29]
• Audio: One terabyte of audio recorded at CD quality contains approx. 2000 hours of audio. Additionally, one terabyte of compressed audio recorded at 128 kB/s contains approx. 17,000 hours of audio.
• The Hubble Space Telescope has collected more than 45 terabytes of data in its first 20 years of observations.^[30]
• The IBM computer Watson, against which Jeopardy! contestants competed in February 2011, has 16 terabytes of RAM.^[31]

–snip–

---