Exabyte to Word

One exabyte = 1,000,000 terabytes = 1,000 petabytes. If you filled 1 TB external hard drives and stacked them end to end, 1 EB worth would stretch roughly 200 km. In content terms: 1 EB can store about 250,000 years of HD video, or about 100 billion hours of music at 128 kbps. All the data produced by the Large Hadron Collider per year is about 15 petabytes — still 67× less than one exabyte.

Global data creation, capture, copy, and consumption is estimated at roughly 2.5 exabytes per day (IDC 2023 estimate), growing roughly 23% annually. This includes IoT sensor readings, financial transactions, social media posts, surveillance camera footage, scientific instrument output, and all other digital activity. Most of this data is transient and never stored long-term.

Amazon Web Services, Microsoft Azure, and Google Cloud each store estimated tens to hundreds of exabytes of customer data in their cloud platforms. Meta (Facebook/Instagram) stores an estimated 100+ exabytes across all data types. The NSA's Utah Data Center is estimated to hold yottabytes in capability, though actual stored volumes are classified. Collectively, global cloud storage is in the hundreds-of-exabytes range.

An exabyte (EB) = 10¹⁸ bytes (SI decimal). An exbibyte (EiB) = 2⁶⁰ bytes = 1,152,921,504,606,846,976 bytes — about 15.3% larger. This is the largest practically relevant gap between SI and IEC units in storage contexts. For a data center procuring 10 EB of storage, the SI vs IEC difference represents about 1.5 EB of capacity discrepancy in the contract.

Data archaeology is the practice of recovering information from obsolete storage media and formats — 9-track magnetic tapes, 8-inch floppy disks, MiniDiscs, Zip drives, and early optical formats. The challenge is threefold: hardware to read the media no longer exists or is failing, file formats and encoding schemes are undocumented, and magnetic media degrade over time (tape has a 10–30 year shelf life). At exabyte scale, organisations like national archives face the prospect of vast digital collections becoming unreadable within decades. Active migration strategies — periodically copying data to current formats and media — are the only reliable defense, but the cost scales linearly with data volume.

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.