Arithmeticlogical unit
An arithmeticlogic unit ( English arithmetic logic unit , therefore often abbreviated to ALU ) is an electronic arithmetic unit that is used in processors .
Functions
The ALU calculates arithmetic and logical functions . It makes sense to perform at least the following minimal operations:

Arithmetic :
 Addition (ADD)

Logical :
 Negation (NOT)
 Conjunction (AND)
Typically, however, the following operations are also available, which can also be simulated using the upper three at the expense of computing time (in several cycles ):
 Arithmetic:
 Subtraction (SUB)
 Comparison ( compare , CMP)
 Multiplication (MUL) using a multiplier
 division
 Decimal adjust after addition (decimal adjustment after addition)
 Logical:
 Disjunction (OR operation, OR)
 Contravalence (exclusiveor link, XOR, EOR )
 Right and left shift (right, left shift, ASR  arithmetic shift right, ASL  arithmetic shift left, LSR  logical shift to the right, LSL  logical shift to the left)
 Left and right rotation (ROL, ROR)
 Register manipulation and bit changes (set, delete and test bits)
 Sorting bits and bytes, AES commands, CRC commands
All ALUs process fixed point numbers . Floating point instructions are now standard in many current CPUs. Exceptions are smaller microcontrollers that are designed for low power consumption or low manufacturing costs. The trend over the past 15 years has been to convert ALUs to vector processing (as of 2015).
Structure and functionality
An ALU can link two binary values with the same number ( s ) of digits. One speaks of n bit ALUs. Typical values for n are 8, 16, 32 and 64. Historically, the 4bit ALU 74LS181 and the 1bit processor MC14500B from Motorola are also worth mentioning . (However, the corresponding unit is only called LU (Logic Unit)). Terms such as 32bit  or 64bit  CPU come from the width of the working register of the processor architecture. Usually this width also corresponds to that of the ALU; therefore, these terms (32bit or 64bit CPU) indicate that similar ALUs are also used in corresponding processors. The Z80 , for example , which works with a 4bit ALU, is an exception .
F _{3}  F _{2}  F _{1}  F _{0}  R.  

0  0  0  0  0  
0  0  0  1  A.  
1  0  0  1  NOT A  
0  1  0  0  A AND B  
0  1  0  1  A OR B  
0  1  1  0  A XOR B  
0  1  1  1  A + B  
1  1  1  1  B  A 
The n bit ALU is usually composed of individual 1bit ALUs, which each pass on a carry bit to the higherorder ALU , with which a carry is identified at the respective point. (Other methods (e.g. carrylookahead ) are often used to accelerate this ; see also carryripple adder .) To switch the interconnected 1bit ALUs to the required function type, each 1bit ALU has in addition to the inputs for the values to be linked and the carry bit, there is also an input for a control vector (op. code); when used in a processor, these inputs are supplied jointly by the control register (operation register, OR) of the processor.
The status register
In addition to the output vector for the result, the entire n bit ALU also has a condition vector to signal its state. When used in a processor, this condition vector is stored in its status register (also called condition code register ).
This register usually contains four status bits. The individual values of the status register can be queried by machine language commands and thus influence the further course of the program (e.g. conditional jumps):
 Carry bit (C for engl. Carry bit ): indicates the carry of the addition at the n arises th bit (the highest point) of the operands. It is used as an indicator of overrange when viewing the result as an unsigned number (positive results only). If calculations are made using the 2's complement representation (negative numbers are also possible), the carry bit does not play a direct role for the range being exceeded.
 Overflow bit (V for overflow bit ): Indicates that the number range is exceeded in the case of 2's complement calculation (carry over of the second highest digit of the operands). Other possible designations besides V are OF or O.
 Zero bit (Z engl. Zero bit ): indicates whether the result of the previous arithmetic operation is zero (becomes 1 when contents of the accumulator register is 0).
 Negative bit (N): Is set if the result of the operation can be interpreted as a negative number ( top bit of the accumulator register = 1).
There are other flags depending on the ALU type , for example:
 Half carry bit (H): Indicates a carry between the loworder and highorder nibble. Interesting for the decimal correction when converting binary representation to BCD representation.
 Parity bit (P): Depending on the processor, indicates even or odd parity of the accumulator register (number of bits with the value 1 is even or odd).
Related systems
Parallel Logic Units (PLUs) are ALUs specially tailored for bit manipulation. You can access the data in parallel, i.e. at the same time as other arithmetic units, and are therefore connected to the main memory via a separate data path. PLUs are part of some types of signal processors that are used as highspeed controllers .
Individual evidence
 ↑ Data sheet from 74LS181 (Fairchild) ( Memento from January 31, 2012 in the Internet Archive ) (PDF; 77 kB), ALU from the 74xx logic family
 ↑ Motorola MC14500B Industrial Control Unit Handbook , on Wikichip.org
 ↑ Michael Slater, Federico Faggin , Masatoshi Shima , Ralph Ungermann: Zilog Oral History Panel on the Founding of the Company and the Development of the Z80 Microprocessor , page 11, Ed .: Computer History Museum