View source for Accumulator (computing)

{{short description|Register in which intermediate arithmetic and logic results of a CPU are stored}}
[[File:Walther WSR-16 Inside the Machine.jpg|300px|thumb|Walther WSR-16 mechanical calculator. The row of digit-wheels in the carriage (at the front), is the Accumulator.]]
{{more citations needed|date=February 2024}}

In a [[computer]]'s [[central processing unit]] (CPU), the '''accumulator''' is a [[processor register|register]] in which intermediate [[arithmetic logic unit]] results are stored. 

Without a register like an accumulator, it would be necessary to write the result of each calculation (addition, multiplication, [[Bitwise operation#bit shifts|shift]], etc.) to [[Cache (computing)|cache]] or [[main memory]], perhaps only to be read right back again for use in the next operation. 

Accessing memory is slower than accessing a register like an accumulator because the technology used for the large main memory is slower (but cheaper) than that used for a register. Early electronic computer systems were often split into two groups, those with accumulators and those without.

Modern computer systems often have multiple general-purpose registers that can operate as accumulators, and the term is no longer as common as it once was. However, to simplify their design, a number of special-purpose processors still use a single accumulator.

== Basic concept ==
Mathematical operations often take place in a stepwise fashion, using the results from one operation as the input to the next. For instance, a manual calculation of a worker's weekly payroll might look something like:

# look up the number of hours worked from the employee's time card
# look up the pay rate for that employee from a table
# multiply the hours by the pay rate to get their basic weekly pay
# multiply their basic pay by a fixed percentage to account for income tax
# subtract that number from their basic pay to get their weekly pay after tax
# multiply that result by another fixed percentage to account for retirement plans
# subtract that number from their basic pay to get their weekly pay after all deductions

A computer program carrying out the same task would follow the same basic sequence of operations, although the values being looked up would all be stored in computer memory. In early computers, the number of hours would likely be held on a [[punched card|punch card]] and the pay rate in some other form of memory, perhaps a [[magnetic drum]]. Once the multiplication is complete, the result needs to be placed somewhere. On a "drum machine" this would likely be back to the drum, an operation that takes considerable time. Then the very next operation has to read that value back in, which introduces another considerable delay.

Accumulators dramatically improve performance in systems like these by providing a scratchpad area where the results of one operation can be fed to the next one for little or no performance penalty. In the example above, the basic weekly pay would be calculated and placed in the accumulator, which could then immediately be used by the income tax calculation. This removes one save and one read operation from the sequence, operations that generally took tens to hundreds of times as long as the multiplication itself.

==Accumulator machines==
An '''accumulator machine''', also called a [[Instruction_set_architecture#Number_of_operands|1-operand machine]], or a CPU with ''accumulator-based architecture'', is a kind of CPU where, although it may have several registers, the CPU mostly stores the results of calculations in one special register, typically called "the accumulator". Almost all {{clarify|text=early|reason=To what years does "early" refer|date=July 2021}} computers were accumulator machines with only the high-performance "[[supercomputer]]s" having multiple registers. Then as [[mainframe computer|mainframe]] systems gave way to [[microcomputer]]s, accumulator architectures were again popular with the [[MOS Technology 6502|MOS 6502]] being a notable example. Many [[8-bit computing|8-bit]] [[microcontroller]]s that are still popular {{as of|2014|lc=y}}, such as the [[PIC microcontrollers|PICmicro]] and [[Intel 8051|8051]], are accumulator-based machines.

Modern CPUs are typically 2-operand or 3-operand machines. The additional operands specify which one of many [[general-purpose register]]s (also called "general-purpose accumulators"<ref>{{cite web|url=http://www.freescale.com/webapp/sps/site/overview.jsp?code=DRMCRHC16OV&srch=1 |title=HC16 Overview |publisher=Freescale.com |access-date=2008-09-22 |url-status=dead |archive-url=https://web.archive.org/web/20070928031937/http://www.freescale.com/webapp/sps/site/overview.jsp?code=DRMCRHC16OV&srch=1 |archive-date=28 September 2007 }}</ref>) are used as the source and destination for calculations. These CPUs are not considered "accumulator machines".

The characteristic that distinguishes one register as being the accumulator of a [[computer architecture]] is that the accumulator (if the architecture were to have one) would be used as an ''implicit'' [[operand]] for arithmetic [[instruction (computer science)|instruction]]s. For instance, a CPU might have an instruction like: <code>ADD ''[[memory address|memaddress]]''</code> that adds the value read from memory location ''memaddress'' to the value in the accumulator, placing the result back in the accumulator. The accumulator is not identified in the instruction by a register number; it is [[addressing_mode#Implicit|implicit]] in the instruction and no other register can be specified in the instruction.  Some architectures use a particular register as an accumulator in some instructions, but other instructions use register numbers for explicit operand specification.

== History of the computer accumulator ==
Any system that uses a single "memory" to store the result of multiple operations can be considered an accumulator. [[J. Presper Eckert]] refers to even the earliest [[adding machine]]s of [[Gottfried Leibniz]] and [[Blaise Pascal]] as accumulator-based systems.<ref>J. Presper Eckert, "A Survey of Digital Computer Memory Systems", IEEE Annals of the History of Computing, 1988, pp. 15-28.</ref> [[Percy Ludgate]] was the first to conceive a multiplier-accumulator (MAC) in his Analytical Machine of 1909.<ref>{{cite web |url=http://www.fano.co.uk/ludgate/ |title=The Feasibility of Ludgate's Analytical Machine}}</ref>

Historical convention dedicates a register to "the accumulator", an "arithmetic organ" that literally accumulates its number during a sequence of arithmetic operations:

:"The first part of our arithmetic organ ... should be a parallel storage organ which can receive a number and add it to the one already in it, which is also able to clear its contents and which can store what it contains. We will call such an organ an Accumulator. It is quite conventional in principle in past and present computing machines of the most varied types, e.g. desk multipliers, standard IBM counters, more modern relay machines, the ENIAC" (Goldstine and von Neumann, 1946; p. 98 in Bell and Newell 1971).

Just a few of the instructions are, for example (with some modern interpretation):
* Clear accumulator and add number from memory location X
* Clear accumulator and subtract number from memory location X
* Add number copied from memory location X to the contents of the accumulator
* Subtract number copied from memory location X from the contents of the accumulator
* Clear accumulator and shift contents of register into accumulator

No convention exists regarding the names for operations from registers to accumulator and from accumulator to registers. Tradition (e.g. [[Donald Knuth]]'s (1973) hypothetical [[MIX (abstract machine)|MIX]] computer), for example, uses two instructions called ''load accumulator'' from register/memory (e.g. "LDA r") and ''store accumulator'' to register/memory (e.g. "STA r"). Knuth's model has many other instructions as well.

== Notable accumulator-based computers ==
[[File:IBM 701console.jpg|thumb|Front panel of an [[IBM 701]] computer with lights displaying the accumulator and other registers]]
The 1945 configuration of [[ENIAC]] had 20 accumulators, which could operate in parallel.<ref name="ENIAC">{{cite book |last1=Haigh |first1=Thomas |first2=Mark |last2=Priestley |first3=Crispin |last3=Ropefir  |title=ENIAC in Action: Making and Remaking the Modern Computer |year= 2016 |publisher=MIT Press |isbn=9780262334419}}</ref>{{rp|46}}  Each one could store an eight decimal digit number and add to it (or subtract from it) a number it received.<ref name="ENIAC" />{{rp|33}} Most of IBM's early binary "scientific" computers, beginning with the vacuum tube [[IBM 701]] in 1952, used a single [[36-bit computing|36-bit]] accumulator, along with a separate multiplier/quotient register to handle operations with longer results. The [[IBM 650]], a decimal machine, had one 10 digit distributor and two ten-digit accumulators; the [[IBM 7070]], a later, transistorized decimal machine had three accumulators.  The [[IBM System/360]], and [[Digital Equipment Corporation]]'s [[PDP-6]], had 16 general-purpose registers, although the PDP-6 and its successor, the [[PDP-10]], call them accumulators.

The [[12-bit computing|12-bit]] [[PDP-8]] was one of the first minicomputers to use accumulators, and inspired many later machines.<ref>{{citation |publisher=[[Digital Equipment Corporation]] |location=[[Maynard, Massachusetts]] |date=1961 |url=http://bitsavers.trailing-edge.com/pdf/dec/pdp1/F15B_PDP1_Handbook_1961.pdf |archive-url=https://ghostarchive.org/archive/20221009/http://bitsavers.trailing-edge.com/pdf/dec/pdp1/F15B_PDP1_Handbook_1961.pdf |archive-date=2022-10-09 |url-status=live |title=Programmed Data Processor-1 Manual |page=7: PDP-1 system block diagram |access-date=2014-07-03}}</ref> The PDP-8 had but one accumulator. The [[HP 2100]] and [[Data General Nova]] had 2 and 4 accumulators. The Nova was created when this follow-on to the PDP-8 was rejected in favor of what would become the [[PDP-11]]. The Nova provided four accumulators, AC0-AC3, although AC2 and AC3 could also be used to provide offset addresses, tending towards more generality of usage for the registers. The PDP-11 had 8 general-purpose registers, along the lines of the System/360 and PDP-10; most later CISC and RISC machines provided multiple general-purpose registers.
 
Early [[4-bit computing|4-bit]] and 8-bit microprocessors such as the [[Intel 4004|4004]], [[Intel 8008|8008]] and numerous others, typically had single accumulators. The [[Intel 8051|8051]] microcontroller has two, a primary accumulator and a secondary accumulator, where the second is used by instructions only when multiplying (MUL AB) or dividing (DIV AB); the former splits the [[16-bit computing|16-bit]] result between the two 8-bit accumulators, whereas the latter stores the quotient on the primary accumulator A and the remainder in the secondary accumulator B. As a direct descendant of the 8008, the [[Intel 8080|8080]], and the [[Intel 8086|8086]], the modern ubiquitous [[x86|Intel x86]] processors still uses the primary accumulator EAX and the secondary accumulator EDX for multiplication and division of large numbers. For instance, MUL ECX will multiply the [[32-bit computing|32-bit]] registers ECX and EAX and split the [[64-bit computing|64-bit]] result between EAX and EDX. However, MUL and DIV are special cases; other arithmetic-logical instructions (ADD, SUB, CMP, AND, OR, XOR, TEST) may specify any of the eight registers EAX, ECX, EDX, EBX, ESP, EBP, ESI, EDI as the accumulator (i.e. left operand and destination).  This is also supported for multiply if the upper half of the result is not required.  x86 is thus a fairly general register architecture, despite being based on an accumulator model.<ref>{{cite book |last= Irvine |first= Kip R. |title= Assembly Language for Intel-Based Computers |year= 2007 |edition= 5th  |publisher=Pearson Prentice Hall |isbn=978-0-13-238310-3 |pages=633, 622}}</ref>  The 64-bit extension of x86, [[x86-64]], has been further generalized to 16 instead of 8 general registers.

== References ==
<references />
{{refbegin}}
*Goldstine, Herman H., and von Neumann, John, "Planning and Coding of the Problems for an Electronic Computing Instrument", Rep. 1947, [[Institute for Advanced Study]], Princeton. Reprinted on pp.&nbsp;92–119 in Bell, C. Gordon and Newell, Allen (1971), ''Computer Structures: Readings and Examples'', McGraw-Hill Book Company, New York. {{ISBN|0-07-004357-4}}}. A veritable treasure-trove of detailed descriptions of ancient machines including photos.
{{refend}}

{{Authority control}}
{{DEFAULTSORT:Accumulator (Computing)}}
[[Category:Central processing unit]]
[[Category:Digital registers]]