In digital electronics, an arithmetic logic unit is a digital circuit that performs integer
arithmetic and logical operations. The ALU is a fundamental building block of the central
processing unit of a computer, and even the simplest microprocessors contain one for purposes
such as maintaining timers. The processors found inside modern CPUs and graphics processing
units accommodate very powerful and very complex ALUs; a single component may contain a number
of ALUs. Mathematician John von Neumann proposed the
ALU concept in 1945, when he wrote a report on the foundations for a new computer called
the EDVAC.
Numerical systems
An ALU must process numbers using the same formats as the rest of the digital circuit.
The format of modern processors is almost always the two's complement binary number
representation. Early computers used a wide variety of number systems, including ones'
complement, two's complement, sign-magnitude format, and even true decimal systems, with
various representation of the digits. The ones' complement and two's complement
number systems allow for subtraction to be accomplished by adding the negative of a number
in a very simple way which negates the need for specialized circuits to do subtraction;
however, calculating the negative in two's complement requires adding a one to the low
order bit and propagating the carry. An alternative way to do two's complement subtraction of
A−B is to present a one to the carry input of the adder and use ¬B rather than B as
the second input. The arithmetic, logic and shift circuits introduced in previous sections
can be combined into one ALU with common selection. Practical overview
Most of a processor's operations are performed by one or more ALUs. An ALU loads data from
input registers. Then an external control unit tells the ALU what operation to perform
on that data, and then the ALU stores its result into an output register. The control
unit is responsible for moving the processed data between these registers, ALU and memory.
Complex operations Engineers can design an arithmetic logic unit
to calculate most operations. The more complex the operation, the more expensive the ALU
is, the more space it uses in the processor, and the more power it dissipates. Therefore,
engineers compromise. They make the ALU powerful enough to make the processor fast, yet not
so complex as to become prohibitive. For example, computing the square root of a number might
use: Calculation in a single clock Design an extraordinarily
complex ALU that calculates the square root of any number in a single step.
Calculation pipeline Design a very complex ALU that calculates the square root of any
number in several steps. The intermediate results go through a series of circuits arranged
like a factory production line. The ALU can accept new numbers to calculate even before
having finished the previous ones. The ALU can now produce numbers as fast as a single-clock
ALU, although the results start to flow out of the ALU only after an initial delay.
Iterative calculation Design a complex ALU that calculates the square root through several
steps. This usually relies on control from a complex control unit with built-in microcode.
Co-processor Design a simple ALU in the processor, and sell a separate specialized and costly
processor that the customer can install just beside this one, and implements one of the
options above. Software libraries Tell the programmers that
there is no co-processor and there is no emulation, so they will have to write their own algorithms
to calculate square roots by software. Software emulation Emulate the existence of
the co-processor. Whenever a program attempts to perform the square root calculation, make
the processor check if there is a co-processor present and use it if there is one; if there
is not one, interrupt the processing of the program and invoke the operating system to
perform the square root calculation through some software algorithm.
The options above go from the fastest and most expensive one to the slowest and least
expensive one. Therefore, while even the simplest computer can calculate the most complicated
formula, the simplest computers will usually take a long time doing that because of the
several steps for calculating the formula. Powerful processors like the Intel Core and
AMD64 implement option #1 for several simple operations, #2 for the most common complex
operations and #3 for the extremely complex operations.
Inputs and outputs The inputs to the ALU are the data to be operated
on and a code from the control unit indicating which operation to perform. Its output is
the result of the computation. One thing designers must keep in mind is whether the ALU will
operate on big-endian or little-endian numbers. In many designs, the ALU also takes or generates
inputs or outputs a set of condition codes from or to a status register. These codes
are used to indicate cases such as carry-in or carry-out, overflow, divide-by-zero, etc.
A floating-point unit also performs arithmetic operations between two values, but they do
so for numbers in floating-point representation, which is much more complicated than the two's
complement representation used in a typical ALU. In order to do these calculations, a
FPU has several complex circuits built-in, including some internal ALUs.
In modern practice, engineers typically refer to the ALU as the circuit that performs integer
arithmetic operations. Circuits that calculate more complex formats like floating point,
complex numbers, etc. usually receive a more specific name such as floating-point unit.
See also 7400 series
74181 Adder
Multiplication ALU Digital circuit
Division algorithm Control unit
Central Processing Unit Bus
Notes
References
Hwang, Enoch. Digital Logic and Microprocessor Design with VHDL. Thomson. ISBN 0-534-46593-5.
Stallings, William. Computer Organization & Architecture: Designing for Performance.
Pearson Prentice Hall. ISBN 0-13-185644-8. External links
ALU and its Micro-operations: Bitwise, Arithmetic and Shift
A Simulator of Complex ALU in MATLAB