 This time, we're going to begin building some data paths. The idea is going to be to take some of this hardware that we already have, that we already know how to build, and we're going to try to assemble them in such a way that we can implement a single type of instruction. We'll start off with something simple like an add instruction, and then work our way through the various other instructions that we've got. We're going to be working primarily with functional units that we've built so far, but we may throw in a few logicates here and there as needed. So with an add instruction, we want it to be able to take two values out of registers, add them together, and store them back into a register. So obviously I'm going to need some registers, and because I want to be able to add them together, I will use an ALU. And then once we're done, we'll store that back in the registers. So I can add some connectors, show that I'm taking the stuff out of the register, passing it to the ALU, and then when I'm done, I'll pass it back to the registers again. But I also need to do a little bit more than this. For one thing, I have to get my instruction. I have to know what two registers I need to add together and where to store the results back. So I also need an instruction memory. That will allow me to say, well, where does my first source register come from? Where does my second source register come from? And what is my destination register? But there's one more thing I'd like to be able to do here. I don't just want to be able to run one add instruction. I'd like to be able to run lots and lots of these. So my instruction memory is going to be indexed so that I can incrementally walk through my list of add instructions. And it's going to be indexed based on a program counter. This program counter will just be another register, like the regular block of registers. But it only holds one value. The address of the next instruction to run. So that will work great as the index into my instruction memory. It will tell me where I should go to get my next add instruction. But since I want to be able to iterate through all of these add instructions that I've got, I will also need to be able to increment this program counter. So I'm going to just want to be able to add four to this. So I'll take my program counter, pass it to an adder. I'll pass in the number four. And then I will take this result and store it back into my program counter. So now each time through this loop, I will increment my program counter by four. Since all of my instructions will be word sized, they're all 32 bits or four bytes. So I'm incrementing the counter by four every time. Which will mean each time through this loop, I will select a different add instruction. I will go request two values from the registers and tell it where to store the result value. The two source values will go to the ALU, they'll be added together. And then they'll be stored back into the registers when we're done. So to just build the data path for an add instruction, this is all we need. We read our instruction, we go get the requested data out of our registers, add that together and store it back into the registers, as well as incrementing the program counter so that we can get a different add instruction the next time through. But that's it.