Placeholder Image

Subtitles section Play video

  • Hi, I’m Carrie Anne and welcome to Crash Course Computer Science.

  • So last episode, using just logic gates, we built a simple ALU, which performs arithmetic

  • and logic operations, hence the ‘A’ and the ‘L’.

  • But of course, there’s not much point in calculating a result only to throw it away

  • - it would be useful to store that value somehow, and maybe even run several operations in a row.

  • That's where computer memory comes in!

  • If you've ever been in the middle of a long RPG campaign on your console, or slogging

  • through a difficult level on Minesweeper on your desktop, and your dog came by, tripped

  • and pulled the power cord out of the wall, you know the agony of losing all your progress.

  • Condolences.

  • But the reason for your loss is that your console, your laptop and your computers make

  • use of Random Access Memory, or RAM, which stores things like game state - as long as

  • the power stays on.

  • Another type of memory, called persistent memory, can survive without power, and it’s

  • used for different things; We'll talk about the persistence of memory in a later episode.

  • Today, were going to start small - literally by building a circuit that can store one..

  • single.. bit of information.

  • After that, well scale up, and build our very own memory module, and well combine

  • it with our ALU next time, when we finally build our very own CPU!

  • INTRO

  • All of the logic circuits we've discussed so far go in one direction - always flowing

  • forward - like our 8-bit ripple adder from last episode.

  • But we can also create circuits that loop back on themselves.

  • Let’s try taking an ordinary OR gate, and feed the output back into one of its inputs

  • and see what happens.

  • First, let’s set both inputs to 0.

  • So 0 OR 0 is 0, and so this circuit always outputs 0.

  • If we were to flip input A to 1.

  • 1 OR 0 is 1, so now the output of the OR gate is 1.

  • A fraction of a second later, that loops back around into input B, so the OR gate sees that

  • both of its inputs are now 1.

  • 1 OR 1 is still 1, so there is no change in output.

  • If we flip input A back to 0, the OR gate still outputs 1.

  • So now we've got a circuit that records a “1” for us.

  • Except, we've got a teensy tiny problem - this change is permanent!

  • No matter how hard we try, there’s no way to get this circuit to flip back from a 1

  • to a 0.

  • Now let’s look at this same circuit, but with an AND gate instead.

  • We'll start inputs A and B both at 1.

  • 1 AND 1 outputs 1 forever.

  • But, if we then flip input A to 0, because it’s an AND gate, the output will go to 0.

  • So this circuit records a 0, the opposite of our other circuit.

  • Like before, no matter what input we apply to input A afterwards, the circuit will always output 0.

  • Now weve got circuits that can record both 0s and 1s.

  • The key to making this a useful piece of memory is to combine our two circuits into what is

  • called the AND-OR Latch.

  • It has two inputs, a "set" input, which sets the output to a 1, and a "reset" input, which

  • resets the output to a 0.

  • If set and reset are both 0, the circuit just outputs whatever was last put in it.

  • In other words, it remembers a single bit of information!

  • Memory!

  • This is called a “latchbecause itlatches onto” a particular value and stays that way.

  • The action of putting data into memory is called writing, whereas getting the data out

  • is called reading.

  • Ok, so weve got a way to store a single bit of information!

  • Great!

  • Unfortunately, having two different wires for inputset and resetis a bit confusing.

  • To make this a little easier to use, we really want a single wire to input data, that we

  • can set to either 0 or 1 to store the value.

  • Additionally, we are going to need a wire that enables the memory to be either available

  • for writing orlockeddown --which is called the write enable line.

  • By adding a few extra logic gates, we can build this circuit, which is called a Gated Latch

  • since thegatecan be opened or closed.

  • Now this circuit is starting to get a little complicated.

  • We don’t want to have to deal with all the individual logic gates... so as before, were

  • going to bump up a level of abstraction, and put our whole Gated Latch circuit in a box

  • -- a box that stores one bit.

  • Let’s test out our new component!

  • Let’s start everything at 0.

  • If we toggle the Data wire from 0 to 1 or 1 to 0, nothing happens - the output stays at 0.

  • That’s because the write enable wire is off, which prevents any change to the memory.

  • So we need toopenthegateby turning the write enable wire to 1.

  • Now we can put a 1 on the data line to save the value 1 to our latch.

  • Notice how the output is now 1.

  • Success!

  • We can turn off the enable line and the output stays as 1.

  • Once again, we can toggle the value on the data line all we want, but the output will

  • stay the same.

  • The value is saved in memory.

  • Now let’s turn the enable line on again use our data line to set the latch to 0.

  • Done.

  • Enable line off, and the output is 0.

  • And it works!

  • Now, of course, computer memory that only stores one bit of information isn’t very

  • useful -- definitely not enough to run Frogger.

  • Or anything, really.

  • But were not limited to using only one latch.

  • If we put 8 latches side-by-side, we can store 8 bits of information like an 8-bit number.

  • A group of latches operating like this is called a register, which holds a single number,

  • and the number of bits in a register is called its width.

  • Early computers had 8-bit registers, then 16, 32, and today, many computers have registers

  • that are 64-bits wide.

  • To write to our register, we first have to enable all of the latches.

  • We can do this with a single wire that connects to all of their enable inputs, which we set to 1.

  • We then send our data in using the 8 data wires, and then set enable back to 0, and

  • the 8 bit value is now saved in memory.

  • Putting latches side-by-side works ok for a small-ish number of bits.

  • A 64-bit register would need 64 wires running to the data pins, and 64 wires running to

  • the outputs.

  • Luckily we only need 1 wire to enable all the latches, but that’s still 129 wires.

  • For 256 bits, we end up with 513 wires!

  • The solution is a matrix!

  • In this matrix, we don’t arrange our latches in a row, we put them in a grid.

  • For 256 bits, we need a 16 by 16 grid of latches with 16 rows and columns of wires.

  • To activate any one latch, we must turn on the corresponding row AND column wire.

  • Let’s zoom in and see how this works.

  • We only want the latch at the intersection of the two active wires to be enabled,

  • but all of the other latches should stay disabled.

  • For this, we can use our trusty AND gate!

  • The AND gate will output a 1 only if the row and the column wires are both 1.

  • So we can use this signal to uniquely select a single latch.

  • This row/column setup connects all our latches with a single, shared, write enable wire.

  • In order for a latch to become write enabled, the row wire, the column wire, and the write

  • enable wire must all be 1.

  • That should only ever be true for one single latch at any given time.

  • This means we can use a single, shared wire for data.

  • Because only one latch will ever be write enabled, only one will ever save the data

  • -- the rest of the latches will simply ignore values on the data wire because they are not

  • write enabled.

  • We can use the same trick with a read enable wire to read the data later, to get the data

  • out of one specific latch.

  • This means in total, for 256 bits of memory, we only need 35 wires - 1 data wire, 1 write

  • enable wire, 1 read enable wire, and 16 rows and columns for the selection.

  • That’s significant wire savings!

  • But we need a way to uniquely specify each intersection.

  • We can think of this like a city, where you might want to meet someone at 12th avenue

  • and 8th street -- that's an address that defines an intersection.

  • The latch we just saved our one bit into has an address of row 12 and column 8.

  • Since there is a maximum of 16 rows, we store the row address in a 4 bit number.

  • 12 is 1100 in binary.

  • We can do the same for the column address: 8 is 1000 in binary.

  • So the address for the particular latch we just used can be written as 11001000.

  • To convert from an address into something that selects the right row or column, we need

  • a special component called a multiplexer -- which is the computer component with a pretty cool

  • name at least compared to the ALU.

  • Multiplexers come in all different sizes, but because we have 16 rows, we need a 1 to

  • 16 multiplexer.

  • It works like this.

  • You feed it a 4 bit number, and it connects the input line to a corresponding output line.

  • So if we pass in 0000, it will select the very first column for us.

  • If we pass in 0001, the next column is selected, and so on.

  • We need one multiplexer to handle our rows and another multiplexer to handle the columns.

  • Ok, it’s starting to get complicated again, so let’s make our 256-bit memory its own component.

  • Once again a new level of abstraction!

  • It takes an 8-bit address for input - the 4 bits for the column and 4 for the row.

  • We also need write and read enable wires.

  • And finally, we need just one data wire, which can be used to read or write data.

  • Unfortunately, even 256-bits of memory isn’t enough to run much of anything, so we need

  • to scale up even more!

  • Were going to put them in a row.

  • Just like with the registers.

  • Well make a row of 8 of them, so we can store an 8 bit number - also known as a byte.

  • To do this, we feed the exact same address into all 8 of our 256-bit memory components

  • at the same time, and each one saves one bit of the number.

  • That means the component we just made can store 256 bytes at 256 different addresses.

  • Again, to keep things simple, we want to leave behind this inner complexity.

  • Instead of thinking of this as a series of individual memory modules and circuits, well

  • think of it as a uniform bank of addressable memory.

  • We have 256 addresses, and at each address, we can read or write an 8-bit value.

  • Were going to use this memory component next episode when we build our CPU.

  • The way that modern computers scale to megabytes and gigabytes of memory is by doing the same

  • thing weve been doing here -- keep packaging up little bundles of memory into larger, and

  • larger, and larger arrangements.

  • As the number of memory locations grow, our addresses have to grow as well.

  • 8 bits hold enough numbers to provide addresses for 256 bytes of our memory, but that’s all.

  • To address a gigabyteor a billion bytes of memorywe need 32-bit addresses.