16.1. Computer Organization and Architecture: A Pedagogical Aspect

Welcome to the fifth unit of the module on control design. So, as discussed in the last unit that from today we will be discussing on the special type of instructions, what are the control signal involved in, and we will be mainly talking about control instructions which are of jump, handling of function calls etcetera which we call as transfer instruction. So, this unit basically we will be covering on control signals, microinstructions involving transfer instructions like jump, call etcetera.

In this unit, we are diving into control transfer instructions. These are special commands in computer architecture that control the flow of execution by altering the sequence in which statements are run. Control transfer instructions include 'jump' and handling function calls. This unit will explore the signals and commands that facilitate these operations.

Think of control transfer instructions like a set of traffic signals at an intersection. Just as traffic signals control the flow of cars by directing them to stop or go depending on various conditions, control transfer instructions send the program execution in different directions based on certain conditions being met.

Basically as you already know the control transfer instructions are of two type conditional and unconditional sorry unconditional and conditional as we shown in the cases in the slide. So, what is the unconditional jump instruction, an unconditional jump instruction is very simple like jump go to that memory location where the corresponding instruction is there, maybe you call a function so that is an unconditional jump. And what is the conditional jump, when you look at these flags and decide what to do like jump on zero to some memory location 3030 where the next instruction is there. It will jump only if the zero flag is set, so that way we can differentiate the means control transfer instruction as conditional and unconditional.

Control transfer instructions can be either conditional or unconditional. Unconditional jumps move the execution to a specific memory location immediately without checking any conditions. For instance, if an instruction says, 'jump to address X', the program will jump to X regardless of any status. On the other hand, conditional jumps depend on certain conditions, often represented by flags in the CPU. An example would be 'jump if zero' – this jumps to a memory address only if a specific flag (the zero flag) is activated.

Imagine a game where a character can either jump to a new location immediately regardless of what is happening (unconditional jump) or can jump only if a specific condition is met, like if they have enough energy (conditional jump). This understanding helps in programming and executing logic efficiently.

As we have already discussed in the last three units that basically the three steps that is the first three steps basically involve fetching of the instruction. So, in this case what happens in the step one basically we load the program into the bus, the PC into the bus and we give it to the memory address register, so that the corresponding instruction can be fetched. We make the main memory in read mode and we get the value of the program or the instruction in the memory data register in this third stage basically.

The process of handling control transfer instructions begins with instruction fetching. The first step involves loading the Program Counter (PC), which holds the address of the next instruction, into the memory address register. This allows the CPU to fetch the specific instruction from memory. The CPU then needs to indicate that it's in 'read mode' to retrieve the correct data stored at that memory location. The data fetched is then held in the memory data register, ready for processing.

Imagine the CPU as a librarian. Whenever the librarian gets a request for a specific book (instruction), they first consult a catalog (Program Counter) to find the book's location. They then go to the shelf (memory), bring the book back, and place it on a desk (memory data register) for the person asking for it. This process ensures that the correct book is fetched systematically.

But here there are slight differences in case of a jump instruction or transfer instructions. In general type of instructions, we take the value of the program counter to the bus, put it in the address register, and then wait for the corresponding instruction to be obtained in the memory data register. And also what we do, we also try to increment the value of PC to the next value to point to the next instruction.

In the case of a transfer instruction like a jump, there are unique steps involved compared to regular instructions. Normally, the Program Counter (PC) increments automatically to point to the next instruction after fetching the current one. However, in a jump instruction, this automatic increment is paused since the program counter needs to be updated with a new address based on the jump. Additionally, the current value of the PC is stored in a temporary register for later use.

Consider a series of books on a shelf, where you usually turn to the next page after reading (incrementing the PC). But imagine if you decide to skip to another book (jump) based on what you want to read next; you might need to bookmark your current page (temporary storage) to find your way back once you're done with the new book. This illustrates how jumps adjust normal execution flow.

Now, in this case, what we have to do, we have to somehow load the value of program counter in the next stage to 3030 that is what is the execution to be done. Because when you want to execute some instruction which is the memory location 3030, what we have to do is to simply load the value of PC to 3030 and your job will be done.

When executing a jump instruction, the main goal is to load the program counter with the address specified in the instruction. For instance, if the instruction indicates a jump to memory location 3030, the CPU shifts the program counter to reflect this new address. This action effectively redirects the flow of execution to the instruction located at 3030.

Think of this as a GPS navigation system. If your destination changes (like jumping to a new instruction), the GPS will update your route and direct you to the new location (3030). Just as you’d rely on the GPS to direct your travel accurately, the CPU relies on the program counter to guide the execution path correctly.

--