Word to Exabit

A word's size depends on the CPU architecture. In x86/x64 (Intel/AMD) documentation: word = 16 bits, DWORD = 32 bits, QWORD = 64 bits. In ARM 32-bit: word = 32 bits. In most modern 64-bit systems (excluding x86 documentation): word = 64 bits. When reading technical documentation, always check the architecture's definition, as "word" is not a universal fixed size.

In Windows API documentation and x86 architecture, a DWORD (Double Word) = 32 bits = 4 bytes, capable of holding values 0–4,294,967,295 (unsigned) or -2,147,483,648 to 2,147,483,647 (signed). DWORD is the most common fixed-width integer type in the Windows API, used for flags, handles, and return codes. The equivalent in modern C/C++ is uint32_t (unsigned) or int32_t (signed).

A CPU's word size determines: (1) the maximum addressable memory — a 32-bit CPU addresses up to 4 GiB (2³² bytes); a 64-bit CPU addresses up to 16 EiB (2⁶⁴ bytes); (2) the precision of integer arithmetic — a 64-bit word handles numbers up to ~18.4 × 10¹⁸ in a single instruction; (3) performance — operations on data smaller than the word size may require extra sign-extension instructions on some architectures.

Modern x86-64 CPUs (Intel Core, AMD Ryzen) have 64-bit general-purpose registers, so their native word size is 64 bits for most operations. However, x86 documentation maintains the legacy definition: "word" = 16 bits, DWORD = 32 bits, QWORD = 64 bits. This creates a confusing terminology mismatch between the architectural naming convention and the physical register size.

Memory alignment means storing data at addresses that are multiples of the data's size. A 32-bit word should be stored at an address divisible by 4 (bytes); a 64-bit word at an address divisible by 8. Misaligned access is either forbidden (causes a CPU fault) or penalised (requires two memory reads instead of one). Compilers automatically align variables; manual struct packing can create misalignment that causes subtle performance issues or crashes on strict architectures.

One exabit = 10¹⁸ bits = 125,000 terabytes = 125 petabytes. If every person on Earth (8 billion people) each stored 15 GB of data — roughly a modern smartphone's photos and messages — the total would be about 120 exabytes, or about 960 exabits. The entire human genome is about 1.5 GB; sequencing every person on Earth would produce about 12 exabytes of data.

Cisco's annual internet traffic reports estimated global IP traffic at roughly 4.8 exabytes per day in 2022, rising about 20% per year. Expressed in bits, that's about 38 exabits per day or roughly 440 petabits per second continuously. Video streaming accounts for over 60% of total internet traffic volume.

Data gravity is the principle that massive datasets attract applications, services, and additional data toward them — rather than being moved to where processing occurs. At exabit scale, physically transferring data becomes impractical: moving 1 exabit over a 100 Gbps link takes 116 days. Instead, companies deploy compute resources alongside the data. This effect drives cloud concentration — once an organisation stores exabits in AWS or Azure, the cost and latency of moving that data elsewhere creates powerful vendor lock-in, shaping the economics of the entire cloud industry.

The Square Kilometer Array (SKA), under construction in Australia and South Africa, will be the world's largest radio telescope. Its thousands of antennas will collectively produce roughly 1 exabit of raw sensor data per day — more than the entire global internet traffic of the early 2000s. This data cannot be stored in full; instead, on-site supercomputers reduce it by a factor of ~10,000 in real time, keeping only scientifically relevant signals. The SKA illustrates how radio astronomy pushes data processing to extreme scales that rival commercial internet infrastructure.

At 1 Gbps (a fast home connection), downloading 1 exabit would take 1 billion seconds — about 31.7 years. At 1 Tbps (a high-end data center link), it would take 1 million seconds, or about 11.6 days. This illustrates why exabit-scale data movements require massively parallel infrastructure — no single link or device handles exabit transfers directly.