Instruction Sets - Brief History of Computer Evolution Video Lecture -

roughly this time last year we spend an
extended period of time taking a look at
logic components while we went to great
depth looking at individual components
and understanding how they worked we
never really thought about you know how
to move things one level up and that is
how these components will come together
to actually make the processor in your
computer today we're going to move that
one step up to take a look at what is
known as an instruction set architecture
or is a four-shot we're gonna try and
understand the purpose as well as the
implementation of an instruction set and
we'll try and see why it's necessary
we've got a long episode ahead of us so
without further ado let us jump right in
after the break so instruction sets
first of all why do we even need them
what is their purpose you see here's a D
when you are programming for a computer
you would probably not like to write
your program entirely in terms of the
language of logic that is your program
can only consist of things like and or
and not you know that would be very
inconvenient not to mention very hard to
read instead we're trying to express our
programs in a manner that is easier to
understand at a higher level that
basically allows us to step away from
the logic implementation throughout the
logic component series you would have
seen an atom of course it will be easy
to refer to it as simply you know a
component that does addition as opposed
to having the thing of it in terms of
its individual components the concept is
exactly the same and this that of
abstraction Mosiah
is allow you to work with a cpu as well
as its components using simple
instructions these instructions are
simply bit strings and inside them we
encode several crucial pieces of
information each instruction must
contain an opcode and this opcode
basically tells the CPU what
exactly you're trying to execute apart
from the opcode the rest of the
instruction contains information about
basically what the instruction is
supposed to work on so we can point it
to which registers you can give it
values for it to work on you know things
like that this instruction is then
passed off to some part of the CPU which
translates it it will probably look at
the up code and try to figure out what
it is you want to do and then it will
fire off the necessary component to do
the job at this point here is an
interesting fact that it's worth
pointing out the instruction itself
doesn't actually say anything about you
know which components are in charge of
doing what the implementation is
separate from the instruction so in fact
when you have say an Intel processor
versus and AMD processor they can both
implement the x86 instruction set what
this means is both these processors
understand the same instructions however
their implementation that is the actual
logic circuits laid out on the CPU can
be completely different it doesn't
matter as long as at the end of the day
it understands the same instructions and
it gives you the same results and that
right there is one level of abstraction
you're basically separating the
instructions from the implementation as
long as the instruction is translated
correctly well things will work as you'd
expect so what we've done so far is
we've looked at is s
as well as the individual instructions
we almost know enough to actually look
at some examples of an ISA in action but
not just yet I do have to fill you in on
two little things first and foremost is
how code is actually stopped you see
every instruction is a bit string and
what this means is it simply occupies
some space in memory and if you have
multiple instructions which most
programs do what you can do is you can
just line up these instructions in
consecutive areas of memory you can
imagine each one of these pigeonholes to
have an
address and this address is extremely
important because that is what we're
going to be using to basically refer to
the individual instructions we need to
know where the instructions are and that
will help us to actually jump back and
forth if we ever need to do so so that's
one of the two concepts the other is the
concept of a register you see when your
CPU is working even with just an
individual instruction it may need to
temporarily hold some information in
some places a register helps it do just
that registers are basically very small
amounts of memory normally they just
hold one number or one address and if
any calculations or any instructions are
me then the register value could be used
or changed so yeah think of a register
is just a temporary holding area for one
number or one address alright having
come this far it is now time to actually
look at several example instructions for
this purpose we'll look at the MIPS is a
it's not an extremely common use but its
relative simplicity makes it a good
educational tool I used it in school
myself and it wasn't very hard to pick
up MIPS instructions are 32 bits in
length and there are three different
instruction types what this means is
there are actually three different ways
in which we can divide up the 32 bits
they are known as CR I and J type
instructions we'll look at this in
greater detail over several examples all
you need to take note off at this point
is the fact that the first six bits
always refers to the opcode that is in
fact how mips knows how to tell apart
the different types of instructions
different op codes are associated with
different instruction types so mips just
needs to look at the opcode and you'll
know whether that instruction is an r
type I type or J type so knowing that
let us move on to the first type of the
instruction and that is EJ type
instruction now J type instructions are
the simplest they're simply jumps and
the first six bits refer to the opcode
the remaining 26 bits simply specify the
address in which you jump to so nothing
very complicated let's step it up a
little with our second example which
looks at the I type the I type basically
stands for instructions containing an
immediate value to understand what this
means
let us take a look at an example this is
the add immediate instruction of course
as usual the first 6 bits ie opcode and
this OP code tells MIPS you want to
perform the add immediate instruction
the next 5 bits actually specify a
source register so this is why the
concept of registers come in when we
reference a register like this admits
what we're saying is we want to use the
value contained within that register the
next five bits refer to the target
register and what this means is after
you've performed the addition you want
to write the answer or the result of the
operation to that target register the
remaining 16 bits basically is the
amount you want to add to that
particular register so what this means
is this instruction in general basically
says take the value from the source
register add this value to it and write
the answer to the target register and
that is the add immediate instruction so
this should meet the definition of the
term immediate quite clip you have an
immediate value here it doesn't refer to
any register you just want to use the
number here verbatim for our calculation
and that is what MIPS defines as
immediate so that is an I type
instruction still pretty straightforward
as long as you know where to break down
you know the individual bits and you
know what they mean well you'll be able
to understand what the operation is
trying to do next up is the R type
instruction in an interest of time we
will not be taking a very in-depth look
at this I just want to draw attention to
a pretty neat trick used by MIPS and
potentially other ISAs as well up codes
in MIPS as six bits
what this means is MIPS can cater for
two to the power of six or 64
instructions now what if you need more
instructions adding more bits to the
opcode may not be the best solution for
example if we want to make all
instructions and MIPS take on seven bit
up codes we will have to sacrifice one
bit in the add immediate instruction
limiting the extent of our addition
instead the ingenious workaround for
this is to add a set of function bits to
all the are type instructions in fact
all are type instructions have the same
opcode however the function bits at the
end change to reflect the different type
of operation requested this increases
the maximum number of MIPS instructions
from 64 to 127 and they have it
basically we've taken a very close look
both edit concepts off and highest a as
well as an implementation of an is a and
what can be done to make it you know
basically work and some tricks in which
you can actually make it do more now
here's some further information to make
your understanding even more complete
first and foremost of course writing
instructions like this is still not a
very good way of you know coding in
general I mean you're gonna have to
figure out the instructions you're gonna
have to write out actual bit strings and
that's going to be very tedious and very
easy to get wrong that's why we have
what is known as assembly language
instead of writing out the individual
instructions you know specifying the
opcode specifying all the registers you
can also write assembly language for
example instead of looking at the pitch
strength that is basically the opcode
for the add immediate instruction you
can simply write add I can then specify
the target and destination registers in
a friendly manner as well as the
immediate value when you actually
compile your assembly language program
all the compiler needs to do is to
understand that instruction and convert
it to a bit string it also needs to
understand all the registers
the immediate values you've specified
and convert those to bitch strings as
well so in this case it is basically a
one-to-one mapping you just translate
whatever there is there into a series of
bit strings and these can then be
executed by a mips compliant processor
this have caused far more intuitive than
writing bitch strings but there is still
not very intuitive and that is why we
have programming languages which are
even higher level abstractions of an
assembly language when you write code in
a language like C or C++ they're
actually compiled to an intermediate
assembly language state that assembly
language state is then compiled again
down to machine code so in fact the
levels of abstraction are levels of
compilation as well of course these
aren't MIPS instructions because I've
compiled them on my own computer they're
actually x86 instructions of course this
gets compiled further into actual bit
strings of course if we're to open that
we wouldn't be able to understand that's
because well it's machine code these are
in fact bit strings that are pushed
directly to the processor and processor
can then execute these bit strings and
then have it that is the concept of is s
and Raval so taking a look at how
abstraction helps us in this particular
regard and that basically wraps up this
topic of course this video ran a little
long it's hard to you know describe all
these things without going into the
in-depth examples but I really hope
you've gained some insights in this
particular episode but yeah that's all I
have to tell you about is is hopefully
I've made things clear if you have any
queries of course feel free to leave a
comment but that's it thank you very
much for watching you're watching zero
six one two TV thank you very much for
watching if you like this video consider
checking out the rest of my work on my
channel alternatively you may be
interested in a playlist of my earlier
work on computing and computer science
topics if you'd like to show me some
monetary support I am on patreon you can
find a link to
campaign in the video description of
course you can simply like this video or
leave a comment I'll be sure to respond
as soon as I can to keep in touch with
my future uploads do subscribe to this
channel and for even more updates check
out the official Twitter account for
this channel at 0 6 1 2 TV thank you for
your support