24.1. Computer Organization and Architecture: A Pedagogical Aspect

Welcome to the unit 8 on the Module of Control. So, what we are discussing as of now in this module that how basically we can execute the controls, if the methodology is a micro program control. So, in the last unit basically we have seen the very basic idea of a micro programmed control unit that given a mainly we have discussed only the fetch part of the instruction.

This introduction sets the stage for understanding microprogrammed control units. The instructor emphasizes that this module focuses on how controls can be executed using micro programming techniques. Previously, they discussed the basic fetch part of an instruction, which is crucial as it is the first step in processing instructions. By understanding how the fetch works in a micro programmed control unit, students can appreciate the complexity involved in executing even simple commands.

Think of a microprogrammed control unit like a chef following a recipe to prepare a dish. Just as a chef first gathers all ingredients (fetching), the control unit fetches the instruction to understand what action needs to be taken.

Then we have discussed how basically we can optimize it, because in case of a micro program control memory we just give the signals which has to be made 0s and 1 and we write it into the memory. We have seen that there are lot of zeros and lot of zeros in this memory then we have seen how to optimize them using a vertical and hybrid micro program.

The instructor explains the need for optimizing microprogrammed control units. In a microprogram control memory, control signals are recorded as binary digits (0s and 1s). However, many of these signals can be redundant (lots of zeros), leading to inefficient use of memory. Therefore, optimization techniques like vertical and hybrid micro programs are introduced to reduce this redundancy and make the unit more efficient.

Think of optimizing a microprogrammed control unit like organizing a messy closet. By sorting through and removing unnecessary items (zeros), you can save space and make it easier to find what you need (relevant instructions).

So, basically a full program which is one of the main emphasis, how to see a full program which is written in terms of machine instruction that is macro program how it is executed. For each machine instruction when it is in the decoding cycle based on the Op-Code, the corresponding micro program is loaded into the memory.

In this section, the focus is on understanding how a full program operates within the microprogram control architecture. Each machine instruction corresponds to a specific microprogram. When the program is in its decoding phase, the control unit identifies the operation type (Op-Code) and accesses the relevant microprogram from memory, which dictates how the instruction is to be executed.

Consider this as handing a student a textbook based on their class schedule. Just like the student uses the relevant textbook to study for their classes, the control unit fetches the specific microprogram associated with each machine instruction to carry out the task.

The micro program counter fetches each micro instruction in sequence and then generate the required signal or if required jumps will also be there.

The micro program counter (MPC) is essential in managing the flow of micro instructions. It sequentially retrieves each instruction from the microprogram memory and generates control signals. If the instruction requires a different operation, the MPC may jump to a different part of the microprogram memory to fetch the appropriate instruction, ensuring that operations are executed correctly.

Imagine a train navigating a series of stops. The micro program counter is like the train conductor, moving from station to station (micro instruction to micro instruction) but also having the ability to change tracks (jump to different sections) when necessary.

So, what we do basically we try to keep something in common for example, the fetch part is common to all. So, there will be only a 3 bits or 3 words memory for fetch and then for example, if we have subtract and say add 2 instructions are there.

In microprogrammed architecture, it is efficient to share common components between different instructions. For instance, the fetch operation is identical for all instructions, allowing a unified approach. This minimization of redundancy leads to a leaner microprogram memory that can significantly enhance performance. However, it should be noted that where instructions differ, branching instructions are required to adapt the execution flow.

This concept can be compared to a group of friends deciding on a restaurant. If they all agree to get pizza (common step), they can just take one vehicle. However, if someone's tastes change and they prefer sushi (branching step), the group will need to re-divert to accommodate that choice.

--