Accumulator

5 Key excerpts on "Accumulator"

• 

  eBook - PDF

  Industrial Process Control Systems, Second Edition

  • Dale R. Patrick, Stephen W. Fardo(Authors)
  • 2021(Publication Date)
  • River Publishers

    (Publisher)

  This value is then stored in the Accumulator, where it replaces the operand that appeared there originally. It is important to note that the ALU only responds to binary numbers. Accumulators The Accumulators of a microprocessor are temporary registers which are designed to store operands that are to be processed by the ALU. Before the ALU can perform, it must first receive data from an Accumulator. After the data register input and Accumulator input are combined, the logical answer or output of the ALU appears in the Accumulator. This function is basically the same for all microprocessors. In microprocessor operation, a typical instruction would be to “load the Accumulator.” This instruction enables the contents of a particular memory location to be placed into the Accumulator. A similar instruction might be “store Accumulator.” In this operation, the instruction causes the contents of the Accumulator to be placed in a selected memory location. Essentially, the Accumulator serves as both an input source for the ALU and a destination area for its output. Data Register The data register of a microprocessor serves as a temporary storage location for information applied to the data bus. Typically, this register 348 Industrial Process Control Systems will accommodate an 8-bit data word. An example of a function of this register is operand storage for the ALU input. 10 addition, it may be called on to hold an instruction while the instruction is being decoded. It may also temporarily hold data prior to the data being placed in memory. Address Registers Address registers are used in microprocessors to temporarily store the address of a memory location that is to be accessed for data. In some units, this register may be programmable. This means that it permits instructions to alter its contents. The program can also be used to build an address in the register prior to executing a memory reference instruction.

  Sign up to read

  Learn more about book
• 

  eBook - PDF

  Computer Systems Architecture

  • Aharon Yadin(Author)
  • 2016(Publication Date)
  • Chapman and Hall/CRC

    (Publisher)

  The solution was the implementation of a data register called the Accumulator . As the Accumulator was part of the processor, the access time was significantly shorter. All arithmetic operations in Accumulator-based architecture were performed using the Accumulator and the result was entered into the Accumulator as well. The reason was that this way, the result could be ready as input for the next instruction. Contrary to the arithmetic instructions in the stack-based architecture that do not have any operands, in the Accumulator architecture these instructions have one operand. The second operand is assumed to be in the Accumulator. This implies that prior to executing an arithmetic instruction, one operand has to be in the Accumulator. When writing assembly programs, it is the developer’s responsibility to load the register with the operand. For higher-level programming languages, it is performed by the compiler. Since the result is stored in the Accumulator, the previous content (one of 104 ◾ Computer Systems Architecture the operands) is destroyed. Furthermore, the instruction’s result has to be copied from the Accumulator or it may be overwritten by the next instruction’s operand or result. This is similar to the short-term memory behavior. The data stored in the short-term memory has to be transferred to the long-term memory (if it is important) otherwise it will be forgotten and overwritten by new data Using the previous example (C = A + B) in an Accumulator-based architecture requires a set of three instructions: Load A # Load variable A into the Accumulator Add B # Add A + B; store result in the Accumulator Store C # Copy Accumulator content to variable C • The first instruction loads the Accumulator. The content of the variable (A) is copied into the Accumulator, overriding its previous content. • The second instruction performs the add operation.

  Sign up to read

  Learn more about book
