You are here: Home » Content » Control Unit Operation
Content Actions

Control Unit Operation

Module by: Nguyen Thi Hoang Lan

Summary: Purpose: This module is to study the Control Unit Operation, the micro-operations are controlled by the control unit operation. Objective: Understanding the organization and operation of the CU of processor.

Micro-operations

We have seen that the operation of a computer, in executing a program, consists of a sequence of instruction cycles, with one machine instruction per cycle. Of course, we must remember that this sequence of instruction cycles is not necessarily the same as the written sequence of instructions that make up the program, because of the existence of branching instructions. What we are referring to here is the execution time sequence of instructions.
We have further seen that each instruction cycle is made up if a number of smaller units. One subdivision that we found convenient is fetch, indirect, execute and interrupt, with only fetch and execute cycles always occurring.
To design a control unit, however, we need to break down the description further. In fact, we will see that each of the smaller cycles involves a series of steps, each of which involves the processor registers. We will refer to these steps as micro-operations. The prefix micro refers to the fact that each step is very simple and accomplishes very little. To summarize, the execution of a program consists of the sequential execution of instructions. Each instruction is executed during an instruction cycle made up of shorter sub-cycles (e.g., fetch, indirect, execute, interrupt). The performance of each sub-cycle involves one or more shorter operations, that is, micro-operations.
Micro-operations are the functional, or atomic, operations of a processor. In this section, we will examine micro-operations to gain an understanding of how the events of any instruction cycle can be described as a sequence of such micro-operations. A simple example will be used. We then show how the concept of micro-operations serves as a guide to the design of the control unit.

The Fetch Cycle

We begin by looking at the fetch cycle, which occurs at the beginning of each instruction cycle and causes an instruction to be fetched from memory. Four reg­isters are involved:
  • Memory address register (MAR): Is connected to the address lines of the sys­tem bus. It specifies the address in memory for a read or write operation.
  • Memory buffer register (MBR): Is connected to the data lines of the system bus. It contains the value to be stored in memory or the last value read from memory.
  • Program counter (PC): Holds the address of the next instruction to be fetched.
  • Instruction register (IR): Holds the last instruction fetched.
Let us look at the sequence of events for the fetch cycle from the point of view of its effect on the processor registers. An example appears in Figure 1. At the beginning of the fetch cycle, the address of the next instruction to be executed is in the program counter (PC); in this case, the address is 1100100. The first step is to move that address to the memory address register (MAR) because this is the only register connected lo the address lines of the system bus. The second step is to bring in the instruction. The desired address (in the MAR) is placed on the address bus, the control unit issues a READ command on the control bus, and the result appears on the data bus and is copied into the memory buffer register (MBR). We also need to increment the PC by 1 to get ready for the next instruction. Because these two actions (read word from memory, add 1 to PC) do not interfere with each other, we can do them simultaneously to save time. The third step is to move the contents of the MBR to the instruction register (IR). This frees up the MBR for use during a possible indirect cycle.
Thus, the simple fetch cycle actually consists of three steps and four micro-operations. Each micro-operation involves the movement of data into or out of a register. So long as these movements do not interfere with one another, several of them can lake place during one step, saving lime. Symbolically, we can write this sequence of events as follows:
t1: MAR <= (PC)
t2: MBR <= Memory
PC <= (PC) + l
t3: IR <= (MBR)
Figure 1: Sequence of Events, Fetch Cycle
where l is the instruction length. We need to make several comments about this sequence. We assume that a clock is available for timing purposes and that it emits regularly spaced clock pulses. Each clock pulse defines a time unit. Thus, all time units are of equal duration. Each micro-operation can be performed within the time of a single time unit. The notation (t1, t2, t3) represents successive lime units. In words, we have
  • First time unit: Move contents of PC to MAR.
  • Second time unit: Move contents of memory location specified by MAR to MBR. Increment by l the contents of the PC.
  • Third time unit: Move contents of MBR to IR.
