The control unit decodes each instruction's opcode and generates the control signals that orchestrate data movement through the datapath: register reads/writes, ALU function select, memory enables, and MUX selections. Hardwired control implements the control logic directly as combinational/sequential circuits — fast but inflexible. Microprogrammed control stores microinstructions in a ROM and interprets them — slower but easier to modify. Modern high-performance CPUs use hardwired control, while microprogramming suits complex ISAs or updatable firmware.
Build a truth-table-based control unit for a small ISA of 5–10 instructions. Trace how each opcode produces a unique pattern of control signals. Compare hardwired and microprogrammed implementations by examining the control logic for a multi-cycle processor.
From your understanding of the CPU datapath, you know the hardware components that perform computation: the ALU, register file, memory units, and the multiplexers and buses connecting them. But the datapath by itself is inert — it needs something to tell the ALU which operation to perform, which registers to read, whether to write to memory, and which MUX input to select. The control unit is that something. It takes the opcode from the current instruction and produces the precise pattern of control signals that configure the datapath to execute that instruction correctly.
Think of it like a railroad switching yard. The tracks, junctions, and trains are the datapath. The control unit is the switchboard operator who sets every switch in the right position so the train reaches its destination. For an ADD instruction, the control unit asserts signals that read two source registers, configure the ALU for addition, and write the result back to the destination register — while keeping the memory write-enable deasserted so nothing gets stored to memory. For a LOAD instruction, a completely different pattern of signals activates: one register provides the base address, the ALU adds the offset, the memory read-enable is asserted, and the result MUX selects the memory output instead of the ALU output.
Hardwired control implements this mapping as pure combinational logic (plus a state counter for multi-cycle designs). The opcode bits feed into AND-OR gate networks that directly produce each control signal. From your study of finite state machines and sequential circuits, you can see this as an FSM where each state corresponds to a phase of instruction execution (fetch, decode, execute, memory access, write-back), and the transition logic is built from gates. Hardwired control is fast — signals propagate at gate speed — but inflexible. Adding a new instruction means redesigning the logic, and complex ISAs with hundreds of instruction formats make the combinational logic sprawling and error-prone.
Microprogrammed control takes a fundamentally different approach: it stores the control signal patterns in a small ROM called the control store. Each entry (a microinstruction) encodes one set of control signal values, and a micro-program counter sequences through these entries. Executing a machine instruction means jumping to its micro-routine in the ROM and stepping through the microinstructions. This is slower (ROM lookup + sequencing overhead) but far easier to modify — changing an instruction's behavior means updating ROM contents, not rewiring gates. Intel's x86 processors historically used microcode to implement their complex instruction set, and even modern x86 chips use microcode for complex or rarely-used instructions while hardwiring the common fast paths. Understanding both approaches lets you reason about the tradeoff between execution speed and design flexibility that shapes every processor architecture.