Placeholder Image

字幕表 動画を再生する

  • Hi, I’m Carrie Anne, this is Crash Course Computer Science, and today, were talking about processors.

  • Just a warning though - this is probably the most complicated episode in the series.

  • So once you get this, youre golden.

  • Weve already made a Arithmetic and Logic Unit, which takes in binary numbers and performs

  • calculations, and weve made two types of computer memory: Registers -- small, linear

  • chunks of memory, useful for storing a single value -- and then we scaled up, and made some

  • RAM, a larger bank of memory that can store a lot of numbers located at different addresses.

  • Now it’s time to put it all together and build ourselves the heart of any computer,

  • but without any of the emotional baggage that comes with human hearts.

  • For computers, this is the Central Processing Unit, most commonly called the CPU.

  • INTRO

  • A CPU’s job is to execute programs.

  • Programs, like Microsoft Office, Safari, or your beloved copy of Half Life: 2, are made

  • up of a series of individual operations, called instructions, because theyinstruct

  • the computer what to do.

  • If these are mathematical instructions, like add or subtract, the CPU will configure its

  • ALU to do the mathematical operation.

  • Or it might be a memory instruction, in which case the CPU will talk with memory

  • to read and write values.

  • There are a lot of parts in a CPU, so were going to lay it out piece by piece, building

  • up as we go.

  • Well focus on functional blocks, rather than showing every single wire.

  • When we do connect two components with a line, this is an abstraction for all of the necessary wires.

  • This high level view is called the microarchitecture.

  • OK, first, were going to need some memory.

  • Lets drop in the RAM module we created last episode.

  • To keep things simple, well assume it only has 16 memory locations, each containing 8 bits.

  • Let’s also give our processor four, 8-bit memory registers, labeled A, B, C and D which

  • will be used to temporarily store and manipulate values.

  • We already know that data can be stored in memory as binary values

  • and programs can be stored in memory too.

  • We can assign an ID to each instruction supported by our CPU.

  • In our hypothetical example, we use the first four bits to store theoperation code”,

  • or opcode for short.

  • The final four bits specify where the data for that operation should come from -

  • this could be registers or an address in memory.

  • We also need two more registers to complete our CPU.

  • First, we need a register to keep track of where we are in a program.

  • For this, we use an instruction address register, which as the name suggests, stores the memory

  • address of the current instruction.

  • And then we need the other register to store the current instruction, which well call the instruction register.

  • When we first boot up our computer, all of our registers start at 0.

  • As an example, weve initialized our RAM with a simple computer program that well to through today.

  • The first phase of a CPU’s operation is called the fetch phase.

  • This is where we retrieve our first instruction.

  • First, we wire our Instruction Address Register to our RAM module.

  • The register’s value is 0, so the RAM returns whatever value is stored in address 0.

  • In this case, 0010 1110.

  • Then this value is copied into our instruction register.

  • Now that weve fetched an instruction from memory, we need to figure out what that instruction is

  • so we can execute it.

  • That is run it.

  • Not kill it.

  • This is called the decode phase.

  • In this case the opcode, which is the first four bits, is: 0010.

  • This opcode corresponds to theLOAD A” instruction, which loads a value from RAM

  • into Register A.

  • The RAM address is the last four bits of our instruction which are 1110, or 14 in decimal.

  • Next, instructions are decoded and interpreted by a Control Unit.

  • Like everything else weve built, it too is made out of logic gates.

  • For example, to recognize a LOAD A instruction, we need a circuit that checks if the opcode

  • matches 0010 which we can do with a handful of logic gates.

  • Now that we know what instruction were dealing with, we can go ahead and perform

  • that instruction which is the beginning of the execute phase!

  • Using the output of our LOAD_A checking circuit, we can turn on the RAM’s read enable line

  • and send in address 14.

  • The RAM retrieves the value at that address, which is 00000011, or 3 in decimal.

  • Now, because this is a LOAD_A instruction, we want that value to only be saved into Register A

  • and not any of the other registers.

  • So if we connect the RAM’s data wires to our four data registers, we can use our LOAD_A

  • check circuit to enable the write enable only for Register A.

  • And there you have it -- weve successfully loaded the value at RAM address 14 into Register A.

  • Weve completed the instruction, so we can turn all of our wires off, and we’’re

  • ready to fetch the next instruction in memory.

  • To do this, we increment the Instruction Address Register by 1 which completes the execute phase.

  • LOAD_A is just one of several possible instructions that our CPU can execute.

  • Different instructions are decoded by different logic circuits, which configure the CPU’s

  • components to perform that action.

  • Looking at all those individual decode circuits is too much detail, so since we looked at one example,

  • were going to go head and package them all up as a single Control Unit to keep things simple.

  • That’s right a new level of abstraction.

  • The Control Unit is comparable to the conductor of an orchestra, directing all of the different

  • parts of the CPU.

  • Having completed one full fetch/decode/execute cycle, were ready to start all over again,

  • beginning with the fetch phase.

  • The Instruction Address Register now has the value 1 in it, so the RAM gives us the value

  • stored at address 1, which is 0001 1111.

  • On to the decode phase!

  • 0001 is theLOAD B” instruction, which moves a value from RAM into Register B.

  • The memory location this time is 1111, which is 15 in decimal.

  • Now to the execute phase!

  • The Control Unit configures the RAM to read address 15 and configures Register B to receive the data.

  • Bingo, we just saved the value 00001110, or the number 14 in decimal, into Register B.

  • Last thing to do is increment our instruction address register by 1, and were done with another cycle.

  • Our next instruction is a bit different.

  • Let’s fetch it.

  • 1000 01 00.

  • That opcode 1000 is an ADD instruction.

  • Instead of an 4-bit RAM address, this instruction uses two sets of 2 bits.

  • Remember that 2 bits can encode 4 values, so 2 bits is enough to select any one of our 4 registers.

  • The first set of 2 bits is 01, which in this case corresponds to Register B, and 00, which is Register A.

  • So “1000 01 00” is the instruction for adding the value in Register B into the value in register A.

  • So to execute this instruction, we need to integrate the ALU we made in Episode 5 into our CPU.

  • The Control Unit is responsible for selecting the right registers to pass in as inputs,

  • and configuring the ALU to perform the right operation.

  • For this ADD instruction, the Control Unit enables Register B and feeds its value into

  • the first input of the ALU.

  • It also enables Register A and feeds it into the second ALU input.

  • As we already discussed, the ALU itself can perform several different operations, so the

  • Control Unit must configure it to perform an ADD operation by passing in the ADD opcode.

  • Finally, the output should be saved into Register A. But it can’t be written directly

  • because the new value would ripple back into the ALU and then keep adding to itself.

  • So the Control Unit uses an internal register to temporarily save the output, turn off the

  • ALU, and then write the value into the proper destination register.

  • In this case, our inputs were 3 and 14, and so the sum is 17, or 00010001 in binary,

  • which is now sitting in Register A. As before, the last thing to do is increment our instruction

  • address by 1, and another cycle is complete.

  • Okay, so let’s fetch one last instruction: 01001101.

  • When we decode it we see that 0100 is a STORE_A instruction, with a RAM address of 13.

  • As usual, we pass the address to the RAM module, but instead of read-enabling the memory, we write-enable it.

  • At the same time, we read-enable Register A. This allows us to use the data line to

  • pass in the value stored in register A.

  • Congrats, we just ran our first computer program!

  • It loaded two values from memory, added them together, and then saved that sum back into memory.

  • Of course, by me talking you through the individual steps, I was manually transitioning the CPU

  • through its fetch, decode and execute phases.

  • But there isn’t a mini Carrie Anne inside of every computer.

  • So the responsibility of keeping the CPU ticking along falls to a component called the clock.

  • As it’s name suggests, the clock triggers an electrical signal at a precise and regular interval.

  • Its signal is used by the Control Unit to advance the internal operation of the CPU,

  • keeping everything in lock-step - like the dude on a Roman galley drumming rhythmically

  • at the front, keeping all the rowers synchronized... or a metronome.

  • Of course you can’t go too fast, because even electricity takes some time to travel

  • down wires and for the signal to settle.

  • The speed at which a CPU can carry out each step of the fetch-decode-execute cycle is called its Clock Speed.

  • This speed is measured in Hertz - a unit of frequency.

  • One Hertz means one cycle per second.

  • Given that it took me about 6 minutes to talk you through 4 instructions -- LOAD, LOAD,

  • ADD and STORE -- that means I have an effective clock speed of roughly .03 Hertz.

  • Admittedly, I’m not a great computer but even someone handy with math

  • might only be able to do one calculation in their head every second or 1 Hertz.

  • The very first, single-chip CPU was the Intel 4004, a 4-bit CPU released in 1971.

  • It’s microarchitecture is actually pretty similar to our example CPU.

  • Despite being the first processor of its kind, it had a mind-blowing clock speed of 740 Kilohertz

  • -- that’s 740 thousand cycles per second.

  • You might think that’s fast, but it’s nothing compared to the processors that we use today.

  • One megahertz is one million clock cycles per second, and the computer or even phone

  • that you are watching this video on right now is no doubt a few gigahertz -- that's

  • BILLIONs of CPU cycles everysingle... second.

  • Also, you may have heard of people overclocking their computers.

  • This is when you modify the clock to speed up the tempo of the CPU -- like when the drummer

  • speeds up when the Roman Galley needs to ram another ship.

  • Chip makers often design CPUs with enough tolerance to handle a little bit of overclocking,

  • but too much can either overheat the CPU, or produce gobbledygook as the signals fall behind the clock.

  • And although you don’t hear very much about underclocking, it’s actually super useful.

  • Sometimes it’s not necessary to run the processor at full speed...

  • maybe the user has stepped away, or just not running a particularly demanding program.

  • By slowing the CPU down, you can save a lot of power, which is important for computers

  • that run on batteries, like laptops and smartphones.

  • To meet these needs, many modern processors can increase or decrease their clock speed

  • based on demand, which is called dynamic frequency scaling.

  • So, with the addition of a clock, our CPU is complete.

  • We can now put a box around it, and make it its own component.

  • Yup.

  • A new level of abstraction!

  • RAM, as I showed you last episode, lies outside the CPU as its own component, and they communicate

  • with each other using address, data and enable wires.

  • Although the CPU we designed today is a simplified example, many of the basic mechanics we discussed

  • are still found in modern processors.

  • Next episode, were going to beef up our CPU, extending it with more instructions as

  • we take our first baby steps into software.

  • I’ll see you next week.

Hi, I’m Carrie Anne, this is Crash Course Computer Science, and today, were talking about processors.

字幕と単語

動画の操作 ここで「動画」の調整と「字幕」の表示を設定することができます

B1 中級

中央処理装置(CPU)のこと。クラッシュコース コンピュータサイエンス #7 (The Central Processing Unit (CPU): Crash Course Computer Science #7)

  • 114 9
    黃齡萱 に公開 2021 年 01 月 14 日
動画の中の単語