Note that the second and third micro-operations both take place during the second time unit. The third micro-operation could have been grouped with the fourth with­out affecting the letch operation:
t1: MAR <= (PC)
t2: MBR <= Memory
t3: PC <= (PC) + I
  IR <= (mbr)
The groupings of micro-operations must follow two simple rules:
  • The proper sequence of events must be followed. Thus (MAR <= (PC)) must precede (MBR <= Memory) because the memory read operation makes use of the address in the MAR.
  • 2. Conflicts must be avoided. One should not attempt to read to and write from the same register in one time unit, because the results would be unpredictable. For example, the micro-operations (MBR <= Memory) and (IR <= MBR) should not occur during the same time unit.
A final point worth noting is that one of the micro-operations involves an addi­tion. To avoid duplication of circuitry, this addition could be performed by the ALU. The use of the ALU may involve additional micro-operations, depending on the functionality of the ALU and the organization of the processor.

The Indirect Cycle

Once an instruction is fetched, the next step is to fetch source operands. Continuing our simple example, let us assume a one-address instruction format, with direct and indirect addressing allowed. If the instruction specifies an indirect address, then an indirect cycle must precede the execute cycle. The data flow differs somewhat front that indicated in Figure 12.7 and includes the following micro-operations:
t1: MAR <= (IR (Address))
t2: MBR <= Memory
t3: IR(Address) <= (MBR(Address) )
The address field of the instruction is transferred to the MAR. This is then used to fetch the address of the operand. Finally, the address field of the IR is updated from the MBR, so that it now contains a direct rather than an indirect address.
The IR is now in the same state as if indirect addressing had not been used, and it is ready for the execute cycle. We skip that cycle for a moment, lo consider the interrupt cycle.

The Interrupt Cycle

At the completion of the execute cycle, a test is made to determine whether any enabled interrupts have occurred. If so, the interrupt cycle occurs. The nature of this cycle varies greatly from one machine to another. We present a very simple sequence of events, as illustrated in Figure 12.8. We have
t1 : MBR <= (PC)
t2 : MAR <= Save_Address
PC <= Routine_Address
t3: Memory <= (MBR)
In the first step, the contents of the PC are transferred to the MBR, so that they can be saved for return from the interrupt. Then the MAR is loaded with the address at which the contents of the PC are to be saved, and the PC is loaded with the address of the start of the interrupt-processing routine. These two actions may each be a single micro-operation. However, because most processors provide multiple types and/or levels of interrupts, it may lake one or more additional micro-operations to obtain the save_address and the routine_address before they can be transferred to the MAR and PC, respectively. In any case, once this is done, the final step is to store the MBR, which contains the old value of the PC, into memory. The processor is now ready to begin the next instruction cycle.

The Execute Cycle

The fetch, indirect, and interrupt cycles are simple and predictable. Each involves a small, fixed sequence of micro-operations and, in each ease, the same micro-opera­tions are repealed each time around.
This is not true of the execute cycle. For a machine with N different opcodes, there are N different sequences of micro-operations that can occur. Let us consider several hypothetical examples.
First, consider an add instruction:
ADD R1, X
which adds the contents of the location X to register Rl. The following sequence of micro-operations might occur:
t1: MAR <= (IR(address))
t2: MBR <= Memory
t3: Rl <= (Rl) + (MBR)
We begin with the IR containing the ADD instruction. In the first step, the address portion of the IR is loaded into the MAR. Then the referenced memory location is read. Finally, the contents of R1 and MBR are added by the ALU. Again, this is a simplified example. Additional micro-operations may be required to extract the register reference from the IR and perhaps to stage the ALU inputs or outputs in some intermediate registers.
Let us look at two more complex examples. A common instruction is increment and skip if zero:
ISZ X
The content of location X is incremented by 1. If the result is 0, the next instruction is skipped. A possible sequence of micro-operations is
t1: MAR <= (CR(address) )
t2: MBR <= Memory
t3: MBR <= (MBR) - 1
t4: Memory <= (MBR)
If ((MBR) = 0) then (PC <= (PC) + I)
The new feature introduced here is the conditional action. The PC is incremented if (MBR) = 0; this test and action can be implemented as one micro-operation. Note also that this micro-operation can be performed during the same time unit during which the updated value in MBR is stored back to memory.
Finally, consider a subroutine call instruction. As an example, consider a branch-and-save-address instruction:
BSA X
The address of the instruction that follows the BSA instruction is saved in location X, and execution continues al location X - l. The saved address will later be used for return. This is a straightforward technique for providing subroutine calls. the following micro-operations suffice:
t1 : MAR <= (IR(address))
MBR <= (PC)
t2: PC <= (IR(address)) Memory <= (MBR)
t3: PC <= (PC) + I
The address in the PC at the start of the instruction is the address of the next instruction in sequence. This is saved at the address designated in Ihe IK. The latter address is also incremented to provide the address of the instruction for the next instruction cycle.

