Control Unit: Hardwired vs. Microprogrammed Design

TAKEAWAYS

• The control unit (CU) decodes instructions and generates timing/control signals for CPU operations using either hardwired logic (fast, rigid) or microprogrammed logic (flexible, slower).
• Hardwired CU uses combinational logic gates for each instruction, offering high speed but low flexibility (changes require hardware redesign).
• Microprogrammed CU stores control sequences in control memory (microprogram ROM), enabling easy modifications (e.g., adding new instructions) but adding overhead (extra fetch/decode cycles).
• Control words are bit-patterns that activate signals (e.g., "load ALU input from register A")—each instruction maps to a sequence of these words.
• Microprogram sequencers (sequential or parallel) determine the next microinstruction address via next-address field or sequencer logic.
• Real-world tie: Ncell’s billing servers use microprogrammed CUs for dynamic tariff updates, while eSewa’s payment processors rely on hardwired CUs for ultra-low-latency transactions.

---

1. The Role of the Control Unit (CU)

The control unit is the decision-making and timing coordinator of the CPU. Its primary functions are:

1. Fetch: Retrieve instructions from memory via the program counter (PC).
2. Decode: Interpret the instruction’s opcode to determine the operation (e.g., ADD, JMP).
3. Execute: Generate control signals (e.g., "load data bus," "clock ALU") to coordinate CPU components (ALU, registers, memory).
4. Synchronize: Manage timing via clock cycles and machine cycles (e.g., M1: fetch, M2: execute).

A labelled diagram showing the CU’s connection to the ALU, registers, memory, and buses.

---

2. Hardwired Control Unit: Direct Logic Gates

How It Works

• Uses combinational logic circuits (AND/OR/NOT gates) hardcoded for each instruction.
• For example, the ADD instruction might trigger:
  • Load A → ALU input 1
  • Load B → ALU input 2
  • Set ALU op-code to ADD
  • Write result to ACC
• No memory lookup: Control signals are generated directly from the instruction bits.

Worked Example: Hardwired MOV A,B in 8085

Assume the 8085’s CU has logic for MOV A,B (move data from register B to accumulator A):

1. Instruction: 10000010 (binary opcode for MOV A,B).
2. CU logic:
   • Decodes 10000010 → activates signals:
     • REG_SEL = 11 (select register B)
     • MEM_READ = 0 (data from register, not memory)
     • ALU_SRC = REG_OUT (source is register output)
     • ACC_WRITE = 1 (write to accumulator)
3. Result: Data from B is copied to A in 1 machine cycle.

Advantages

Disadvantages

A diagram showing how the 8085’s ADD instruction might be implemented with gates for ALU control signals.

---

3. Microprogrammed Control Unit: Control Memory

How It Works

• Instead of hardwired logic, the CU uses a microprogram—a sequence of microinstructions stored in control memory (ROM).
• Each microinstruction is a control word that specifies:
  • Control signals (e.g., "load ALU input from register X").
  • Next microinstruction address (sequential or conditional).
• Example: The ADD instruction might require 5 microinstructions:
  1. Load operand 1 to ALU.
  2. Load operand 2 to ALU.
  3. Set ALU to ADD mode.
  4. Write result to accumulator.
  5. Increment PC.

Key Components

Control Word Structure

A typical control word has:

A labelled diagram of a 16-bit control word for the 8085, showing fields for next address and control signals.

---

4. Microprogram Sequencing

The microprogram sequencer determines the next microinstruction address. Two types:

A. Sequential (Straightforward) Sequencing

• Next address = current address + 1 (like a program counter).
• Pros: Simple, fast for linear sequences.
• Cons: Cannot handle branches or loops easily.

B. Conditional Sequencing

• Uses flags (e.g., zero flag ZF, carry flag CF) to decide the next address.
• Example: After an ADD, check CF to branch to overflow handling.
• Implemented via:
  • Next-address field: Hardcoded in the control word.
  • Sequencer logic: Uses flags to compute the next address.

A diagram showing how the 8085’s sequencer uses the ZF flag to branch to a microinstruction for JZ (jump if zero).

---

5. Hardwired vs. Microprogrammed: Comparison

---

6. Real-World Applications

A. eSewa: Hardwired CU for Low-Latency Transactions

• Why? eSewa’s servers process thousands of transactions/sec (e.g., mobile top-ups, bill payments).
• How? Uses hardwired CUs in custom ASICs (Application-Specific Integrated Circuits) for:
  • Instant validation of payment requests.
  • Direct routing of funds without microprogram overhead.
