This is kind of an extension to a [previous question]
TL;DR:
The 7030 addressing, works for many instructions, on bit level, not words. Next to all data structures, including bytes, could be located at any bit address. All addressing was always done using 24 bit.
Byte is not a hard defined entity like today, but simply a name for a repeated bit-group (i.e. 1 or more) that is stored consecutive in memory, position and element size (and element number) is part of instructions that handle such groups.
Description of the term byte from the reference manual p.11.
From today's viewpoint these groups could be seen as a variable sized array of integers of arbitrary (but all the same) size. Something usually called a vector. And instructions working thereon are vector operations(*1). After all, a decimal number is nothing else than a vector of digits, isn't it? Likewise a string being a vector of characters. Some languages even call strings that, a vector of integers/chars/ordinals.
You need to get rid of bytes and words. Words have only a meaning for the memory interface. And bytes (on 7030) are only really meaningful when it's about BCD (well, and a few abuses thereof to do text ... and to mark sign handling in integers ...).
Time for a Rant
(Caveat, @NoNameQA, this is not personal in any way, just a generic observation which fits here)
CPU's aren't by default the primitive cogwheel constructions as told today. Something that takes a byte, does an integer operations thereon and stores it again. Anything else are bells and whistles and FP being something like a necessary rucksack to schlepp. They can be a lot more. Anything you want them to be and the 7030 is a great example what could have been, if it weren't for the /360 normalizing all of that into a consisted and simple framework and the dreaded C to turn that in to an even more primitive pile of bytes and nothing else.
All since then was primitivizing CPUs to fit that concept of the bare minimum, just to later on throw billions and ever billions of transistors onto the resulting primitive code to make some sense of it. The same stupidity that got us RISC - don't let me start on that.
And it's the same run to stupidity that made cohorts of programmers stroke the poor little 8088 against the grain by calculating 'far' pointers. It's a frickin' 16 bit CPU, not 20 or whatsoever.
If one wants to learn about a new CPU, it might not be necessary has to drop every previous knowledge, but it helps a lot to be flexible in redefining everything. While it's thus useful to compare with previous learned concepts, there is no sense in trying to project it back. Especially not based on words. Different CPUs use different languages, and much like human languages, words can be false friends, meaning the same word (spelling/pronounciation) used in two both languages has different meaning in either. Eventually complete opposite ... a sentence already an example, as in German 'Eventuell' has a meaning of 'under certain conditions' so rather like 'maybe'. Both are based on the same Latin 'eventualis' covering somehow both meanings. And the 7030's use of byte is like a prime example of this in the computer world: It's byte is a pice of a word, and it can describe some kind of character or digit, but that's it.
So, again, DO NOT try to press new knowledge into existing. It exists in parallel and in relation, but it's almost never a sub- or super-set. And most of all, each CPU is special on it's own.
The Details
According to assembler manual byte had size from 1 to 8 bits and we could specify this size in the code.
Not had but could have.
Using bytes was only a thing when doing operations on a set of them. Like when doing BCD calculation, a byte size of 4 would be nice, but the machine could as well operate with 6 bit BCD or 5 bit.
By using asm
Or any other language.
Therefore, to do that we need to use 3 bits to specify byte size (form 1 to 8). Also we need 6 bits to specify byte address inside the word, since if byte size is 1 bit, then it can be in any of 64 positions inside the word
You seam to be stuck by an implied byte position within a word. That is a feature (*2) of modern, canonical CPUs, but the 7030 isn't one of those. A byte (group) can start at any position regardless of the byte size.
It uses bit addressing with 24 bit.
You need to get rid of bytes and words. Words have only a meaning for the memory interface. And bytes are only really meaningful when it's about BCD (well, and a few abuses thereof to do text). The 7030 operates on a memory of bits ... 16 megabits of continuous memory. And the memory interface is made up of two 64 bit 'look ahead' registers for each access, so any data item used can spread across memory words. This hides the word structure from any data access.
Example for memory organisation from the reference manual p.17.
Only instructions are to be aligned on 32 bit boundaries. That's why the address field in branch and indexing instruction is 19 bit. This is simply done to improve performance.
Therefore, to navigate to the particular byte we need 18+3+6=30 bits,
To start with, 18+6+3 is only 27, not 30.
and therefore we have 64-30=34 unused bits.
Unused by what and why?
An address comes either from one of the 16 index registers, with only the lower 24 bit used, or from within the instruction, were it may be 18, 19, 24 (see p.18 of the reference manual).
An instruction has 32 or 64 bit and will of course contain more than just an address ... most likely opcode bits to identify the instruction and its length. For byte operations like integer arithmetic, as seen here:
This includes in detail:
- 24 bit address,
- 4 bits identifying this as an arithmetic integer instruction
- 4 bits specifying an index register
- 3 bits spcifying the address mode
- 6 bits defining the operand and result length in total
- 3 bits for byte size if it's a byte type operation
- 7 bits of offset within the 128 bit accumulator the value/result is to be placed
- 2 bits modifier for sign handling for either operand
- 1 bit marker for using BCD or binary arithmetic
- 6 bits specifying the operation type (Add, Mul, Load, ...)
- 4 bits specifying an index register to be used to modify length, byte size and offset.
Together 64 bits, not a single bit wasted.
If all my guesses are correct, why did byte has size maximum 8 bits? IBM could make it much larger.
Or smaller. this is not a good question to be asked on RC.SE as it asks for motivation/reasoning which is usually not preserved in full detail. In this case the reference manual (again) offers a hint when discussing BCD arithmetic and zoning:
Again reference manual this time p.58.
So one reason might have been that with values between 4 and 6 being useful for BCD, 3 bits would be needed anyway, so anything up to 8 is possible without spending more bits. And belive me, zoning was an important issue back then at the boundry between punch card processing and computers. The /360, otherwise not really into much specialized handling has in addition to all BCD instructions three instruction to handle the zone part (upper 4 bits) of a byte: MVN, MVO and MVZ.
*1 - If someone now draws a line to vector CPUs (and ultimately GPUs), he's right. One reason why the 7030 is often called the first supercomputer.
*2 - Or better drawback of the byte/word relation the /360 planted and everyone took.