The Instruction Cycle

We have seen that each phase of the instruction cycle can be decomposed into a sequence of elementary micro-operations. In our example, there is one sequence each for the fetch, indirect, and interrupt cycles, and, for the execute cycle, there is one sequence of micro-operations for each opcode.
To complete the picture, we need to tie sequences of micro-operations together, and this is done in Figure 2. We assume a new 2-bit register called the instruction cycle code (ICC). The ICC designates the state of the processor in terms of which portion of the cycle it is in:
00: Fetch
01: Indirect
10: Execute
11: Interrupt
At the end of each of the four cycles, the ICC is set appropriately. The indirect cycle is always followed by the execute cycle. The interrupt cycle is always followed by the fetch cycle (sec Figure 12.4). For both the execute and fetch cycles, the next cycle depends on the state of the system.
Thus, the flowchart of Figure 2 defines the complete sequence of micro-operations, depending only on the instruction sequence and the interrupt pattern. Of course, this is a simplified example. The flowchart for an actual processor would be more complex. In any case, we have reached the point in our discussion in which the operation of the processor is defined as the performance of a sequence of micro-operations. We can now consider how the control unit causes this sequence to occur.
Figure 2: Flowchart for Instruction Cycle

Control of the processor

Functional Requirements

As a result of our analysis in the preceding section, we have decomposed the behavior or functioning of the processor into elementary operations, called micro-operations. By reducing the operation of the processor to its most fundamental level, we are able to define exactly what it is that Ihe control unit must cause to happen. Thus, we can define the functional requirements for the control unit those functions that the control unit must perform. A definition of these functional requirements is the basis for the design and implementation of the control unit.
With the information at hand, the following three-step process leads lo a characterization of the control unit:
  1. Define the basic elements of the processor.
  2. Describe the micro-operations that the processor performs.
  3. Determine the functions that the control unit must perform lo cause the micro-operations to be performed.
We have already performed steps 1 and 2. Let us summarize the results. First, the basic functional elements of the processor are the following:
  • ALU
  • Registers
  • Internal data paths
  • External data paths
  • Control unit
Some thought should convince you that this is a complete list. The ALU is the functional essence of the computer. Registers are used to stoic data internal to the processor. Some registers contain status information needed to manage instruction sequencing (e.g., a program status word). Others contain data that go to or come from the ALU, memory, and I/O modules. Internal data paths are used to move data between registers and between register and ALU. External data paths link registers to memory and I/O modules, often by means of a system bus. The control unit causes operations to happen within the processor.
The execution of a program consists of operations involving these processor elements. As we have seen, these operations consist of a sequence of micro-operations. Upon review of Section 16.1, the reader should see that all micro-operations fall into one of the following categories:
  • Transfer data from one register to another.
  • Transfer data from a register to an external interface (e.g., system bus).
  • Transfer data from an external interface lo a register.
  • Perform an arithmetic or logic operation, using registers for input and output.