• Result: Transactions complete in <50ms, critical for user experience.

B. Ncell: Microprogrammed CU for Dynamic Tariff Updates

• Why? Ncell’s billing system must handle changing tariffs (e.g., night-time discounts, bundle offers).
• How? Uses microprogrammed CUs to:
  • Reconfigure pricing logic via software updates (no hardware changes).
  • Add new tariff rules without halting services.
• Example: When a new "Happy Hours" tariff is launched, the microprogram is updated to apply discounts during 2–5 AM.

C. Google’s TPUs: Hybrid Approach

• Tensor Processing Units (TPUs) used in Google’s data centers combine:
  • Hardwired logic for matrix operations (fast matrix multiplication).
  • Microprogrammed control for dynamic workload scheduling.
• Result: 90% faster than CPUs for AI training while allowing flexibility.

---

7. Worked Example: Microprogram for 8085 FETCH Cycle

Instruction: LDA 2100H (Load A from memory address 2100H). Microprogram Steps (simplified):

Mermaid Diagram:

---

8. Designing a Microprogrammed CU: Step-by-Step

1. List all instructions (e.g., ADD, SUB, JMP).
2. Break each into microoperations (e.g., ADD → load A, load B, ALU ADD, write result).
3. Assign control signals to each microoperation (e.g., REG_A→ALU=1).
4. Design the control word format (e.g., 16 bits: 8 for next address, 8 for signals).
5. Write the microprogram (sequence of control words).
6. Implement the sequencer (sequential or conditional).
7. Test with sample instructions (e.g., trace MOV A,B).

A diagram of a 256-word × 16-bit control memory storing microinstructions for the 8085.

---

Exam Tip

1. Compare hardwired vs. microprogrammed:

   • Exam loves this table—memorize pros/cons for speed, flexibility, and cost.
   • Example answer: "Hardwired CUs are used in high-speed applications like eSewa’s payment gateways due to their low latency, while microprogrammed CUs in Ncell’s billing systems allow dynamic tariff updates without hardware changes."

2. Control word structure:

   • Draw it in exams. Label fields like next μAR and control signals.
   • Example: For a 16-bit control word, show 8 bits for address and 8 for signals.

3. Microprogram sequencing:

   • Explain both types (sequential vs. conditional) with a small example (e.g., branching on ZF=1).
   • Diagram tip: Use a state diagram to show how the sequencer moves between microinstructions.

4. Real-world tie-ins:

   • Always link to Nepalese examples (e.g., "Like how Ncell updates tariffs via microprograms, TU’s student database might use hardwired CUs for fast grade processing").
   • Avoid vague answers: Specify which part of the system uses which CU (e.g., "The payment validation ASIC in eSewa uses hardwired control").

5. Common pitfalls:

   • Don’t confuse microinstructions with machine instructions.
     • ❌ "The 8085’s ADD instruction is a microinstruction." (Wrong!)
     • ✅ "The 8085’s ADD instruction is implemented via 5 microinstructions in its microprogrammed CU."
   • Don’t forget the sequencer: Exams often ask how the next microinstruction is selected—always mention the sequencer logic.

---

Practice Questions (Exam-Style)

1. Short Answer:

   • "Why would a microprogrammed CU be preferred over a hardwired one for a system that frequently updates its instruction set?"
   • Answer: "Microprogrammed CUs allow software-based modifications to the instruction set (via microcode updates), while hardwired CUs require expensive hardware redesigns. This makes them ideal for dynamic systems like Ncell’s billing servers where tariff rules change often."

2. Diagram-Based:

   • "Draw the control word format for a microprogrammed CU that supports 256 microinstructions and 32 control signals. Label all fields."
   • Answer:

     +---------------------+
     | Next μAR (8 bits)    |  (256 possible addresses)
     +---------------------+
     | Control Signals (8)  |  (e.g., MEM_RD, ACC_WR)
     |     ...             |
     | Control Signals (8)  |
     +---------------------+
     

3. Comparison:

   • "Compare the speed and flexibility of hardwired and microprogrammed CUs. Provide one Nepalese and one global example for each."
   • Answer:

     Aspect	Hardwired CU	Microprogrammed CU
     Speed	Faster (eSewa’s ASICs)	Slower (Ncell’s billing servers)
     Flexibility	Rigid (Google TPUs)	Flexible (Intel’s x86 microcode)