30.1.1. Case 1: Advantages of Adding R1 into R2

Now, we are going to take two examples; in one example we will show that what are the advantages of having three buses and another case we will show that we do not get so much advantage, if you are considering a multiple bus architecture. Two extremes that means two different instructions we will take and show, but for most of the cases we are always going to have an advantage, because that is very obvious because if you have multiple buses things will go parallelly, but for one or two stray examples we can see where the advantage is not there in fact, you are having more hardware, but still the number of stages are not reducing.

In this section, we're discussing two examples of bus architecture—one showing the advantages of using three buses and the other demonstrating a scenario where the benefits are not as significant. Generally, multiple bus systems allow operations to be carried out simultaneously, which improves performance. However, there might be rare instances where having more hardware does not reduce the number of instruction stages.

Think of bus architecture like a multi-lane highway. On a busy day, having more lanes (buses) allows for more cars (data) to travel at once, reducing traffic. However, on a less busy day, adding more lanes might not make much difference if the same number of cars is still using the road.

So, the first case we are going to take is add 𝑅 into 𝑅 . So, what is the thing? So, two variables already available in 𝑅 and 𝑅 and then one you have to do it. So, first is you have to fetch the instruction. So how do you fetch the instruction? Basically program counter output value will go to memory address register in, that is as simple as for single bus architecture then you put the memory in read mode here you select 0; that means, you want to add the constant and increment program counter and add.

In the multiple bus architecture, the first step involves fetching the instruction to add R1 and R2. This is done by sending the program counter's output to the memory address register. We toggle the memory to read mode and select a constant to be added to the program counter's value. This allows us to directly access the instruction we want to execute without needing temporary registers.

Imagine you've written down a shopping list (instruction) on a notepad (program counter). If you immediately access the list to see what you need, you're efficiently using what you have without having to make an extra copy of the list (temporary register), just like how we fetch the instruction directly in a bus architecture.

But if you look at a single bus architecture, we had another signal that is called 𝑍 . Because the output of program counter plus constant has to store in a separate temporary register which we call it Z or Y... But in this case as we have already seen we do not require any kind of a temporary register.

In the single bus architecture, there is a step that involves storing intermediate values in temporary registers (Z or Y) before using them. However, with the multiple bus architecture, there is no need for such temporary storage since the values can be directly transferred between registers and buses. This significantly reduces the number of control signals and steps needed in processing the instruction.

Consider preparing a recipe. In a traditional kitchen (single bus), you might mix ingredients in one bowl (temporary register) before transferring them to a cooking pot. In a well-designed kitchen (multiple bus), you can immediately add ingredients from one bowl to the pot without extra steps, thereby saving time and effort.

Next stage is simple you have to make PC in read the value of output to the PC, and wait till the memory response. And if you look at the single bus architecture, these things were very similar you have to read the value of PC, WMFC, but also you had a sin single instruction called 𝑍 ... already bus C is carrying the value of the new value of the program counter.

After the instruction is fetched, the next step is updating the program counter with the new value. In the single bus architecture, there would be a need to store values temporarily before updating. In contrast, the multiple bus architecture allows this process to happen directly, reducing the need for extra instructions and steps.

Think about it as keeping track of your place while reading. In an inefficient method (single bus), you might write down the page number (temporary register) before turning to the new page. In an efficient method (multiple bus), you can simply flip the page and know exactly where you are without any intermediate steps.

Now, let us see we have to now do the real addition? So, if you look at it. So, what is the addition? So, we are assuming that the two registers 𝑅 and 𝑅 already has the value, and the instruction that is 𝑅 𝑎𝑑𝑑 𝑅 ,𝑅 is going to the instruction register...

Once we are ready to perform the addition, both registers R1 and R2 contain the required values. The instruction to add these two registers is brought to the instruction register. Then, the signals generated will allow values from both registers to be fed into the ALU (Arithmetic Logic Unit) directly, enabling the operation without additional delays caused by temporary storage.

It's similar to cooking. If you have all your ingredients ready (values in R1 and R2), you can simply toss them into the pot (ALU) without measuring them out into separate bowls first. This makes the cooking process much more efficient, similar to how multiple buses streamline the addition of register values.

--