2

In 1950s machines had a 36 bit words. And in this word we could pack symbols using 6 bits. And to fetch this symbols from the word programmer should do it using bit manipulations.

In 1961 IBM released 7030 machine that also had word addressable memory. On the other hand, this machine was the first one which used term byte with 8 bits.

My first assumption about "why we need a byte term" was the following:

If this 8 bits were addressable, we could store and get any 8 bit symbol from memory without any bit manipulations. But if memory was word addressable my assumption rises a contradiction: how we could address a single byte if memory was word addressable?

So my question is: what was the point of using term byte in IBM 7030, if memory was word addressable and we can not get any benefits from byte?

  • 5
    I think your conclusion that there would only be a benefit from introducing the term byte if the machine was byte adressable is wrong. If you repeatedly need to refer to a unit of 8 bits, it makes sense to give that unit a name, even if it exists only conceptually. – Michael Graf Jun 24 at 10:11
  • Also, maybe somepne who knows more about the 7030 and the 360 than I do can clear this up: Did either of these machines use byte adressable memory? If not, we should change the headline of the question. – Michael Graf Jun 24 at 10:14
  • 4
    7030=word addressable. 360=byte addressable. I think the 360 introduced byte-addressable memory. – another-dave Jun 24 at 11:06
  • @another-dave Erm yes and no. The /360 uses a byte address, but the 7030 as well. At least in the sense that several instructions can explicite address a byte section within a word. So while the basic access to memory is word wise, from a programmers view it can be byte wise - although, not always linear. The versatile data definition mechanics of a 7030 are a bit too complex to be described with a single term like byte or word addressing. – Raffzahn Jun 24 at 12:32
  • 1
    You do a secondary addressing of a byte in the word with a bit mask instruction. The byte location is just not encoded in the memory address but somewhere else. The machine isn't byte addressable doesn't means the program isn't either. – user3528438 Jun 24 at 17:02
10

[Please see as well this answer, as it's kind of an extension]

Why did IBM 7030 or IBM 360 use byte and word addressing simultaneously

Not sure what's with /360 reference here, as it's uses byte addressing (*1).

The 7030 in contrast used word and bit addressing.

Word addressing of 18 bit when it was about words, and bit addressing in the form of a 24 bit address when it was about 'bytes'. A word address is always stored in the first 18 bits of an instruction word (32/64 bit), followed by 6 bit holding the bit address for instructions accessing chunks of a word (a majority). Most of them contained as well the bit length (up to 64). (*2,*3)

In 1950s machines had a 36 bit words.

Some had, others had different word sizes, like 18, 22 or 72.

And in this word we could pack symbols using 6 bits. And to fetch this symbols from the word programmer should do it using bit manipulations.

Some supported 6 bit sizes, other none or arbitrary.

In 1961 IBM released 7030 machine that also had word addressable memory. On the other hand, this machine was the first one which used term byte with 8 bits.

No. While Werner Buchholz did coin the term Byte when working on the 7030, it didn't describe a unit of 8 bit, but a variable size definition for a bit group of 1 to 8 bits (*4), defined in each instruction as needed. Others took it the same way, simply as an arbitrary number of bits anywhere between 4 and 9 (*5), depending on machine and/or language, 'bitten' out of a word.

If this 8 bits were addressable, we could store and get any 8 bit symbol from memory without any bit manipulations. But if memory was word addressable my assumption rises a contradiction: how we could address a single byte if memory was word addressable?

By extracting that byte? A byte access in a 7030 consists of a word address and a byte address within. Byte access was done by using a data description (dds) made up of mode, field length and byte size

So my question is: what was the point of using term byte in IBM 7030, if memory was word addressable and we can not get any benefits from byte?

Byte in the 7030 sense isn't a fixed sub unit of a word like today, but a variable length unit within a variable length fiel within a word.

At that point it may be helpful to peek into the 7030 Assembler manual, as about half of it is dedicated to data definition and how this is handled. It's worlds away from what is canon today and way more like some HLL (*6).


*1 - Another standard IBM did set. All addressing was bytewise, independent of word length or position. It simplified memory access to what we now take for granted.

  • All addresses had the same format and size
  • All were byte addresses
  • No address calculation between data types needed
  • Halfwords and words are fixed length collection of fixed size bytes
  • The only speciality of words and halfwords was that they had to be alligned to their size.

All this we take for granted today and many have a hard time to understand that the world before the /360 was different. More colourful but more chaotic as well.

*2 - Any length up to 64 bits could be used and bit addresses warped to word addresses. So it was not only possible to pack 3 21-bit integers into a word without any need for conversion, but as well spread such bitfields across words - like 30 12-bit integer over 3 words :)

