Binary prefixes
Return to kilo-mega-giga-tera-peta-exa-zetta-yotta
Prefixes for multiples of bits (bit) or bytes (B)
{]] | class="floatright" | " | Prefixes for multiples of [[bits (bit) or bytes (B) ]] | - | { | " !colspan="3" | [[Decimal prefix | Decimal ]] | - !colspan="1" | Value !colspan="2" | [[SI prefix | SI ]] | - | 1000 | k | binary_prefix | [[kilo- | kilo ]] | - | 1000<sup>2</sup> | M | binary_prefix | [[mega- | mega ]] | - | 1000<sup>3</sup> | G | binary_prefix | [[giga- | giga ]] | - | 1000<sup>4</sup> | T | binary_prefix | [[tera- | tera ]] | - | 1000<sup>5</sup> | P | binary_prefix | [[peta- | peta ]] | - | 1000<sup>6</sup> | E | binary_prefix | [[exa- | exa ]] | - | 1000<sup>7</sup> | Z | binary_prefix | [[zetta- | zetta ]] | - | 1000<sup>8</sup> | Y | binary_prefix | [[yotta- | yotta ]] | } | { | " !colspan="5" | [[Binary prefix | Binary ]] | - !colspan="1" | Value !colspan="2" | [[IEC 80000-13 | IEC !colspan=“2” ]] | Unit prefixes for semiconductor storage capacity | Legacy ]] | - | 1024 | Ki | binary_prefix | [[kibi- | kibi ]] | K | binary_prefix | kilo | - | 1024<sup>2</sup> | Mi | binary_prefix | [[mebi- | mebi ]] | M | binary_prefix | mega | - | 1024<sup>3</sup> | Gi | binary_prefix | [[gibi- | gibi ]] | G | binary_prefix | giga | - | 1024<sup>4</sup> | Ti | binary_prefix | [[tebi- | tebi ]] | T | binary_prefix | tera | - | 1024<sup>5</sup> | Pi | binary_prefix | [[pebi- | pebi ]] | center" | – | binary_prefix | binary_prefix | - | 1024<sup>6</sup> | Ei | binary_prefix | [[exbi- | exbi ]] | center" | – | binary_prefix | binary_prefix | - | 1024<sup>7</sup> | Zi | binary_prefix | [[zebi- | zebi ]] | center" | – | binary_prefix | binary_prefix | - | 1024<sup>8</sup> | Yi | binary_prefix | [[yobi- | yobi ]] | center" | – | binary_prefix | binary_prefix | } | - | colspan=2 | {{navbar | Bit and byte prefixes | mini=1 | }} | } ===Systematic multiples - Binary prefixes=== Terms for large quantities of [[bits can be formed using the standard range of SI prefixes for powers of 10, e.g., kilo- | kilo = 103 = 1000 (as in kilobit or kbit), mega- | mega = 106 =
(as in megabit or Mbit) and giga- | giga = 109 =
(as in gigabit or Gbit). These prefixes are more often used for multiples of bytes, as in kilobyte (1 kB = 8000 bit), megabyte (1 MB =
), and gigabyte (1 GB =
).
However, for technical reasons, the capacities of computer memories and some storage units are often multiples of some large power of two, such as 228 =
bytes. To avoid such unwieldy numbers, people have often repurposed the SI prefixes to mean the nearest power of two, e.g., using the prefix kilo for 210 = 1024, mega for 220 =
, and giga for 230 =
, and so on. For example, a random access memory chip with a capacity of 228 bytes would be referred to as a 256-megabyte chip. The table below illustrates these differences.
{]] | class="wikitable" ! Symbol ! Prefix ! [[SI prefix | SI Meaning ! Binary prefix | Binary meaning ! Size difference ]] | - | k | kilo | = 1000<sup>1</sup> | = 1024<sup>1</sup> | 2.40% | - | M | mega | = 1000<sup>2</sup> | = 1024<sup>2</sup> | 4.86% | - | G | giga | = 1000<sup>3</sup> | = 1024<sup>3</sup> | 7.37% | - | T | tera | = 1000<sup>4</sup> | = 1024<sup>4</sup> | 9.95% | - | P | peta | = 1000<sup>5</sup> | = 1024<sup>5</sup> | 12.59% | - | E | exa | = 1000<sup>6</sup> | = 1024<sup>6</sup> | 15.29% | - | Z | zetta | = 1000<sup>7</sup> | = 1024<sup>7</sup> | 18.06% | - | Y | yotta | = 1000<sup>8</sup> | = 1024<sup>8</sup> | 20.89% | } In the past, uppercase ''K'' has been used instead of lowercase ''k'' to indicate 1024 instead of 1000. However, this usage was never consistently applied. On the other hand, for external storage systems (such as [[optical discs), the SI prefixes are commonly used with their decimal values (powers of 10). There have been many attempts to resolve the confusion by providing alternative notations for power-of-two multiples. In 1998 the International Electrotechnical Commission (IEC) issued a standard for this purpose, namely a series of binary prefixes that use 1024 instead of 1000 as the main radix:<ref name=“IEC80000_2005”/>
{]] | class="wikitable" ! Symbol ! Prefix ! colspan=3 | binary_prefix | - | Ki | kibi, ''binary kilo'' | 1 [[kibibyte (KiB) ]] | 2<sup>10</sup> bytes | 1024 B | - | Mi | mebi, ''binary mega'' | 1 [[mebibyte (MiB) ]] | 2<sup>20</sup> bytes | 1024 KiB | - | Gi | gibi, ''binary giga'' | 1 [[gibibyte (GiB) ]] | 2<sup>30</sup> bytes | 1024 MiB | - | Ti | tebi, ''binary tera'' | 1 [[tebibyte (TiB) ]] | 2<sup>40</sup> bytes | 1024 GiB | - | Pi | pebi, ''binary peta'' | 1 [[pebibyte (PiB) ]] | 2<sup>50</sup> bytes | 1024 TiB | - | Ei | exbi, ''binary exa'' | 1 [[exbibyte (EiB) ]] | 2<sup>60</sup> bytes | 1024 PiB | } The [[JEDEC memory standards | JEDEC memory standard JESD88F notes that the definitions of kilo (K), giga (G), and mega (M) based on powers of two are included only to reflect common usage.<ref name=“JEDEC_2018_Terms”/>
- Snippet from Wikipedia: Binary prefix
A binary prefix is a unit prefix that indicates a multiple of a unit of measurement by an integer power of two. The most commonly used binary prefixes are kibi (symbol Ki, meaning 210 = 1024), mebi (Mi, 220 = 1048576), and gibi (Gi, 230 = 1073741824). They are most often used in information technology as multipliers of bit and byte, when expressing the capacity of storage devices or the size of computer files.
The binary prefixes "kibi", "mebi", etc. were defined in 1999 by the International Electrotechnical Commission (IEC), in the IEC 60027-2 standard (Amendment 2). They were meant to replace the metric (SI) decimal power prefixes, such as "kilo" (k, 103 = 1000), "mega" (M, 106 = 1000000) and "giga" (G, 109 = 1000000000), that were commonly used in the computer industry to indicate the nearest powers of two. For example, a memory module whose capacity was specified by the manufacturer as "2 megabytes" or "2 MB" would hold 2 × 220 = 2097152 bytes, instead of 2 × 106 = 2000000.
On the other hand, a hard disk whose capacity is specified by the manufacturer as "10 gigabytes" or "10 GB", holds 10 × 109 = 10000000000 bytes, or a little more than that, but less than 10 × 230 = 10737418240 and a file whose size is listed as "2.3 GB" may have a size closer to 2.3 × 230 ≈ 2470000000 or to 2.3 × 109 = 2300000000, depending on the program or operating system providing that measurement. This kind of ambiguity is often confusing to computer system users and has resulted in lawsuits. The IEC 60027-2 binary prefixes have been incorporated in the ISO/IEC 80000 standard and are supported by other standards bodies, including the BIPM, which defines the SI system,: p.121 the US NIST, and the European Union.
Prior to the 1999 IEC standard, some industry organizations, such as the Joint Electron Device Engineering Council (JEDEC), attempted to redefine the terms kilobyte, megabyte, and gigabyte, and the corresponding symbols KB, MB, and GB in the binary sense, for use in storage capacity measurements. However, other computer industry sectors (such as magnetic storage) continued using those same terms and symbols with the decimal meaning. Since then, the major standards organizations have expressly disapproved the use of SI prefixes to denote binary multiples, and recommended or mandated the use of the IEC prefixes for that purpose, but the use of SI prefixes in this sense has persisted in some fields.
Cloud Monk is Retired ( for now). Buddha with you. © 2025 and Beginningless Time - Present Moment - Three Times: The Buddhas or Fair Use. Disclaimers
SYI LU SENG E MU CHYWE YE. NAN. WEI LA YE. WEI LA YE. SA WA HE.
Memory management: Dynamic memory management, C language memory management, C dynamic memory allocation - C memory (malloc, realloc, calloc, C free, mimalloc), C Plus Plus memory | C++ memory (automatic storage duration, C Plus Plus auto | C++ auto, RAII), C Sharp memory | memory, Binary prefixes (kilo-mega-giga-tera-peta-exa-zetta-yotta), Manual memory management, Memory management (operating systems) (Linux memory - UNIX memory, Android memory, IBM mainframe memory, iOS memory, macOS memory, Windows memory), Memory: Memory address, Address space, Memory allocation - Memory allocator, Bash memory, Memory deallocation - Deallocation, Memory debugger (Memwatch, mtrace), Memory diffusion, Dynamic memory, Memory fence (Memory barrier), Memory fragmentation] - Fragmentation, Free list, Garbage collection - Garbage collector, Golang memory, Heap or Free store (Heap-based memory allocation), Stack (Call stack - Stack-based memory allocation - Stack (abstract data type) - LIFO (computing) - Stack frame - Stack unwinding), JVM memory (Java memory - Kotlin memory - Scala memory), Memory leak, Memory model, Memory paging, Out of memory, Page (computer memory), Pointers, C language pointers, Automatic pointer, Pointer swizzling, Memory pool, Memory protection, Physical memory, PowerShell memory, Python memory, RAM, Memory reference (Reference counting - Soft reference - Weak reference), Resource allocation (Resource Acquisition Is Initialization - RAII), Resource leak, Rust memory, Memory segmentation, Memory utilization, Shared memory, Static variable - Automatic variable, Virtual memory, Virtual address space. Category of Memory management. (navbar_memory_management. See also navbar_memory or navbar_data_storage)