All of the micro-operations needed to perform one instruction cycle, including all of the micro-operations to execute every instruction in the instruction set, fall into one of these categories.
We can now be somewhat more explicit about the way in which the control unit functions. The control unit performs two basic tasks:
  • Sequencing: The control unit causes the processor lo step through a series of micro-operations in the proper sequence, based on the program being executed.
  • Execution: The control unit causes each micro-operation to be performed.
The preceding is a functional description of what the control unit does. The key to how the control unit operates is the use of control signals.

Control Signals

We have defined the elements that make up the processor (ALU, registers, data paths) and the micro-operations that are performed. For the control unit to perform its function, it must have inputs that allow it to determine the slate of the system and outputs that allow it to control the behavior of the system. These are the exter­nal specifications of the control unit. Internally, the control unit must have the logic required lo perform its sequencing and execution functions. The remainder of this section is concerned with the interaction between the control unit and the other elements of the processor.
Figure 3 is a general model of the control unit, showing all of its inputs and outputs. The inputs are as follows:
  • Clock: This is how the control unit "keeps time." The control unit causes one micro-operation (or a set of simultaneous micro-operations) to be performed for each clock pulse. This is sometimes referred to as the processor cycle time. or the clock cycle lime.
  • Instruction register: The opcode of the current instruction is used lo determine which micro-operations lo perform during the execute cycle.
  • Flags: These are needed by the control unit to determine the status of the processor and the outcome of previous ALU operations. For example, for the increment-and-skip-if-zero (ISZ) inslruelion, the control unil will increment the PC if the zero flag is set.
  • Control signals from control bus: The control bus portion of the system bus pro-vides signals to the control unit, such as interrupt signals and acknowledgments.
The outputs are as follows:
  • Control signals within the processor: These are two types: those that cause data to be moved from one register to another, and those that activate specific ALU functions.
  • Control signals to control bus: These are also of two types: control signals lo memory, and control signals lo the I/O modules.
The new element that has been introduced in this figure is the control signal. Three types of control signals are used: those that activate an ALU function, those that activate a data path, and those lhal are signals on the external system bus or other external interface. All of these signals are ultimately applied directly as binary inputs lo individual logic gates.
Figure 3: Model of Control Unit
Let us consider again the fetch cycle to see how the control unit maintains control. The control unit keeps track of where it is in the instruction cycle. At a given point, it knows that the fetch cycle is to be performed next. The first step is to transfer the contents of the PC to the MAR. The control unit does this by activating the control signal that opens the gates between the bits of the PC and the bits of the MAR. The next step is to read a word from memory into the MBR and increment the PC. The control unit does this by sending the following control signals simultaneously:
  • A control signal that opens gates, allowing the contents of the MAR onto the address bus
  • A memory read control signal on the control bus
  • A control signal that opens the gates, allowing the contents of the data bus to be stored in the MBR
  • Control signals to logic that add 1 to the contents of the PC and store the result back to the PC
Following this, the control unit sends a control signal that opens gates between the MBR and the IR.
This completes the fetch cycle except for one thing: The control unit must decide whether to perform an indirect cycle or an execute cycle next. To decide this, it examines the IR to see if an indirect memory reference is made.
The indirect and interrupt cycles work similarly. For the execute cycle, the control unit begins by examining the opcode and. on the basis of that, decides which sequence of micro-operations to perform for the execute cycle.

A Control Signals Example

