 In this video we're going to describe very quickly what is known as the MARI architecture. This architecture is a fairly simplified microprocessor so that we can understand how the different registers and components work. The first component we're going to depict here at the top that's going to be the memory. Now MARI has a memory which has a total of 8 kilobytes of information. However, the special feature about this memory is that it contains 2 to the 12 cells but these cells are 16 bit addressable. What it means is that I do have 2 to the 12 cells but each one of these cells you can visualize it like this contains precisely 16 bits. In other words, every time I read a data from this memory I receive 16 bits of information and every time I want to write a piece of data in this memory I have to provide an address and 16 bits of information. The rest architecture is comprised of 7 registers. The first one we're going to depict here is what we call the MAR or memory address register. As the name says this register is in charge of storing the address of the data we want to either read or write from the MARI memory. Next we have another register which we call it the PC or program counter which holds the address of the instruction that is being executed or the instruction that is going to be executed next. As you can see these 2 registers over here hold addresses and therefore the size of these registers is 12 bits because the number of bits needed to address this memory bank is 12 bits as well. Next to the program counter we have a third register which is called the memory buffer register or MBR. MBR on the other hand it's going to be a register that is going to contain data that we either a storing memory or we retrieve from memory and therefore the size of this register is not going to be 12 but 6 bits. Next we have probably the most important register in our architecture, it's called AC and it's known as the accumulator. The accumulator will be the register we use to perform operations and store temporary results. Now the interesting part here is what we're going to have as well the combinational part ALU which will be in charge of performing arithmetical logic operations as we saw in previous examples. We have two additional registers in and out reg which will be used for input and output operations and the final register which will be IR which we will call the instruction register. Now let's look not that we have introduced only the names of these registers, let's see how are they connected to each other and the crucial observation here is that these architecture, all these blocks are connected through a bus that we are depicting like this which contains address and data bus and the connections of these blocks to these bus are all of them like this. MIR is connected like this as well. PC program counter can write on the bus or read from the bus. Same thing for MBR, same thing for the accumulator. What this means is that all these registers can write on that bus or read data from that bus and therefore we don't need so many point to point communications. Additionally to these connections we still need to see how the data comes in and out of the ALU. Now this architecture it's going to rely mostly on the data that comes from memory and is stored in MBR. Processing the operations will be in the ALU and storing the results will be on the accumulator. Therefore we're gonna have in this architecture these additional specific connections. So we'll have the possibility of loading data from the MBR to the accumulator and vice versa and the ALU will be capable of taking two of MBR and accumulator and store the result as well on the accumulator. So if we look a bit carefully here these two registers they have to be controlled in a way that even though they have two possibilities to read their data, in the case of the accumulator we have three. There has to be some control logic that has to decide at all times if the accumulator is going to load whatever values in the bus, whatever value comes from MBR or whatever value has been produced by ALU. Now the communication of all these blocks to the bus we're gonna enumerate them like this. One, two, three, four, five, six, seven. You have to remember that only one of these connections can be active at the same time in order for the value to propagate to the entire bus. Remember that a bus is a collection of signals such that if two connections are connected at the same time that produces an unstable value all around the bus. So we need a policy to access the bus such that out of these eight connections you see here only one of them is active at any point in time. So now let's go over again the size of the registers we have in these two registers MAR and PC they have memory addresses, represent like this, and therefore the size is 12 bits. They have memory addresses because this is when the register that we're gonna use to store the address to access memory and the program counter is always pointing to the address of the next instruction we have to execute. MBR and AC on the other hand will be processing data. Now the data comes from this memory and we know that this memory is 16-bit addressable. In other words it has two to the twelve cells each of one 16 bits. These cells when they are read from memory they'll be storing the MBR and the results will be processed by ALU and storing the accumulator and therefore we have 16 bits here for data processing. In this architecture the additional two registers IN-REG and OUT-REG are used for input output operations and they are based on the representation of letters and therefore they will have a size of 8 bits for input and output. And finally this register which is the instruction register, the instruction register these instructions will come from memory as well and therefore from point of view of the size it is similar to the accumulator and MBR and therefore you'll have also 16 bits. So to summarize what we have here is a very simple architecture. This architecture is based on this first block which is the memory with data and instructions. And then these registers over here will be used to store addresses for the case of AMAR a counter, what you call the program counter, next instruction to be executed, the data that is being either read or written to memory MBR, the accumulator for operations will always store the result there input data into the computer output data into some sort of peripheral or device and where we store the instruction being executed instruction register