All language subtitles for subtitles-en (2)

Last week we described what the computer
that we're building in this course

is supposed to do.

This week we get to the more
difficult task of actually doing it.

Implementing a computer that can actually
do everything that we promised previously.

So let us recall the kinds of things that
we said that our computer is going to do.

The most amazing thing was that
one computer is able to run any

kind of program, any kind of software
that it is supposed to be able to get

instruction from the software and
then just execute it.

So we get a single machine that is
very flexible and can do everything.

That idea was called the universal Turing
machine, in the theoretical world.

And the architecture that actually
implements it is called the von Neumann

architecture.

And this is what we're
going to build today.

So, last week we were very happy
to get such an amazing device

to actually do whatever we tell it to do.

This week we're going to
have to pay the price, and

actually see how can you do such
an amazingly flexible thing.

So we're,
we already saw the general architecture

of how this can be implemented.

We are going to have a large piece
of memory that's going to be used

for two things.

First of all to store all the kind
of the data that we're going to use

in the computation but more interestingly
the memory will hold the program

a sequence of instructions that
are going to be executed one by one.

Beyond that, we're going to have the
central processing unit, which actually

carries out these instructions and
runs them and controls everything.

So let us now look more closely
how this actually happens,

how the central processing unit is built,
and how does all the controls back and

forth works, and this is what we're going
to describe in a general way this unit,

and later we'll actually talk much more
specifically about the computers that

we're building for this project.

So generally speaking,

our CPU is going to be composed of two
main ingredients, two main components.

One of them is what you often
call the arithmetic logic unit.

It's actually a piece of hardware that
actually is able to add numbers and

subtract numbers maybe do
logical operations and so on.

The second element is there are going to
be a bunch of registers, a bunch of places

where we can store data data that we're
going to use for the rest of computation.

So this is going to be basically
the core of the elements

that the CPU is built out of.

The memory itself,
as we said, has two parts,

the part that stores the program and
the part that stores the data.

To try to understand how all
these things work together,

it's best to actually consider
it as a flow of data,

what kind of information needs to pass
within the computers from side to side.

And this is what we're going
to actually now try to do.

Try to describe the various
pieces of information

that go from side to side in this
computer and how we control them.

So basically there are,
I would say three types of information

that's usually passed around the system,
and one of them is the data.

When we have a number
that needs to be added,

of course the number needs to be moved
from some, from one place to another,

from the data in memory to the registers,
to the actual other

systematic logic unit that's going
to do something with them, and back.

The second type of information
that we need to control is

what's called addresses.

What instruction are we
actually executing now?

What piece of data within the memory
do we need to access now?

These are in addresses.

And, of course, there is going to be a,

there is going to be a big bunch of
wires that actually do all the control.

That actually tell each part of the system
what to do at this particular point and

this is called the control.

Sometimes all these three pieces of the,
each one of these pieces of information is

actually going to be implemented by wires,
by a set of wires sometimes called a bus.

So we're going to have in a typical sys,
computer, we're going to have a data bus,

an address bus and sometimes the control
bit are called the control bus,

sometimes they're just
called control wires.

So let's look at the different pieces
that we have in our computer and

see exactly what kind of
information they get and emit.

Let us start with arithmetic logic unit.

This is a conceptually, the simplest and
clearest part of the CPU of our computer.

It basically needs to be
able to accept numbers.

And add them, subtract them.

Do some logical operations on them.

So it's very simple.

We need,
simply need to have some information from

the databus connect into the ALU.

And then information.

And then feeds the output
value back into the databus.

That's going to be a, and from there,
of course, it's going to have to go

to other places that also connect to the
databus, like the memory or the registers.

There is one other piece of infor,
plus other type of pieces of information

that ALB would, ALU will need to be
connected to, this is the control bus.

On one hand,

of course the ALU needs to know what
kind of operation it does every time.

So it has to reget information
from the control bus,

specifying the type of
operation that it does.

And on the other hand, according to
the results of the arithmetic or

logical operations that it does.

It's going to be able to,

have to be able to tell the other
parts of the system what to do.

For example, if it sees that a certain
number is greater then 0, that can control

the jump in the next instruction,
what the next instruction will be.

This control will happen
through the control bits.

So we're going to also have to get,
take some information from the ALU and

feed it back to control
the rest of the system.

Let us consider now with the registers.

The registers conceptually
are very simple.

Again, we store intermediate
results in the registers.

So we're going to be,
have to be able to take data in,

from the data bust into the registers and

then also take data's from the register
then feeds them back into the data bus.

And of course where would they go
from the data bus to other parts of

the system such, as the ALU.

So this is the first thing that
of course we will have to connect

all the registers to the data bus.

The second piece of information is,
sometimes,

as we've discussed previously, some
registers are used to specify addresses.

The way we actually achieve
indirect addressing into a RAM or

jump into a ROM address, the way we
do it is usually we put numbers,

addresses into a register and then that
specifies where we want to access.

So we're going to also have to
have registers control a connected

to the address bus which controls
again the memories, that,

which actually then feeds into the memory.

So that's a second type of
information we'll need to have.

We will [INAUDIBLE] have some
registers that are address registers,

either exclusively or
both address and data registers.

And these will need to
feed into the address bus.

The last piece of information,

the last piece that we need
to talk about is a memory.

So on one hand the memory needs,
we always need to specify what

address of the memory are we
going to be working with.

And that is specified of course by the
address method, that's the whole point.

And of course once we actually
work with a certain address,

we're going to be need
to be able to read it or

write into it, get information from it or
put information into it.

So of course the data, the input and

the output of the memory unit will have
to be connected to the, to the data bus.

Let us look slightly more clo,
closer inside.

There are two pieces to the memory,
there is a data memory and

there is a program memory.

Let's a lit, talk a little
bit about each part of these.

Looking at the data memory, eh, that,
what, it's going to need to get a,

an address of a data piece that
needs to be operated upon.

And of course, then very simply,
we need to write and read into it.

Looking at the other part which is the
program memory, where also we, if, we're

going to need to put the address of the
next program instruction into the, into

the program memory because this is where
we're taking our program instructions.

We need to be able to put an address
into the program memory address, and

then get the instructions from there.

Now the instructions that we get from the
program memory, both may have data in it.

For example, it may have numbers
that we need to add, and so on.

But, also it's an important thing,
is the program actually tells,

the program instruction tells
the rest of the system what to do.

So we need to be able to actually take
information from the next instruction,

from the data output
of the program memory.

And feed it into the control bus.

So that's another important piece
of information that we need to do,

another important connection that we
need to have inside the computer.

So, so far we talked about all
the different pieces inside the,

all the different components that
a computer is going to be composed of and

how they're connected to
each other versus in the,

in the, in the sense of which
information moves from where to where.

What we're going to do in the next unit,
is actually look more closely

at the innermost loop, the basic thing
that our hardware is supposed to do,

that is take an instruction from
the memory, from the program memory, and

actually execute it using the rest
of the system as appropriate.

That is called the fetch-execute cycle,
and will be the content of the next unit.