• 

  eBook - PDF

  Computer Programming

  A Mixed Language Approach

  • Marvin L. Stein, William D. Munro(Authors)
  • 2014(Publication Date)
  • Academic Press

    (Publisher)

  To augment the Accumulator and permit it to perform compound addi-tions and subtractions such as are required for multiplication and division, there will usually be some auxiliary arithmetic registers. These will usually be multipurpose registers, even though they are assigned names which are associated with one particular function, such as quotient register. Since we wish to retain the freedom of choosing operands from, and preserving results in, arbitrary storage registers, we must provide for the transfer of data from any storage register into the arithmetic registers and for the reverse transfer from arithmetic registers to any storage register. Thus, the digits manipulated within and between arithmetic registers in order to create results, will either have been copied into these registers from addressed storage registers or will have been left there from the pre-vious operation. Usually this transmission of information between arith-metic registers and storage registers will be handled by the same exchange register used for the storage to storage transmission. The exchange register may also function as an auxiliary arithmetic register. The actual switching networks which permit the Accumulator to carry out its specific functions are a proper topic for a book on computer design. However, it is important to a programmer that he be familiar with the way in which each operation is carried out, and, in particular, with the sequencing. We illustrate this point by an example. Example 2-0. In the UNIVAC 1103 an appropriate instruction will cause the computer to form the sum of two numbers obtained from storage. Since the Accumulator is addressable in this machine, one of the two num-bers may be the one currently stored in the Accumulator. The steps are: (1) The first number goes to the exchange register. (2) The Accumulator is cleared. (3) The content of the exchange register (first number) is added to the cleared Accumulator.

  Sign up to read

  Learn more about book
• 

  eBook - PDF

  Electrical Engineer's Reference Book

  • G R Jones(Author)
  • 2013(Publication Date)
  • Newnes

    (Publisher)

  Depending on the architecture of the processor, the operand data inputs may be from either immediate-access memory registers or CPU data registers. The resultand is usually output to a special register, known as the Accumulator, which is normally a multifunction register which can participate fully in the processing opera-tions. In some systems the Accumulator is used to store one of the operands before a processing operand and is subsequently used to store the resultand. This technique removes the need to have two operand registers and may increase the opera-tional speed of the processor. However, the need to minimise the number of CPU registers is no longer a major design objective and many modern microprocessors have a number of CPU registers of advanced design which can act as operand registers or Accumulators. The ALU also contains the status register which is also known as a flag register or condition code register. This register consists of a number of flip-flops (flags) whose state reflects the result or state of the processing element at the end of the previous processing operation. This is illustrated in Figure 6.33 which shows in schematic form the structure of a typical ALU and the other logical systems associated with the execution part of the instruction cycle. 6.6.6 Memory unit The memory unit provides storage for program code and data. Computers commonly use two types of memory, fast immediate-access memory and backing store memory, which have different roles and functions. The immediate-access memory is considered to be the primary memory unit of a computer, it is used to store program code and the data associated with the program so that it may be readily accessed during the execution of the pro-gram. Read-only memory devices may be used to store information which does not alter, such as program code or constant data, and random-access read-write memory (RAM) devices are used to store data which may be altered, such as the value of variables.

  Sign up to read

  Learn more about book
• 

  eBook - PDF

  Digital Computer Structure and Design

  • R. Townsend(Author)
  • 2014(Publication Date)
  • Butterworth-Heinemann

    (Publisher)

  The diagram of the program counter is shown in Figure 9.5, and an individual cell is shown in Figure 9.6. The Operation Register As described in Chapter 8, the operation which the processor is to perform during each instruction is defined by bits in the instruction code whose meaning is designated by the functional specification. The instruction is stored in the operation register where it is decoded to control the sequence of small operations within the processor and the selection of appropriate registers. The operation register contains the instruction during the whole operation until it receives the next instruction word. It is at this point that the data flow system impinges on the control system of the processor. The operation register is a straightforward parallel register of 16 bits as for the address register The Data Flow System of the Processor 199 and the block diagram is similar to that in Figure 9.4. The output from the register is taken to the operation decoding logic and also to the device address lines for the input-output system. The Accumulator Registers These registers are all similar to each other and consists merely of temporary storage for numbers or other words upon which arith-metic or logical operations are to be performed. No special functions are incorporated, and although certain Accumulators may be involved in special operations such as indexing for base addressing in memory reference operations, or as temporary storage for the next instruction in the main program during a 'jump to subroutine' instruction, these functions are determined by the operation code and control system. The programmer must of course remember what is stored in each Accumulator or that its contents may be destroyed in the 'jump to subroutine' instruction. In some ways these registers may be looked on as a high speed extension of the memory. They are all simple parallel registers similar to the A register shown in Figure 9.4.

  Sign up to read

  Learn more about book