Wikipedia says that many of the early machines were accumulator-based machines.
My guess is that in those machines the accumulator did not play the role of a speed-up register as do registers in today load and store architectures.

The accumulator had mainly the role of implicit operand so that instructions could be shorter
(one operand of an arithmetic operation always resided there and also its result was stored in the accumulator)

Is my guess right ?


I think it depends on the machine, its design aims and the limitations of the technology.

Most traditional accumulator machines have very few registers, and many only have a single ‘general-purpose’ register (by today's standards). On the PDP-8, for example, there are a few registers, but the only one you can access directly is the AC. The vast majority of instructions (not that ‘vast’ applies to a design with eight instructions) operate on the AC. The only other object to operate on is memory, so most instructions have a single field (a 7-bit address). The data transfer direction is implicit in the instruction (think load/store).

On the other hand, the machine languages of many accumulator machines were a side effect of the system architecture more so than the other way round (which is how we do it today, software being king). The PDP-8 was an accumulator machine because, well, 12 bits worth of flip-flops were pretty expensive equipment in the late 60s and the PDP-8 was a cheap computer.

As for the speed factor: in-processor registers were almost always faster than memory, same as now. But their cost was much higher than it is now, instruction widths were smaller, sequencers and state machines were much simpler, and so there weren't many registers. Unless you have at least two of them, you can keep your instruction set very simple. And vice versa.

Also, with respect to early computers using ‘accumulators’ instead of ‘registers’: ‘accumulator’ came from its use in tabulating machines to denote registers for running totals. Presumably operators would have been more comfortable with the term. The PDP-8 schematics refer to every single flip-flop in the system as a ‘register’, but there's only one ‘accumulator’ and it's marked as a ‘major’ register.


Any machine which is going to perform an ALU operation on two operands has to have a means of getting both operands to the ALU. If a machine were to allow operations to be performed on arbitrary combinations of register operands, every register would need a path to both ALU inputs. If, by contrast, one of the ALU inputs will always be either the accumulator, a constant determined by the opcode, or possibly one other holding register, then registers other than the accumulator will only need a path to the other ALU input (and the accumulator probably won't need a path to that one).


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.