*3 - I personally thing the object orientated bit-mongering of Intel's 432 was quite influenced by the way the 7030 handeled it's data.

*4 - The Assembler used default sizes of 1, 4 or 8, depending on the mode field, if none were given explicite or by data definitions.

*5 - Or simply used byte as a term for any bit defined chunk different from a word - as in "A Bite from a Word" - like the PDP-10s bit field operations handling variable length sections of 1..36 bit were as well called byte.

*6 - In some way it shows the quintessence of computer development between back then and today. In the old days computers were enhanced to offer instructions the programmer can use deliver the task, while today instructions are simplified and programmers work hard to please the compiler.

| improve this answer | |
  • Thank you! Your answer is the best answer I have ever seen among all of the answers for all of my question at all stack overflow resources! Thank you SO much for your effort. One more question. According to the link that you provided to 7030 asm. I didn’t get the following: it seems that 7030 used 6 bits to store symbol, but used 1 or 4 or 8 bits for byte. How it was possible to fetch symbol from a word? – No Name QA Jun 24 at 12:30
  • @NoNameQA It can use any byte size between 1 and 8 - wich includes 6. 1,2 and 4 are only default sizes depending on the instruction, when no other size is given. By defining data for example DD (BU, 60, 6), DO NOT PANIC Q would define a data structure, holding unsigned binary (BU) in fields of 60 bit with bytes of 6 bit, to be prefilled with the conversion of the 15 characters following (' DO NOT PANIC '). Q in this case marks the string termination. Fetching could now be done symbolic by using the data name and a byte offset, which gets turned into a bitaddress by the assembler. – Raffzahn Jun 24 at 13:04
  • 1
    @NoNameQA Erm ... you're trying something, right? :) How many values are there in the range of 0..7, and ho many do you need to hold the length of the bit field being 1..8? I mean, noone in his right mind (at least back then and real programmers) would waste another bit, making it 4 bits, just to preserve the otherwise illegal length of zero? Not to mention adding 7 more illegal values and complicating the decoder? – Raffzahn Jun 24 at 13:58
  • 1
    Erm ... you're trying something, right? :)) I'm just want to make sure that I understood everything correctly. Thank you one more time. You are amazing! – No Name QA Jun 24 at 14:04
  • 1
    There were also multiple 40-bit machines in the 50s (all IAS lineage machines I am aware of). – Vatine Jun 24 at 15:10
6

'Byte' was used before it meant '8 bits' and It was used on machines that had word-addressable memory. The point was for the program to be able to read and write data of less than a word size.

The PDP-10, with which I am familiar, had "load byte" and "deposit byte" instructions which could read any part of a word, sized from 0 to 36 bits. As far as memory was concerned, whole words would be transferred; the ALU would handle the shifting and masking required to extract/insert the designated field. Since memory was word-addressable, a special address format was required for these instructions - it had a standard address, and also offset-in-word and size-of-byte fields (6 bits each).

The byte instructions were heavily used, for example, for manipulating text. The standard format was 7-bit bytes (ASCII encoding) packed 5 to a word, with one bit left over. The byte instructions made it trivial to process such a format.

Absent such instructions, the programmer would have had to write the and mask instructions himself.

Stretch (the 7030) was similar. It had a standard 18-bit address for word operations, and an extended format that specified the exact bitfield on which to operate. As with the PDP-10, the term 'byte' is used regardless of the bit count of the field.

'Individual characters, or bytes, in a field may also be varied in length' -- see the section on Integer Arithmetic in the 7030 ref manual. The terminology is slightly different from the PDP-10; it seems words were divided into fields and fields were divided into bytes of 1 to 8 bits.

| improve this answer | |
  • Things got more "interesting" on word-addressing computers after C came along, and you have to implement variables that are pointers to char, and can support pointer arithmetic. (And of course evil C programmers think all pointer types are really just quiche-eating declarations of "pointer to void"...) – alephzero Jun 24 at 13:43
  • At one point in my student life, I needed 8-bit character pointers on a 24-bit word-oriented 6-bit-char ICL 1906A. And this was before I could even spell "C". (Fortunately the requirement was "make it work" not "make it efficient"). – another-dave Jun 24 at 23:07
  • @alephzero: A major problem with C is that the Standard fails to recognize concepts which are common among many but not all implementations. If the Standard were to expressly recognize of implementations that offer various features and guarantees that are practical and useful on many but not all platforms, that would make the language more useful for both commonplace and obscure platforms. – supercat Jun 25 at 19:19

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.