 This time, we're going to start looking at forwarding. In this video, we'll focus on what forwarding is and how it works. Then in the next video, we'll see how we can update our architecture to implement forwarding. If you think about your arithmetic instructions, you know that they compute their results in the third stage. Then they spend the next two stages waiting to write their results back. So instead of waiting two extra cycles to write those results back, we could just take them and pass them to something else that wants them. That is essentially what we're going to do with forwarding. So let's look at our previous code again. If we think about our add instruction, it computes its results in the third stage. So as soon as that's done, it can pass those results to any other instruction that wants them. The add instruction will just place its results in the execute memory stage registers, and the subtract instruction can come along, pull those out, and use them for its own computation. For the or instruction, we still won't have written our result back to T0 in time. We're still just right here. So the or instruction will want to start its computation while the add instruction is actually writing this data back. So in this case, your instruction will try to take the data from the memory writeback stage registers and use that instead. In general, forwarding will work really well when we have lots of arithmetic instructions in a row. All of these instructions compute their results relatively early in the pipeline, and we can just pass the results from the end of the execute stage back to the beginning of the next execute stage. So it works really well for these. But it's still not perfect when we get to load instructions. Load instructions only produce the results at the end of the memory stage. So this is one cycle later than our arithmetic instructions. If we want to use the results of a load instruction in the next instruction, like we do here, then we still need one instruction between them. We could fill this with another unrelated instruction, but if we don't have anything else, then we'll just stick a nil op in there. So in general, forwarding works really well, but it's still limited when we have memory instructions in our code.