12.2.5. Revisiting Single Bus Architecture

Basically, what will be covering in this unit, the unit summary will basically we will have quick revisit, as you can see in the first point. We will be quickly revisiting what is a single bus architecture? Because that is what is mainly we are dealing with all the examples and most of our study is basically on a single bus architecture. Then we look at where the ALU is connected? What are the different types of registers? What are the program counters? Instruction register, their interconnects, all this things we will have a quick reconnect recollect.

This section provides a summary of what will be covered regarding the single bus architecture. The focus will be on reviewing the architecture itself, the placement of the Arithmetic Logic Unit (ALU), various types of registers (like the program counter and instruction register), and their interconnections. Essentially, it sets the stage for a deeper understanding of how these components interact within a single bus framework.

Think of a public transport bus system where different stops (registers) must connect to a main road (the bus). Just like this bus system needs to know how to direct passengers to their next stops efficiently, the single bus architecture needs to manage data between the ALU and registers efficiently.

Then, we quickly jump to the different cycles of an instruction like fetch, decode execute and there will exactly see that what are the basic control signals required in each of the cycles.

Every instruction in a computer goes through a series of steps known as cycles: fetching the instruction, decoding it, and executing it. In this section, the focus will be on examining what specific control signals are necessary for each step of this cycle, ensuring a complete understanding of the internal processes during instruction execution.

Imagine baking a cake as an analogy for instruction cycles. First, you gather (fetch) the ingredients, then you read the recipe (decode) to understand what to do with those ingredients, and finally, you actually mix and bake the cake (execute). Each step requires specific actions and tools, just like the instruction cycles depend on particular control signals.

Any first step of the instruction basic instruction flow that is, basically your the fetch. So, fetch basically what happens? You take instruction from the memory and basically bring it to the instruction register that is the first part of the instruction.

The fetching of an instruction is the initial step in instruction execution, where the system retrieves the next instruction from memory and transfers it to the instruction register. This process involves the program counter, which signifies the address in memory where the instruction is stored, effectively directing the flow of execution.

Think of fetching an instruction as picking a book from a shelf (the memory) to read next. The book's location (its address) is indicated by a bookmark (the program counter) which tells you exactly where to look.

So, we will see what basically in the unit, we will first see what are the basic type of control signal requires to do that, basically what happens first, you see it will output the it shows that output the contents of the 𝑃𝐶 to the BUS, there because of the program counter only will point out, that which instruction has to be executed.

Control signals dictate how data moves within the system. In the fetching stage, specific control signals instruct the program counter to output its value to the bus, which then directs the flow of data to the memory address register, thus indicating which instruction should be fetched from memory.

Consider control signals like traffic lights at an intersection guiding vehicles (data) on where to go and when to stop. Just as green indicates to move forward, control signals instruct when and how to transfer instruction information through the bus.

In fact, also in this instruction you will also have to increment the program counter to point to the next instruction. So, what we do? We also instruction the ALU to perform addition, in this case it will add the value of program counter which is now in the bus, with the increment.

Part of the fetching process includes incrementing the program counter to point to the next instruction after the current instruction has been fetched. This involves the ALU performing an addition operation, adding the current value of the program counter with a constant (typically 1) to reflect the next instruction's location.

If you imagine each instruction as a page in a book, incrementing the program counter is like turning to the next page after reading. Every time you read an instruction (page), you move forward to the next one.

the contents of the bus will be loaded in to the memory address register, because when the program counter value will be loaded to the memory address register and the memory is in the read mode.

The contents of the bus, which hold the address of the instruction to be fetched, are loaded into the memory address register. This activity occurs once the program counter has output its value, and it's imperative that the memory is set to read mode at this point to allow the data transfer.

This step can be likened to entering a library and giving the librarian (memory) the exact location of the book you want to read (instruction address) so that they can retrieve it for you.

So, basically in the first step, basically loads the instruction from the memory to the instruction register, it initiates and it will also increment value of program counter to point to the next location.

During the instruction fetch phase, the ALU plays a critical role by not only aiding in the fetching process but also managing the addition required to increment the program counter. This aspect ensures that the sequential flow of program execution is maintained.

Imagine a chef not only cooking a dish (fetching instruction) but also timing (incrementing) when to start on the next dish. The ALU ensures that the sequence of operations is followed correctly.

Now you have to wait till the memory signal is ready, basically what happens, whenever we are giving a read command and you have given the data that is the 𝑃𝐶 value to the memory address register, you have to wait for some amount of time, till the memory says that I am ready and the instruction is now loaded into the memory buffer register.

After the program counter is loaded into the memory address register and the memory is set to read, there will be a waiting period until the memory signals readiness for the data transfer. This waiting ensures that the system doesn't attempt to access data that isn't yet available.

This can be visualized as waiting for a pizza to be cooked in a restaurant. You place your order (send a read command), but then you must wait until the restaurant signals that your pizza is ready before you can enjoy it.

--