mirror of
https://github.com/LCTT/TranslateProject.git
synced 2024-12-26 21:30:55 +08:00
Merge pull request #28956 from lkxed/20230307-3-Some-possible-reasons-for-8-bit-bytes
[手动选题][tech]: 20230307.3 ⭐️⭐️⭐️ Some possible reasons for 8-bit bytes.md
This commit is contained in:
Xingyu.Wang
GitHub
commit
93ab0ecd80
@ -0,0 +1,312 @@
|
|||||||
|
[#]: subject: "Some possible reasons for 8-bit bytes"
|
||||||
|
[#]: via: "https://jvns.ca/blog/2023/03/06/possible-reasons-8-bit-bytes/"
|
||||||
|
[#]: author: "Julia Evans https://jvns.ca/"
|
||||||
|
[#]: collector: "lkxed"
|
||||||
|
[#]: translator: " "
|
||||||
|
[#]: reviewer: " "
|
||||||
|
[#]: publisher: " "
|
||||||
|
[#]: url: " "
|
||||||
|
|
||||||
|
Some possible reasons for 8-bit bytes
|
||||||
|
======
|
||||||
|
|
||||||
|
I’ve been working on a zine about how computers represent thing in binary, and
|
||||||
|
one question I’ve gotten a few times is – why does the x86 architecture use 8-bit bytes? Why not
|
||||||
|
some other size?
|
||||||
|
|
||||||
|
With any question like this, I think there are two options:
|
||||||
|
|
||||||
|
- It’s a historical accident, another size (like 4 or 6 or 16 bits) would work just as well
|
||||||
|
- 8 bits is objectively the Best Option for some reason, even if history had played out differently we would still use 8-bit bytes
|
||||||
|
- some mix of 1 & 2
|
||||||
|
|
||||||
|
I’m not super into computer history (I like to use computers a lot more than I
|
||||||
|
like reading about them), but I am always curious if there’s an essential
|
||||||
|
reason for why a computer thing is the way it is today, or whether it’s mostly
|
||||||
|
a historical accident. So we’re going to talk about some computer history.
|
||||||
|
|
||||||
|
As an example of a historical accident: DNS has a `class` field which has 5
|
||||||
|
possible values (“internet”, “chaos”, “hesiod”, “none”, and “any”). To me that’s
|
||||||
|
a clear example of a historical accident – I can’t imagine that we’d define
|
||||||
|
the class field the same way if we could redesign DNS today without worrying about backwards compatibility. I’m
|
||||||
|
not sure if we’d use a class field at all!
|
||||||
|
|
||||||
|
There aren’t any definitive answers in this post, but I asked [on Mastodon][1] and
|
||||||
|
here are some potential reasons I found for the 8-bit byte. I think the answer
|
||||||
|
is some combination of these reasons.
|
||||||
|
|
||||||
|
#### what’s the difference between a byte and a word?
|
||||||
|
|
||||||
|
First, this post talks about “bytes” and “words” a lot. What’s the difference between a byte and a word? My understanding is:
|
||||||
|
|
||||||
|
- the **byte size** is the smallest unit you can address. For example in a program on my machine `0x20aa87c68` might be the address of one byte, then `0x20aa87c69` is the address of the next byte.
|
||||||
|
- The **word size** is some multiple of the byte size. I’ve been confused about
|
||||||
|
this for years, and the Wikipedia definition is incredibly vague (“a word is
|
||||||
|
the natural unit of data used by a particular processor design”). I
|
||||||
|
originally thought that the word size was the same as your register size (64
|
||||||
|
bits on x86-64). But according to section 4.1 (“Fundamental Data Types”) of the [Intel architecture manual][2],
|
||||||
|
on x86 a word is 16 bits even though the registers are 64 bits. So I’m
|
||||||
|
confused – is a word on x86 16 bits or 64 bits? Can it mean both, depending
|
||||||
|
on the context? What’s the deal?
|
||||||
|
|
||||||
|
Now let’s talk about some possible reasons that we use 8-bit bytes!
|
||||||
|
|
||||||
|
#### reason 1: to fit the English alphabet in 1 byte
|
||||||
|
|
||||||
|
[This Wikipedia article][3] says that the IBM System/360 introduced the 8-bit byte in 1964.
|
||||||
|
|
||||||
|
Here’s a [video interview with Fred Brooks (who managed the project)][4] talking about why. I’ve transcribed some of it here:
|
||||||
|
|
||||||
|
> … the six bit bytes [are] really better for scientific computing and the 8-bit byte ones are really better for commercial computing and each one can be made to work for the other.
|
||||||
|
> So it came down to an executive decision and I decided for the 8-bit byte, Jerry’s proposal.
|
||||||
|
>
|
||||||
|
> ...
|
||||||
|
>
|
||||||
|
> My most important technical decision in my IBM career was to go with the 8-bit byte for the 360.
|
||||||
|
> And on the basis of I believe character processing was going to become important as opposed to decimal digits.
|
||||||
|
|
||||||
|
It makes sense that an 8-bit byte would be better for text processing: 2^6 is
|
||||||
|
64, so 6 bits wouldn’t be enough for lowercase letters, uppercase letters, and symbols.
|
||||||
|
|
||||||
|
To go with the 8-bit byte, System/360 also introduced the [EBCDIC][5] encoding, which is an 8-bit character encoding.
|
||||||
|
|
||||||
|
It looks like the next important machine in 8-bit-byte history was the
|
||||||
|
[Intel 8008][6], which was built to be
|
||||||
|
used in a computer terminal (the Datapoint 2200). Terminals need to be able to
|
||||||
|
represent letters as well as terminal control codes, so it makes sense for them
|
||||||
|
to use an 8-bit byte.
|
||||||
|
[This Datapoint 2200 manual from the Computer History Museum][7]
|
||||||
|
says on page 7 that the Datapoint 2200 supported ASCII (7 bit) and EBCDIC (8 bit).
|
||||||
|
|
||||||
|
#### why was the 6-bit byte better for scientific computing?
|
||||||
|
|
||||||
|
I was curious about this comment that the 6-bit byte would be better for scientific computing. Here’s a quote from [this interview from Gene Amdahl][8]:
|
||||||
|
|
||||||
|
> I wanted to make it 24 and 48 instead of 32 and 64, on the basis that this
|
||||||
|
> would have given me a more rational floating point system, because in floating
|
||||||
|
> point, with the 32-bit word, you had to keep the exponent to just 8 bits for
|
||||||
|
> exponent sign, and to make that reasonable in terms of numeric range it could
|
||||||
|
> span, you had to adjust by 4 bits instead of by a single bit. And so it caused
|
||||||
|
> you to lose some of the information more rapidly than you would with binary
|
||||||
|
> shifting
|
||||||
|
|
||||||
|
I don’t understand this comment at all – why does the exponent have to be 8 bits
|
||||||
|
if you use a 32-bit word size? Why couldn’t you use 9 bits or 10 bits if you
|
||||||
|
wanted? But it’s all I could find in a quick search.
|
||||||
|
|
||||||
|
#### why did mainframes use 36 bits?
|
||||||
|
|
||||||
|
Also related to the 6-bit byte: a lot of mainframes used a 36-bit word size. Why? Someone pointed out
|
||||||
|
that there’s a great explanation in the Wikipedia article on [36-bit computing][9]:
|
||||||
|
|
||||||
|
> Prior to the introduction of computers, the state of the art in precision
|
||||||
|
> scientific and engineering calculation was the ten-digit, electrically powered,
|
||||||
|
> mechanical calculator… These calculators had a column of keys for each digit,
|
||||||
|
> and operators were trained to use all their fingers when entering numbers, so
|
||||||
|
> while some specialized calculators had more columns, ten was a practical limit.
|
||||||
|
>
|
||||||
|
> Early binary computers aimed at the same market therefore often used a 36-bit
|
||||||
|
> word length. This was long enough to represent positive and negative integers
|
||||||
|
> to an accuracy of ten decimal digits (35 bits would have been the minimum)
|
||||||
|
|
||||||
|
So this 36 bit thing seems to based on the fact that log_2(20000000000) is 34.2. Huh.
|
||||||
|
|
||||||
|
My guess is that the reason for this is in the 50s, computers were
|
||||||
|
extremely expensive. So if you wanted your computer to support ten decimal
|
||||||
|
digits, you’d design so that it had exactly enough bits to do that, and no
|
||||||
|
more.
|
||||||
|
|
||||||
|
Today computers are way faster and cheaper, so if you want to represent ten
|
||||||
|
decimal digits for some reason you can just use 64 bits – wasting a little bit
|
||||||
|
of space is usually no big deal.
|
||||||
|
|
||||||
|
Someone else mentioned that some of these machines with 36-bit word sizes let
|
||||||
|
you choose a byte size – you could use 5 or 6 or 7 or 8-bit bytes, depending
|
||||||
|
on the context.
|
||||||
|
|
||||||
|
#### reason 2: to work well with binary-coded decimal
|
||||||
|
|
||||||
|
In the 60s, there was a popular integer encoding called binary-coded decimal (or [BCD][10] for short) that
|
||||||
|
encoded every decimal digit in 4 bits.
|
||||||
|
|
||||||
|
For example, if you wanted to encode the number 1234, in BCD that would be something like:
|
||||||
|
|
||||||
|
```
|
||||||
|
0001 0010 0011 0100
|
||||||
|
```
|
||||||
|
|
||||||
|
So if you want to be able to easily work with binary-coded decimal, your byte
|
||||||
|
size should be a multiple of 4 bits, like 8 bits!
|
||||||
|
|
||||||
|
#### why was BCD popular?
|
||||||
|
|
||||||
|
This integer representation seemed really weird to me – why not just use
|
||||||
|
binary, which is a much more efficient way to store integers? Efficiency was really important in early computers!
|
||||||
|
|
||||||
|
My best guess about why is that early computers didn’t have displays the same way we do
|
||||||
|
now, so the contents of a byte were mapped directly to on/off lights.
|
||||||
|
|
||||||
|
Here’s a [picture from Wikipedia of an IBM 650 with some lights on its display][11] ([CC BY-SA 3.0][12]):
|
||||||
|
|
||||||
|
![][13]
|
||||||
|
|
||||||
|
So if you want people to be relatively able to easily read off a decimal number
|
||||||
|
from its binary representation, this makes a lot more sense. I think today BCD
|
||||||
|
is obsolete because we have displays and our computers can convert numbers
|
||||||
|
represented in binary to decimal for us and display them.
|
||||||
|
|
||||||
|
Also, I wonder if BCD is where the term “nibble” for 4 bits comes from – in
|
||||||
|
the context of BCD, you end up referring to half bytes a lot (because every
|
||||||
|
digits is 4 bits). So it makes sense to have a word for “4 bits”, and people
|
||||||
|
called 4 bits a nibble. Today “nibble” feels to me like an archaic term though –
|
||||||
|
I’ve definitely never used it except as a fun fact (it’s such a fun word!). The Wikipedia article on [nibbles][14] supports this theory:
|
||||||
|
|
||||||
|
> The nibble is used to describe the amount of memory used to store a digit of
|
||||||
|
> a number stored in packed decimal format (BCD) within an IBM mainframe.
|
||||||
|
|
||||||
|
Another reason someone mentioned for BCD was **financial calculations**. Today
|
||||||
|
if you want to store a dollar amount, you’ll typically just use an integer
|
||||||
|
amount of cents, and then divide by 100 if you want the dollar part. This is no
|
||||||
|
big deal, division is fast. But apparently in the 70s dividing an integer
|
||||||
|
represented in binary by 100 was very slow, so it was worth it to redesign how
|
||||||
|
you represent your integers to avoid having to divide by 100.
|
||||||
|
|
||||||
|
Okay, enough about BCD.
|
||||||
|
|
||||||
|
#### reason 3: 8 is a power of 2?
|
||||||
|
|
||||||
|
A bunch of people said it’s important for a CPU’s byte size to be a power of 2.
|
||||||
|
I can’t figure out whether this is true or not though, and I wasn’t satisfied with the explanation that “computers use binary so powers of 2 are good”. That seems very plausible but I wanted to dig deeper.
|
||||||
|
And historically there have definitely been lots of machines that used byte sizes that weren’t powers of 2, for example (from [this retro computing stack exchange thread][15]):
|
||||||
|
|
||||||
|
- Cyber 180 mainframes used 6-bit bytes
|
||||||
|
- the Univac 1100 / 2200 series used a 36-bit word size
|
||||||
|
- the PDP-8 was a 12-bit machine
|
||||||
|
|
||||||
|
Some reasons I heard for why powers of 2 are good that I haven’t understood yet:
|
||||||
|
|
||||||
|
- every bit in a word needs a bus, and you want the number of buses to be a power of 2 (why?)
|
||||||
|
- a lot of circuit logic is susceptible to divide-and-conquer techniques (I think I need an example to understand this)
|
||||||
|
|
||||||
|
Reasons that made more sense to me:
|
||||||
|
|
||||||
|
- it makes it easier to design **clock dividers** that can measure “8 bits were
|
||||||
|
sent on this wire” that work based on halving – you can put 3 halving clock
|
||||||
|
dividers in series. [Graham Sutherland][16] told me about this and made this really cool
|
||||||
|
[simulator of clock dividers][17] showing what these clock dividers look like. That site (Falstad) also has a bunch of other example circuits and it seems like a really cool way to make circuit simulators.
|
||||||
|
- if you have an instruction that zeroes out a specific bit in a byte, then if
|
||||||
|
your byte size is 8 (2^3), you can use just 3 bits of your instruction to
|
||||||
|
indicate which bit. x86 doesn’t seem to do this, but the [Z80’s bit testing instructions][18] do.
|
||||||
|
- someone mentioned that some processors use [Carry-lookahead adders][19], and they work
|
||||||
|
in groups of 4 bits. From some quick Googling it seems like there are a wide
|
||||||
|
variety of adder circuits out there though.
|
||||||
|
- **bitmaps**: Your computer’s memory is organized into pages (usually of size 2^n). It
|
||||||
|
needs to keep track of whether every page is free or not. Operating systems
|
||||||
|
use a bitmap to do this, where each bit corresponds to a page and is 0 or 1
|
||||||
|
depending on whether the page is free. If you had a 9-bit byte, you would
|
||||||
|
need to divide by 9 to find the page you’re looking for in the bitmap.
|
||||||
|
Dividing by 9 is slower than dividing by 8, because dividing by powers of 2
|
||||||
|
is always the fastest thing.
|
||||||
|
|
||||||
|
I probably mangled some of those explanations pretty badly: I’m pretty far out
|
||||||
|
of my comfort zone here. Let’s move on.
|
||||||
|
|
||||||
|
#### reason 4: small byte sizes are good
|
||||||
|
|
||||||
|
You might be wondering – well, if 8-bit bytes were better than 4-bit bytes,
|
||||||
|
why not keep increasing the byte size? We could have 16-bit bytes!
|
||||||
|
|
||||||
|
A couple of reasons to keep byte sizes small:
|
||||||
|
|
||||||
|
- It’s a waste of space – a byte is the minimum unit you can address, and if
|
||||||
|
your computer is storing a lot of ASCII text (which only needs 7 bits), it
|
||||||
|
would be a pretty big waste to dedicate 12 or 16 bits to each character when
|
||||||
|
you could use 8 bits instead.
|
||||||
|
- As bytes get bigger, your CPU needs to get more complex. For example you need one bus line per bit. So I guess simpler is better.
|
||||||
|
|
||||||
|
My understanding of CPU architecture is extremely shaky so I’ll leave it at
|
||||||
|
that. The “it’s a waste of space” reason feels pretty compelling to me though.
|
||||||
|
|
||||||
|
#### reason 5: compatibility
|
||||||
|
|
||||||
|
The Intel 8008 (from 1972) was the precursor to the 8080 (from 1974), which was the precursor to the
|
||||||
|
8086 (from 1976) – the first x86 processor. It seems like the 8080 and the
|
||||||
|
8086 were really popular and that’s where we get our modern x86 computers.
|
||||||
|
|
||||||
|
I think there’s an “if it ain’t broke don’t fix it” thing going on here – I
|
||||||
|
assume that 8-bit bytes were working well, so Intel saw no need to change the
|
||||||
|
design. If you keep the same 8-bit byte, then you can reuse more of your
|
||||||
|
instruction set.
|
||||||
|
|
||||||
|
Also around the 80s we start getting network protocols like TCP
|
||||||
|
which use 8-bit bytes (usually called “octets”), and if you’re going to be
|
||||||
|
implementing network protocols, you probably want to be using an 8-bit byte.
|
||||||
|
|
||||||
|
#### that’s all!
|
||||||
|
|
||||||
|
It seems to me like the main reasons for the 8-bit byte are:
|
||||||
|
|
||||||
|
- a lot of early computer companies were American, the most commonly used language in the US is English
|
||||||
|
- those people wanted computers to be good at text processing
|
||||||
|
- smaller byte sizes are in general better
|
||||||
|
- 7 bits is the smallest size you can fit all English characters + punctuation in
|
||||||
|
- 8 is a better number than 7 (because it’s a power of 2)
|
||||||
|
- once you have popular 8-bit computers that are working well, you want to keep the same design for compatibility
|
||||||
|
|
||||||
|
Someone pointed out that [page 65 of this book from 1962][20]
|
||||||
|
talking about IBM’s reasons to choose an 8-bit byte basically says the same thing:
|
||||||
|
|
||||||
|
- Its full capacity of 256 characters was considered to be sufficient for the great majority of applications.
|
||||||
|
- Within the limits of this capacity, a single character is represented by a
|
||||||
|
single byte, so that the length of any particular record is not dependent on
|
||||||
|
the coincidence of characters in that record.
|
||||||
|
- 8-bit bytes are reasonably economical of storage space
|
||||||
|
- For purely numerical work, a decimal digit can be represented by only 4
|
||||||
|
bits, and two such 4-bit bytes can be packed in an 8-bit byte. Although such
|
||||||
|
packing of numerical data is not essential, it is a common practice in
|
||||||
|
order to increase speed and storage efficiency. Strictly speaking, 4-bit
|
||||||
|
bytes belong to a different code, but the simplicity of the 4-and-8-bit
|
||||||
|
scheme, as compared with a combination 4-and-6-bit scheme, for example,
|
||||||
|
leads to simpler machine design and cleaner addressing logic.
|
||||||
|
- Byte sizes of 4 and 8 bits, being powers of 2, permit the computer designer
|
||||||
|
to take advantage of powerful features of binary addressing and indexing to
|
||||||
|
the bit level (see Chaps. 4 and 5 ) .
|
||||||
|
|
||||||
|
>
|
||||||
|
|
||||||
|
Overall this makes me feel like an 8-bit byte is a pretty natural choice if
|
||||||
|
you’re designing a binary computer in an English-speaking country.
|
||||||
|
|
||||||
|
--------------------------------------------------------------------------------
|
||||||
|
|
||||||
|
via: https://jvns.ca/blog/2023/03/06/possible-reasons-8-bit-bytes/
|
||||||
|
|
||||||
|
作者：[Julia Evans][a]
|
||||||
|
选题：[lkxed][b]
|
||||||
|
译者：[译者ID](https://github.com/译者ID)
|
||||||
|
校对：[校对者ID](https://github.com/校对者ID)
|
||||||
|
|
||||||
|
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
|
||||||
|
|
||||||
|
[a]: https://jvns.ca/
|
||||||
|
[b]: https://github.com/lkxed/
|
||||||
|
[1]: https://social.jvns.ca/@b0rk/109976810279702728
|
||||||
|
[2]: https://www.intel.com/content/www/us/en/developer/articles/technical/intel-sdm.html
|
||||||
|
[3]: https://en.wikipedia.org/wiki/IBM_System/360
|
||||||
|
[4]: https://www.youtube.com/watch?v=9oOCrAePJMs&t=140s
|
||||||
|
[5]: https://en.wikipedia.org/wiki/EBCDIC
|
||||||
|
[6]: https://en.wikipedia.org/wiki/Intel_8008
|
||||||
|
[7]: https://archive.computerhistory.org/resources/text/2009/102683240.05.02.acc.pdf
|
||||||
|
[8]: https://archive.computerhistory.org/resources/access/text/2013/05/102702492-05-01-acc.pdf
|
||||||
|
[9]: https://en.wikipedia.org/wiki/36-bit_computing
|
||||||
|
[10]: https://en.wikipedia.org/wiki/Binary-coded_decimal
|
||||||
|
[11]: https://commons.wikimedia.org/wiki/File:IBM-650-panel.jpg
|
||||||
|
[12]: http://creativecommons.org/licenses/by-sa/3.0/
|
||||||
|
[13]: https://upload.wikimedia.org/wikipedia/commons/a/ad/IBM-650-panel.jpg
|
||||||
|
[14]: https://en.wikipedia.org/wiki/Nibble
|
||||||
|
[15]: https://retrocomputing.stackexchange.com/questions/7937/last-computer-not-to-use-octets-8-bit-bytes
|
||||||
|
[16]: https://poly.nomial.co.uk/
|
||||||
|
[17]: https://www.falstad.com/circuit/circuitjs.html?ctz=CQAgjCAMB0l3BWcMBMcUHYMGZIA4UA2ATmIxAUgpABZsKBTAWjDACgwEknsUQ08tQQKgU2AdxA8+I6eAyEoEqb3mK8VMAqWSNakHsx9Iywxj6Ea-c0oBKUy-xpUWYGc-D9kcftCQo-URgEZRQERSMnKkiTSTDFLQjw62NlMBorRP5krNjwDP58fMztE04kdKsRFBQqoqoQyUcRVhl6tLdCwVaonXBO2s0Cwb6UPGEPXmiPPLHhIrne2Y9q8a6lcpAp9edo+r7tkW3c5WPtOj4TyQv9G5jlO5saMAibPOeIoppm9oAPEEU2C0-EBaFoThAAHoUGx-mA8FYgfNESgIFUrNDYVtCBBttg8LiUPR0VCYWhyD0Wp0slYACIASQAamTIORFqtuucQAzGTQ2OTaD9BN8Soo6Uy8PzWQ46oImI4aSB6QA5ZTy9EuVQjPLq3q6kQmAD21Beome0qQMHgkDIhHCYVEfCQ9BVbGNRHAiio5vIltg8Ft9stXg99B5MPdFK9tDAFqg-rggcIDui1i23KZfPd3WjPuoVoDCiDjv4gjDErYQA
|
||||||
|
[18]: http://www.chebucto.ns.ca/~af380/z-80-h.htm
|
||||||
|
[19]: https://en.wikipedia.org/wiki/Carry-lookahead_adder
|
||||||
|
[20]: https://web.archive.org/web/20170403014651/http://archive.computerhistory.org/resources/text/IBM/Stretch/pdfs/Buchholz_102636426.pdf
|
||||||
Loading…
Reference in New Issue
Block a user