The ALU

Introduction

Every mathematical calculation, every logical comparison, every decision your computer makes ultimately comes down to one component: the Arithmetic Logic Unit, or ALU. The ALU is the part of the CPU that actually performs the work of addition, subtraction, multiplication, division, and logical operations like AND, OR, NOT, and comparison.

Without the ALU, a computer would be little more than a fancy data-moving machine. Every time you add numbers in a spreadsheet, determine if a game character has collided with a wall, or encrypt a password, the ALU is hard at work. Understanding how the ALU works is key to understanding how computers process information at the most fundamental level.

How It Works

The ALU is a digital circuit built from logic gates that takes two input values (operands) and produces one output result based on a control signal that selects the operation. The ALU's control lines come from the Control Unit, which tells the ALU whether to add, subtract, compare, or perform a bitwise operation on the inputs.

Inside the ALU, different functional units handle different operations. An adder circuit performs addition using a cascade of full adders. A multiplier uses a combination of shifts and additions to compute products. The logic unit handles bitwise AND, OR, XOR, and NOT operations using simple gate arrays. A comparator determines whether one value is greater than, less than, or equal to another.

The ALU also produces flags — status signals that provide information about the result. For example, a zero flag is set when the result is zero, a carry flag is set when an addition produces a carry out of the most significant bit, and an overflow flag indicates when the result exceeds the representable range. These flags are stored in a special flags register and can be tested by conditional branch instructions.

Deeper Dive

The simplest ALU operation is addition, implemented with a ripple-carry adder. A 1-bit full adder takes three inputs (A, B, and carry-in) and produces two outputs (sum and carry-out). To add two N-bit numbers, N full adders are chained together, with each carry-out feeding the next carry-in. While simple, ripple-carry adders become slower as the bit width increases because the carry must propagate through all stages. Modern CPUs use carry-lookahead adders (CLA) that compute all carries in parallel, dramatically reducing addition time.

Subtraction is performed by taking the two's complement of the subtrahend and then adding it to the minuend. The two's complement is computed by inverting all bits and adding 1. This means the CPU can reuse the same adder circuit for both addition and subtraction, with a simple control signal to select the operation.

The flags register (also called the status register) typically includes: Carry (C), Overflow (O/V), Zero (Z), Sign/Negative (S/N), and sometimes Parity (P) and Auxiliary Carry (AC). These flags are critical for implementing conditionals like "if (x > y)" in high-level languages — the compiler generates a comparison instruction (which sets flags), followed by a conditional branch instruction that tests those flags.

Advanced

Modern high-performance CPUs include multiple ALUs operating in parallel. A typical superscalar core might have four or more integer ALUs, two or three floating-point units (FPUs), and dedicated load/store units. The CPU's scheduler dispatches instructions to available ALUs based on data dependencies and resource availability.

Floating-point arithmetic is handled by a specialized unit called the FPU (Floating-Point Unit). Floating-point numbers are represented using the IEEE 754 standard, which stores values in scientific notation with a sign bit, exponent, and mantissa. FPU operations like addition and multiplication require more complex circuitry and typically take several clock cycles. Some CPUs (especially in embedded systems) implement floating-point in software rather than hardware to save silicon area.

The performance of the ALU directly limits the CPU's overall throughput. Bit width matters: a 64-bit ALU can process 64-bit integers in one operation, whereas a 32-bit ALU would need multiple operations for the same task. This is why the transition from 32-bit to 64-bit processors was such a major milestone — it doubled the amount of data the ALU could process per cycle for many operations.

Vocabulary Table

Fun Facts

Interactive Diagram

Watch the ALU in action as it adds, subtracts, and compares values while updating the CPU's status flags.

Open Interactive Diagram

---

The interactive diagram for this chapter demonstrates The Arithmetic Logic Unit. It shows the ALU performing arithmetic (add, subtract) and logical (AND, OR, compare) operations.

Knowledge Check

Chapter Navigation