To illustrate the functioning of the control unit, let us examine a simple example. Figure 4 illustrates the example. This is a simple processor with a single accumulator. The data paths between elements are indicated. The control paths for signals emanating from the control unit are not shown, but the terminations of control signals are labeled Ci and indicated by a circle. The control unit receives inputs from the clock, the instruction register, and flags. With each clock cycle, the control unit reads all of its inputs and emits a set of control signals. Control signals go to three separate destinations:
  • Data paths: The control unit controls the internal How of data. For example, on instruction fetch, the contents of the memory buffer register are transferred to the instruction register. For each path to be controlled, there is a gate (indicated by a circle in the figure). A control signal from the control unit temporarily opens the gate to let data pass.
  • ALU: The control unit controls the operation of the ALU by a set of control signals. These signals activate various logic devices and gates within the ALU.
  • System bus: The control unit sends control signals out onto the control lines of the system bus (e.g., memory READ).
The control unit must maintain knowledge of where it is in the instruction cycle. Using this knowledge, and by reading all of its inputs, the control unit emits
Figure 4: Data Paths and Control Signals
a sequence of control signals that causes micro-operations to occur. It uses the clock pulses to time the sequence of events, allowing time between events for signal levels to stabilize. Table (Figure 5) indicates the control signals that arc needed for some of the micro-operation sequences described earlier. For simplicity, the data and control paths for incrementing the PC and for loading the fixed addresses into the PC and MAR are not shown.
It is worth pondering the minimal nature of the control unit. The control unit is (he engine that runs the entire computer. It does this based only on knowing the instructions lo be executed and (he nature of the results of arithmetic and logical
Figure 5: Table: Micro-Operations and Control Signals
operations (e.g., positive, overflow, etc.). It never gets to see the data being processed or the actual results produced: And it controls everything with a few control signals to points within the processor and a few control signals to the system bus.

Internal Processor Organization

Figure 5 indicates the use of a variety of data paths. The complexity of this type of organization should be clear. More typically, some sort of internal bus arrangement, as was suggested in Figure 12.2, will be used.
Using an internal processor bus, Figure 5 can be rearranged as shown in Figure 6. A single internal bus connects the ALU and all processor registers. Gates and control signals are provided for movement of data onto and off the bus
Figure 6: CPU with Internal Bus
from each register. Additional control signals control data transfer to and from the
system (external) bus and the operation of the ALU.
Two new registers, labeled Y and Z. have been added to the organization. These are needed for the proper operation of the ALU. When an operation involv ing two operands is performed, one can he obtained from the internal bus, but the other must be obtained from another source. The AC could be used for this pur pose, but this limits the flexibility of the system and would not work with a proces sor with multiple general-purpose registers. Register Y provides temporary storage for the other input. The ALU is a combinatorial circuit (see Appendix A) with no internal storage, Thus, when control signals activate an ALU function, the input to thc ALU is transformed to the output. Thus, the output of the ALU cannot be directly connected to the bus, because this output would feed back to the input. Reg ister Z provides temporary output storage, With this arrangement, an operation to add a value from memory to the AC would have the following steps:
t1: MAR <= (IR(address))
t2: MBR <= Memory
t3: Y <= (MBR)
t4: Z <= (AC0 + (Y)
t5: ac <= (z)
Other organizations are possible, but, in general, some sort of internal bus or set of internal buses is used. The use of common data paths simplifies the interconnection layout and the control of the processor. Another practical reason for the use of an internal bus is to save space. Especially for microprocessors, which may occupy only a 1/4-inch square piece of silicon, space occupied by internal connections must be minimized.

The Intel 8085

To illustrate some of the concepts introduced thus far in this chapter, let us consider the Intel 8085, Its organization is shown in Figure 7. Several key components that may not be self-explanatory are as follows:
  • Incrementer decrementer address latch: Logic that can add 1 to or subtract 1 from the contents of the slack pointer or program counter. This saves time by avoiding the use of the ALU for this purpose.
  • Interrupt control: This module handles multiple levels of interrupt signals.
  • Serial I/O control: This module interfaces to devices that communicate 1 bit at a time.
Table 16.2 describes the external signals into and out of the 8085. These are linked to the external system bus. These signals are the interface between the 8085 processor and the rest of the system (Figure 8).
The control unit is identified as having two components labeled (1) instruction decoder and machine cycle encoding and (2) timing and control. A discussion of the first component is deferred until the next section. The essence of the control unit is the timing and control module. This module includes a clock and accepts as inputs
Figure 7: Intel 8085: CPU Block Diagram
Table 2 Intel 8085 External Signals
Address and Data Signal
High Address (A15-A8)
The high-order 8 bits of a 16-bit address.
Address/Data (AD7-AD0)
The lower-order 8 bits of a 16-bit address or 8 bits of data. This multiplexing.saves on pins.
Serial Input Data (SID)
A single-bit input to accommodate devices that transmit serially (one bit at a time), Serial Output Data (SOD)
A single-bit output to accommodate devices that receive serially.
Timing and Control Signals
CLK(OUT)
The system clock. Each cycle represents one T state. The CLK signal goes to peripheral chips and synchronizes their timing.
X1, X2
These signals come from an external crystal or other device to drive the internal clock generator.
Address Latch Enabled (ALE)
Occurs during the first clock state of a machine cycle and causes peripheral chips to store the address lines. This allows the address module (e.g., memory, I/O) to recognize that it is being addressed.
Status{S0, Sl)
Control signals used to indicate whether a read or write operation is taking place. IO/M
Used to enable either I/O or memory modules for read and write operations.
Read Control (RD)
Indicates that the selected memory or I/O module is to be read and that the data bus is available for data transfer.
Write Control (WR)
Indicates that data on the data bus is to be written into the selected memory or I/O location.
Memory and I/O Initiated Symbols
Hold
Requests Ihe CPU to relinquish control and use of the external system bus. The CPU will complete execution of the instruction presently in the IR and then enter a hold state, during which no signals are inserted by the CPU to the control. address, or data buses. During the hold state, the bus may be used for DMA operations.
Hold Acknowledge (HOLDA)
This control unit output signal acknowledges the HOLD signal and indicates that the bus is now available. READY
Used to synchronize the CPU with slower memory or I/O devices. When an addressed device asserts READY, the CPU may proceed with an input (DBIN) or output (WR)operation. Otherwise, the CPU enters a wait state until the device is ready.
Interrupt-Related Signals
TRAP
Restart Interrupts (RST 7.5, 6.5, 5.5)
Interrupt Request (INTR)
These live lines are used by an external device to interrupt the CPU. The CPU will not honor the request if it is in the hold state or if the interrupt is disabled. An interrupt is honored only at the completion of an instruction. The interrupts are in descending order of priority.
Interrupt Acknowledge
Acknowledges an interrupt.
CPU Initialization
RESET IN
Causes the contents of the PC to be set to zero. The CPU resumes execution at location zero.
RESET OUT
Acknowledges that the CPU has been reset. The signal can be used to reset the rest of the system.
Voltage and Ground
VCC
+5 volt power supply
VSS
Electrical ground
Figure 8: Intel 8085 Pin Configuration
the current instruction and some external control signals. Its output consists of control signals to the other components of the processor plus control signals to the external system bus.
The timing of processor operations is synchronized by the clock and con trolled by the control unit with control signals. Each instruction cycle is divided into from one to five machine cycles: each machine cycle is in turn divided into from three to five states. Each state lasts one clock cycle. During a state, the processor performs one or a set of simultaneous micro-operations as determined by the control signals.
The number of machine cycles is fixed for a given instruction but varies from one instruction to another. Machine cycles are defined to be equivalent to bus accesses. Thus, the number of machine cycles for an instruction depends on the number of times the processor must communicate with external devices. For example, if an instruction consists of two 8-bit portions, then two machine cycles are required to fetch the instruction. If that instruction involves a 1-byte memory or I/O operation, then a third machine cycle is required for execution.
Figure 9: Timming Diagram for Intel 8085 OUT Instruction
signals that control internal data transfers, The diagram shows the instruction cycle for an OUT instruction. Three machine cycles (M1, M2, M3) are needed. During the first, the OUT instruction is fetched. The second machine cycle fetches the second half of the instruction, which contains the number of the I/O device selected for out put. During the third cycle, the contents of the AC are written out to the selected device over the data bus.
The Address Latch Enabled (ALE) pulse signals the start of each machine cycle from the control unit. The ALE pulse alerts external circuits. During timing state T1 of machine cycle M1, the control unit sets the IO/M signal to indicate that this is a memory operation. Also, the control unit causes the contents of the PC to be placed on the address bus (A13 through A8) and the address/data bus (AD7 through AD0}. With the falling edge of the ALE pulse, the other modules on the bus store the address.
During timing state T2, the addressed memory module places the contents of the addressed memory location on the address/data bus. The control unit sets the Read Control (RD) signal to indicate a read, but it waits until T3 to copy the data from the bus. This gives the memory module time to put the data on the bus and for the signal levels to stabilize. The final state, T4 is a bus idle stale during which Ihe processor decodes the instruction. The remaining machine cycles proceed in a similar fashion.

Hardwired implementation

We have discussed the control unit in terms of its inputs, output, and functions. We now turn to the topic of control unit implementation. A wide variety of techniques have been used. Most of these fall into one of two categories:
  • Hardwired implementation
  • Micro programmed implementation
In a hardwired implementation, the control unit is essentially a combinatorial circuit. Its input logic signals are transformed into a set of output logic signals, which are the control signals. This approach is examined in this section. Micro programmed implementation is the subject of Chapter 17.

Control Unit Inputs

Figure 3 depicts the control unit as we have so far discussed it. The key inputs are the instruction register, the clock, flags, and control bus signals, In the case of the flags and control bus signals, each individual bit typically has some meaning (e.g., overflow). The other two inputs, however, are not directly useful to the control unit. First consider the instruction register. The control unit makes use of the opcode and will perform different actions (issue a different combination of control signals) for different instructions. To simplify the control unit logic, there should be a unique logic input for each opcode. This function can be performed by a decoder, which lakes an encoded input and produces a single output. In general, a decoder will have n binary inputs and 2n binary outputs. Each of the 2" different input patterns will activate a single unique output. Table (Figure 10) is an example. The decoder for a control unit will typically have to be more complex than that, to account for variable-length opcodes. An example of the digital logic used to implement a decoder is presented in Appendix A.
The clock portion of the control unit issues a repetitive sequence of pulses. This is useful (or measuring the duration of micro-operations. Essentially, the period of the clock pulses must be long enough to allow the propagation of signals along data paths and through processor circuitry. However, as we have seen, the control unit emits different control signals at different time units within a single instruction cycle. Thus, we would like a counter as input to the control unit, with a different control signal being used for T1, T2, and so forth. At the end of an instruction cycle, the control unit must feed back to the counter to reinitialize it at T1.
With these two refinements, the control unit can be depicted as in Figure 11.

Control Unit Logic

To define the hardwired implementation of a control unit, all that remains is to dis cuss the internal logic of the control unit that produces output control signals as a function of its input signals.
Figure 10: A Decoder with Four Inputs and Sixteen Outputs
Figure 11: Control Unit with Decoded Inputs
Essentially, what must be done is, for each control signal, to derive a Boolean expression of that signal as a function of the inputs. This is best explained by exam ple. Let us consider again our simple example illustrated in Figure 16.5. We saw in Table 16.1 the micro-operation sequences and control signals needed to control three of the four phases of the instruction cycle.
Let us consider a single control signal, C5. This signal causes data to be read from the external data bus into the MBR. We can see that it is used twice in Table 16.1. Let us define two new control signals. P and Q, that have the following interpretation:
PQ = 00 Fetch Cycle
PQ = 01 Indirect Cycle
PQ = 10 Execute Cycle
PQ = 11 Interrupt Cycle
Then the following Boolean expression defines C5
C 5 = P ¯ . Q ¯ . T 2 + P ¯ .Q. T 2 C 5 = P ¯ . Q ¯ . T 2 + P ¯ .Q. T 2 MathType@MTEF@5@5@+=feaagaart1ev2aaatCvAUfeBSjuyZL2yd9gzLbvyNv2CaerbuLwBLnhiov2DGi1BTfMBaeXatLxBI9gBaerbd9wDYLwzYbItLDharqqtubsr4rNCHbGeaGqiVu0Je9sqqrpepC0xbbL8F4rqqrFfpeea0xe9Lq=Jc9vqaqpepm0xbba9pwe9Q8fs0=yqaqpepae9pg0FirpepeKkFr0xfr=xfr=xb9adbaqaaeGaciGaaiaabeqaamaabaabaaGcbaGaam4qamaaBaaaleaacaaI1aaabeaakiabg2da9iqadcfagaqeaiaac6caceWGrbGbaebacaGGUaGaamivamaaBaaaleaacaaIYaaabeaakiabgUcaRiqadcfagaqeaiaac6cacaWGrbGaaiOlaiaadsfadaWgaaWcbaGaaGOmaaqabaaaaa@4384@
That is. the control signal C5 will be asserted during the second time unit of both the fetch and indirect cycles.
This expression is not complete. C5 is also needed during the execute cycle. For our simple example, let us assume that there are only three instructions that read from memory; LDA, ADD, and AND, Now we can define C5 as:
C 5 = P ¯ . Q ¯ . T 2 + P ¯ .Q. T 2 +P. Q ¯ .(LDA+ADD+AND). T 2 C 5 = P ¯ . Q ¯ . T 2 + P ¯ .Q. T 2 +P. Q ¯ .(LDA+ADD+AND). T 2 MathType@MTEF@5@5@+=feaagaart1ev2aaatCvAUfeBSjuyZL2yd9gzLbvyNv2CaerbuLwBLnhiov2DGi1BTfMBaeXatLxBI9gBaerbd9wDYLwzYbItLDharqqtubsr4rNCHbGeaGqiVu0Je9sqqrpepC0xbbL8F4rqqrFfpeea0xe9Lq=Jc9vqaqpepm0xbba9pwe9Q8fs0=yqaqpepae9pg0FirpepeKkFr0xfr=xfr=xb9adbaqaaeGaciGaaiaabeqaamaabaabaaGcbaGaam4qamaaBaaaleaacaaI1aaabeaakiabg2da9iqadcfagaqeaiaac6caceWGrbGbaebacaGGUaGaamivamaaBaaaleaacaaIYaaabeaakiabgUcaRiqadcfagaqeaiaac6cacaWGrbGaaiOlaiaadsfadaWgaaWcbaGaaGOmaaqabaGccqGHRaWkcaWGqbGaaiOlaiqadgfagaqeaiaac6cacaGGOaGaamitaiaadseacaWGbbGaey4kaSIaamyqaiaadseacaWGebGaey4kaSIaamyqaiaad6eacaWGebGaaiykaiaac6cacaWGubWaaSbaaSqaaiaaikdaaeqaaaaa@5441@
This same process could be repeated for every control signal generated by the processor. The result would be a set of Boolean equations that define the behavior of the control unit and hence of the processor.
To tie everything together, the control unit must control the state of Ihe instruction cycle. As was mentioned, at the end of each sub-cycle (fetch, indirect, execute, interrupt), the control unit issues a signal that causes the timing generator to reinitialize and issue T1. The control unit must also set the appropriate values of P and Q to define the next sub-cycle to be performed.
The reader should be able to appreciate that in a modern complex processor, the number of Boolean equations needed to define the control unit is very large. The task of implementing a combinatorial circuit that satisfies all of these equations becomes extremely difficult. The result is that a far simpler approach, known as Microprogramming, is usually used. This is the subject of the next chapter.

Comments, questions, feedback, criticisms?

Send feedback