This is a certificate from the Guinness World Records.
It's for the largest functional microprocessor model
which has 42,370 transistors
and built by James Newman in the UK in Cambridge.
And this is the mega processor.
It's basically a micro processor
made purely from transistors.
And we're talking discrete transistors,
the ones the ones that you can handle,
not sort of the ones that are
in the silicon chips we know.
So it's a fully functional machine.
It's made of these panels as you see
around the room here.
Each panel has its own
specific function within the processor.
So the memory is made of all these
little transistors here, as the rest is,
but each one has an LED on it as well.
So the important thing about the mega processor
is every single part of the machine,
every single gate
has an LED on its input and output,
so you can see all the data everywhere in the machine,
and actually how it's working as well.
The memory actually kind of then functions
a little bit more as a screen.
So we have here a game of Tetris
that's playing on there at the moment,
we'll show you that in a minute.
So we have the state machine,
all computers have a state machine
so it knows what it's doing at any one given time.
All of the instruction decoding
and the branch calculations, all that kind of thing,
are done on these ones here.
This panel is the special purpose registers.
Arithmetic and logic control, the ALU,
again the ALU part of all processors.
So it has two "adders" in this machine
adder 1, adder 2 there.
And then the ALU control down the bottom.
General purpose registers, so as you make a move
you would move it to register one,
and then out to maybe a special purpose register
or memory depending on
what operations you're doing.
So all of this together
forms effectively a microprocessor.
So we have a number of LEDs okay,
and you can see these LEDs are on.
But if we focus in on just one little bit here,
those five transistors make it an AND gate.
So all of that lot is just one AND gate.
And we can see on the two inputs to the AND
we have one is on, one is off, the output is off.
So for an AND gate the logic says:
both inputs 1 and 2 have to be on.
Okay, so that's the function,
so we haven't, we've only got one of them on
therefore the output is off.
And this is just multiplied up.
The whole system is using this kind of function.
AND gates, OR gates, and XORs
and various then combination of those.
You can use,
turn an AND gate into an inverter
which some of them are done down there.
And a microprocessor is just that.
What we've got here is a machine
that looks like it's not doing very much,
it's kind of fairly static.
But we have a special control over here,
a huge rheostat out of some kind of 40's science film.
What we can do,
it's actually running at about 19 kilohertz at the minute.
But we can slow it down.
13 ... 10 ... 7 kilohertz.
And as we slow it down
we start to see
the LEDs
flickering a little bit.
There's a little bit of flicker.
So now we're at about 100 hertz
and as we come down further ...
10 Hertz ...
Right. And now we're down at about roughly 2 hertz.
So now we can start to see
the individual instructions being operated.
So again,
it's running Tetris at the moment.
It's actually in it's "Game Over" state.
So at first the machine looked like
it wasn't doing anything.
But when we slow it down
we see actually it is doing something.
And one of our special purpose registers
is the "Program Counter".
So this is the part of the machine
that keeps track of what instruction is being executed.
[Sean] That's the PC there yeah? [Jason] Yeah, "Program Counter".
What we've got,
we've got the binary:
this is what's going on to the computer itself.
But for us we've got a little display here
that allows us to interpret that a little bit easier.
So we can see that the instructions
at memory locations 131 to 137
are just going round and round in a loop.
So even though the machine
looked like it was doing nothing,
it's running this little program
between 131 and 137.
And what that's saying
is ...
check out
the peripheral input,
the inputs here.
So between 131 and 137
it's just basically saying,
"Is that button pressed?"
So it just sits there in that loop.
If I speed up a little bit
and I now press that button,
our program counter now shoots off.
Let's slow it down again.
So now we're in a different part of memory
doing another operation.
And you can see on the screen,
so if I speed up the operations now,
You can see that it's basically
very very slowly clearing the screen.
So the part of the program
that is operating at the moment
is just the "clear screen" operation.
And I could speed that up,
take it up to ...
[Sean] And now it's playing the game again.
[Jason] And now it's playing the game again.
But again slowing it down,
you can see just how long it takes to draw
and calculate those pieces.
So to update the screen
there is a whole load of code that's being operated
just to move that piece down the screen.
And then we can speed it up, and now
we have a kind of a functional game.
It is going to slow obviously
it's not very playable.
And it can look at the inputs.
And you can see how the controller here,
as we move it,
changes the LEDs.
You've got the two inputs there.
The button presses cause other
inputs, and it is watching those all the time.
James Newman, the madman that created it,
really wanted to be able to
shrink people down put them inside a computer
just to be able to see how it works.
That's really hard
apparently.
So
he scaled up the processor,
so allowed us to get inside, it as it were.
So the idea is here,
that this is an educational thing.
This is the best way for anybody
to understand things, simple stuff like
the "fetch and execute cycle" of a computer.
How this stuff works.
So this is fantastic because what it allows us to do,
if we halt the machine,
we can now
stop the processor
and we can single step through
every
instruction.
So every time we press
the step button,
we can now see
the operations and the data
moving around the system.
[Sean] I'm just going to darken the camera
so we can see the LEDs now
but we might not see you.
[Jason] And it's not necessarily
one press per instruction.
Some of these instructions take
a number of clock cycles to operate.
So a "divide" could take 16 clock cycles
other instructions take less time.
But we can see how that instruction is broken up.
Step it through
just to see
how that data moves around the processor.
You can't do that in any other way.
There is no way to get inside a processor
and see this stuff happen.
I programmed in assembly language
on 8031 processors and things like that,
and I thought I was fairly low level,
you know "programming at the metal" as they say.
But actually when you see these things being executed
you realize how much extra stuff is going on
that even you as a sort of a low-level coder
don't even, you're not even aware of it.
And it's ...
these things work so hard
to do the,
what seems simple stuff.
[Sean] I'm imagining this is a processor
in some smartphone somewhere.
How big do you think the screen would be?
[Jason] um ... ah ... that's ...
okay, so that's an interesting question.
If this was the memory
that you had in your mobile phone today,
the average mobile phone
with
say, I don't know,
a gig of RAM,
this panel
as the RAM
would be twice the size of the United Kingdom.
So it's fairly low density
and fairly impractical.
But,
you know,
you can't see what's going on in your mobile phone.
So ...
But
actually,
what we should say
that a lot of people just assume
this is something like a model of a 6502
or a Z80 processor from the 80's.
It's not actually necessarily based on any one processor.
it kind of
uses good ideas from a number of different processors.
So for a start it has
"hardware divide" built in.
It's actually a 16-bit machine as well.
So,
really it's kind of a ...
I don't know, it's hard to equate it.
But it's kind of a mid 90's-ish,
or early 90's maybe,
kind of equivalent processor.
So it's really
quite a quite a beast
when you consider this thing is all just transistors.
[ ambient music fades in ... ]