Name: 寄存器和RAM。計算機科學速成班#6 (Registers and RAM: Crash Course Computer Science #6)
Uploaded: 2021-01-14T06:57:32.000Z
Duration: 12 min 17 s
Description: 【看影片學英語】數萬部 YouTube 影片，搭配英漢字典即點即查，輕鬆掌握單字發音與用法，長久累積看電影不必再看字幕。

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.

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.

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

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, we’re going to start small - literally by building a circuit that can store one..

After that, we’ll scale up, and build our very own memory module, and we’ll combine

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

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

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

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

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

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

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 we’ve 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

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

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!

This is called a “latch” because it “latches onto” a particular value and stays that way.

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

Ok, so we’ve got a way to store a single bit of information!

Unfortunately, having two different wires for input – set and reset – is 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 or “locked” down --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 the “gate” can 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, we’re

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

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 to “open” the “gate” by 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.

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

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

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

useful -- definitely not enough to run Frogger.

But we’re 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

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

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

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

字幕列表影片播放

寄存器和RAM。計算機科學速成班#6 (Registers and RAM: Crash Course Computer Science #6)

episode

individual

stick

access