22.3.2. Performance of CPU in Executing Instructions

So, welcome to the module on addressing modes, instruction set and instruction execution flow, lecture number 3, so that is unit number 3.

Since the last 2 units we have basically seen what is the basic structure and the components of a CPU and external interface and we have seen basically the black box architecture of a memory. So, with this we have built enough background to understand the basic stuff which we are going to cover in this module that is, what is an instruction, how it is executed, what are the different types and formats, instruction set design and what are the typical use of instructions to call functions and return procedure.

This introduction sets the stage for understanding how a CPU executes instructions. It summarizes prior knowledge about CPU structure and memory and explains that the current focus will be on various aspects of instruction execution, including the types of instructions and their formats.

Think of the CPU as a chef in a kitchen. Before starting to cook (execute instructions), the chef needs to know what ingredients are available (the structure of the CPU and memory). This preparation allows the chef to efficiently follow recipes (instructions) to create a variety of dishes (perform functions).

So, as I told you that for a pedagogical perspective. So, we are first going to see what is the performance or what is the functions which are performed by a CPU for executing an instruction.

So, basically as it is a Von Neumann architecture so the instruction as well as data are in the memory. So, first what happens? So, whenever you want to execute an instruction, first you have to calculate the address of the instruction and in which memory location and at what address the instruction is there.

In a Von Neumann architecture, both data and instructions are stored in memory. The first step in executing an instruction is determining where that instruction is located in memory. This involves calculating the instruction's address. It’s a crucial step because without knowing where to find the instruction, the CPU cannot execute it.

Imagine you need to retrieve a specific recipe from a cookbook. The first step is to look at the index (calculate the address) to find out which page number (the address in memory) the recipe is on. Only then can you turn to that page to see what ingredients and steps you need (fetching and executing the instruction).

Secondly, the instruction will be fetched, now it will be fetched and loaded into a special register called instruction register IR.

After determining where the instruction is located, the CPU fetches it and loads it into a special register known as the Instruction Register (IR). The IR temporarily holds the instruction that is currently being executed, allowing the CPU to process it in the next steps.

Continuing with the recipe analogy, after finding the page number, you turn to that page and hold it open (fetching) so you can read the recipe as you cook. The page you've opened is like the IR—it contains the information you need to proceed.

So, now, the instructions will be decoded that what it has to do, sometimes it may be very simple like shift 2 numbers or add 2 numbers or do bitwise shifting and sometimes it can be very complicated like a matrix multiplication.

Once the instruction is fetched into the IR, the next step is decoding it. This process involves interpreting what the instruction is supposed to do. Some instructions are straightforward, like addition or subtraction, while others can be more complex, such as executing a loop or performing matrix operations.

Imagine reading a recipe with different sections. Some instructions might be as simple as 'add salt' (easy to decode), while others may involve multiple steps like 'mix, bake, and cool' (complex to decode). Understanding these steps is critical for successful cooking (or instruction execution).

Then you have to find out that is the operation decoding that what is the instruction expected to do, that is all the instruction basically has 2 minimum characters, minimum fields one is the opcode that is the operation it has to do that is again binarized because all the instructions are basically represented in binary.

Each instruction has essential parts, primarily the opcode, which specifies the operation to be performed. The opcode is represented in binary format, which is the language the CPU understands. Alongside the opcode, there are also fields for the operands, which are the values on which operations are performed.

Think of the opcode as the command in a recipe, like 'bake' or 'boil.' Just like a recipe uses specific commands to guide cooking, the CPU uses opcodes to dictate what operations to perform on which ingredients (operands).

After decoding you have to find out whether you want one operand to be fetched, whether you want 2 operands to be fetched or whether the operand is given itself with the instruction.

Depending on the instruction, the CPU may need to fetch one or more operands—these can be found in memory or directly within the instruction itself. The way operands are specified can vary, influencing how the CPU accesses the necessary data for operation.

In cooking, sometimes you have all ingredients specified in the recipe (operands given in the instruction), while other times you'll need to go to the pantry (fetch operands from memory) for items like flour or sugar. The CPU operates similarly, determining how to access data for computations.

So, after that is done you have to do the operation of the data and then you have to store back the data in the memory, if it is required. So, in a nutshell basically we store fetch the instruction, decode the instruction and then find out whether some operands has to be fetched from the memory and then fetch the operands do the operation and store it in a memory location.

After the operands are fetched, the CPU performs the operation as defined by the instruction. If needed, the result is then stored back in memory. This entire sequence is often summarized as fetching the instruction, decoding it, executing it, and possibly storing the result.

After preparing the ingredients (fetching and decoding), the chef (CPU) now starts cooking (executing). If the dish is complete and requires serving (storing), the final product is placed on the table (memory) ready for consumption.

But there is also very special stuff which is actually called the interrupt... the basic idea of instruction execution that is you fetch decode and execute and in fact, if the instruction interrupt then you have to service the interrupt service and then again come back.

An interrupt is a signal that temporarily halts the current instruction flow, allowing the CPU to address critical tasks, such as responding to user inputs (like a mouse movement). After servicing the interrupt, the CPU returns to where it left off, continuing with instruction execution. This involves saving the current state before the interrupt is handled.

Think of a chef cooking in a busy kitchen when a waiter interrupts to request a new order. The chef notes down their current task (saving state), takes care of the order (servicing the interrupt), and then returns to finish the original recipe (resume execution). This ensures everything runs smoothly.

--