Get a clear, beginner-friendly dive into how your CPU works! This video explains the fetch-decode-execute cycle, the role of the clock, instruction pointer (RIP), and units like the ALU and cache. Learn why timing matters and how your CPU handles instructions step-by-step. Perfect for gamers, coders, or anyone curious about what makes computers tick. Inspired by Kip Irvine’s Assembly Language for x86 Processors, this is your gateway to understanding computer architecture. Subscribe for more tech insights and hit that QR code to explore more tutorials! #CPU #ComputerScience #TechTutorials
Introduction to CPU Operations 00:00:00
CPU Clock Explanation 00:00:17
Clock Cycle and Stability 00:01:07
Instruction Fetch from RAM 00:03:24
Instruction Pointer (RIP) Role 00:03:48
Sequential and Conditional Execution 00:04:49
Code Cache Functionality 00:06:24
Instruction Decoding Process 00:07:51
Control Unit Operations 00:08:33
Arithmetic Logic Unit (ALU) 00:08:52
Floating Point Unit 00:11:03
Data Cache Usage 00:12:08
Summary of CPU Process 00:14:36
Closing and Subscription Call 00:15:07
Thanks for watching!
Find us on other social media here:
- https://www.NeuralLantern.com/social
Please help support us!
- Subscribing + Sharing on Social Media
- Leaving a comment or suggestion
- Subscribing to our Blog
- Watching the main “pinned” video of this channel for offers and extras
CPU #ComputerScience #TechTutorials #ComputerArchitecture #AssemblyLanguage #TechExplained #CPUBasics #LearnTech #x86Processors #Coding
Hello there. Let’s talk about how your CPU fetches, decodes and executes instructions.
We’re going to just do a quick surface level overview, but I hope you like it.
Okay. So for starters, your CPU has something called the clock.
keep my pen onto one monitor here let me just double check that real fast
okay is it working yeah okay so
okay so notice how we have this line that goes up and down and up and down it kind of looks like a
little binary line uh it actually is uh sometimes your cpu is outputting a zero to this special
and it just oscillates between zero and one constantly it goes zero one zero one zero one
it does so very very very very fast and the reason it does that is because something needs to control
the timing of your cpu imagine this we kind of take this for granted but when you apply electricity
somewhere as a human you kind of feel like the electricity goes to the other place like on the
other side of your house or your room or whatever you kind of feel like it goes there instantaneously
really fast but in reality electricity doesn’t go faster than the speed of light so there is a limit
which means if you have a cpu that is executing instructions really really really really fast
you know fetching instructions from your system ram really really fast
there’s there’s there’s the problem of trying to um to know for sure that the electricity actually
made it uh to the other place in time uh so like what if we said let’s load some instructions from
load some instructions from memory, they come down the wire to your CPU.
How do we know when it actually finished coming down the wire to the CPU?
We just take it for granted.
But in reality, physics has a limit.
And so the electricity needs time to get there and it needs time to stabilize.
So the clock cycle helps us with that timing.
So, you know, if we make the clock go too fast, your CPU becomes unstable.
Your gamers, you gamers probably know that.
If we make it too slow, then it’ll work.
it’ll work, but, um, you know, we’re not getting the fastest, you know, CPU, uh, that, that
we, that we can, we’re not getting all the performance out of it that we can.
So we make it, we make the clock cycle go as fast as we can, uh, without making the
CPU, uh, instable.
And so just keep that in mind.
That’s one component of the CPU.
Okay.
So then the next thing I wanted to show you, oh, and by the way, let me give credit to
the authors of this book.
I’m just looking at a diagram, but, um, this book is written by someone named Kip
This book is written by someone named Kip Irvine
and it’s titled Assembly Language for X86 Processors.
It’s written by Pearson or it’s published by Pearson
and the year is 2014.
So get a copy of this book.
Anyway, so this is a simplified CPU block diagram.
Let me get my notes here real fast
so I don’t forget what I was supposed to say.
Clock ticks and alu.
Okay, so I guess that’s pretty much it.
Imagine now that we have a little RAM stick or some place where we can get instructions for the CPU.
So this is like system RAM, we’ll say.
And we’ll just pretend for the sake of argument that we already have existing circuitry
that will easily transfer data back and forth from the RAM stick to the CPU.
So anytime the CPU wants to grab some kind of data or like an instruction or something off the RAM stick,
it can just do it. And that’s the arrow right there.
keep in mind after that is that there is a special register in the CPU called the instruction pointer
RIP in x86-64 assembly the RIP register and the RIP register it basically just holds a memory
location telling the CPU where is the next where’s the address of the next instruction that we want
to execute so you know imagine you have like some kind of memory address 0x I don’t know 55 and then
an instruction on the very next actually let’s do five zero so I can increase this by eight without
doing hex in my head we’ll say this is like the address five zero in hexadecimal so that means
that the next time the CPU wants to execute an instruction it’s just going to ask system ram
for that address system ram is going to give it whatever ones and zeros it has and then it can be
decoded and executed after that and then of course we have to execute a program you know step by step
you know step by step we have to execute more instructions and we can’t just do one instruction
so typically in a program you execute instructions one by one by one by one by one
and then every once in a while there might be some decision logic like you have an if else
branch like let’s say uh you know for the for the high level people i’ll put a question mark here
you have like an if statement and you say like if that’s true then execute this i’ll put maybe i’ll
then we’ll just execute this other logic down here. So you know very often we execute instructions
sequentially but every once in a while we have to jump right because if if you executed this
if statement and you realized that this condition was not true then you could not execute the body
that came right after the comparison instructions you would have to jump down to wherever the else
block is so there is circuitry inside of the CPU that allows you to either increase the instruction
instruction pointer by 8 bytes, 8 bytes because 64 bits per instruction because that’s your CPU.
So you just kind of go sequentially or to jump somewhere because you made a decision or you’re
like making a function call or whatever. So just keep in mind that under the hood, under this
diagram, there is a lot more logic even than the more detailed diagrams that you can find elsewhere.
There’s just like a lot more detail. So anyway, the RIP register just kind of increases by 8
every time we execute an instruction,
sometimes it’ll drastically change its address
so we can jump execution somewhere else
in order to make a decision.
So just keep that in mind.
So suppose that we just fetched an instruction from memory.
You know, it comes in here
and we kind of send it down the line.
We first give it to the code cache unit.
Your CPU is just not a solid block of stuff.
It’s got subunits inside of it.
And one of these units is the code cache unit.
it’s a lot more complicated than what you’re seeing here but basically
system ram is very slow dealing with the cpu internally is very very very fast in comparison
so if we have like a register or some unit that we’re accessing that’s inside of the cpu it’s
lightning fast compared to accessing the memory so that means cpus have caches which just i’m not
going to go too much into caches for this video but basically every time we get a new instruction
we might put it into the cache, which is like incredibly fast because it’s hardware that’s part
of the CPU. Then maybe sometime in the future, we might want to execute the same exact instruction
at the same exact address. Again, that’s possible. Remember we have loops. We can execute the same
instructions a bunch of times in a row. So if we come across an instruction that we have executed
in the past and it’s already in the code cache, then we don’t actually need to wait for memory
to fetch the instruction for us, we can just go directly to the code cache and it’s a dramatic
speed up.
Remember, when you access memory, execution has to stall for quite a long time usually
or sometimes.
Okay, so that’s what the code cache does.
Once the memory and the code cache have figured out, okay, we got the instruction and everything’s
good, then we just sort of decode the instruction.
We decide, you know, what is in the instruction?
it all like data or is it all like like is it half and half and part instruction
part data part whatever there’s lots of different formats for instructions so
the instruction decoder just sort of like you know decides how to separate
it and it sends data into the control unit notice how there’s a little arrow
pointing from the instruction decoder to the instruction pointer so we could use
that information to decide how to modify the RIP register like if we’re gonna go
or if we’re going to jump somewhere.
And then the, let’s see,
when we send the instruction to the control unit,
the control unit is not necessarily the brain
because the whole CPU is the brain of the computer,
but the control unit is kind of like the decider of the CPU.
At least that’s the way I see it.
It decides what to do.
There’s a lot of other subunits in the CPU.
Notice how down here we have, you know, CPU registers
and we also have the all you.
the all you the all you is basically the arithmetic logical unit so it’s it’s a little subunit that
will execute mathematical instructions or logical instructions like it’ll take some bits and it’ll
it’ll move them to the left or the right or it’ll flip the bits or whatever or it’ll add two numbers
together the registers you know they’re very very very fast they’re like you know the variables of
the cpu um so the control unit will examine uh whatever it’s getting and it’ll decide all right
want us to do it wants us to add two integers together or it wants us to
write something to memory or it wants us to do whatever right so when
the control unit receives input remember this is all just like ones and zeros
right so imagine if we had like a bunch of ones and zeros coming in and they’re
just wired directly into the control unit right so then the control unit has
its own internal circuitry that that makes it so well if I receive this
going to tell everybody else to add numbers together and if I see some other number I’m
going to tell everybody else to multiply numbers together so the control unit is really responsible
for deciding what the other units need to do in order to accomplish the current instruction
so gosh I really need to fix this I just reconfigured this thing and now it’s just like
drawing even when I don’t want it to draw so the control unit let’s say that we do that we have
that we have like an addition instruction we want to add two registers together the control unit will
send this down the wire to let the all you unit know that it needs to perform addition the all
you unit also has inputs and based on what it receives it will decide to do something it’ll
decide to add or subtract or multiply or just whatever so the control unit sends the right
input into the all you unit so that it knows to add or do whatever we wanted it to do
operands like it might receive data that just came from memory it might receive registers it might
receive just like a raw immediate number that’s embedded into the instruction on the other hand
we might also send something into the floating point unit so the control unit it’s always sending
all of these signals to all of its you know connected units these wires it’s not like we
can remove these wires so there’s always something even if it’s a zero going down the line
so the control unit will basically send the right signals down to the all you to tell it you’re
going to add and it’ll send the right signals down to the floating point unit to say you’re
not going to do anything or just we’re not we’re going to ignore the result there’s like all these
logical gates that we’re not showing on this diagram where we can just like ignore the output
result of some unit that we’re not going to use so it’s sending all these signals to these units
Just like a quick note here, the all you only deals with integer math and, you know, bitwise
logical operations.
Floating point numbers in the machine are stored totally differently than integers.
So we need a totally different unit in order to process them.
So that’s why there are two units there.
Well, I mean, I guess depending on, you know, what CPU we’re talking about, but like as
far as the ones that I’m aware of and that I use.
So then, you know, the data cache, kind of the same thing.
kind of the same thing um you know there’s like a code cache up here and a data cache down there
so sometimes we might want to fetch data that we’ve already fetched before and we don’t want
to hit system ram so you know we don’t want that slow down so we’ll just take it from the cache
and um we will also populate the cache when we have a result so when this like all you is done
adding whatever it’s going to add it’ll send its result data to the data cache and then um
two or three or whatever then we can reuse the result in another instruction or send it back to
memory or do whatever we want to so this is like a basic idea right like you you start off by you
know grabbing something from memory possibly if it’s already in the cache then you wouldn’t
actually grab it and then the instruction decoder decides you know are we gonna we’re gonna jump
are we gonna go to the next instruction after this is over so it’ll have the next address
notice how there’s kind of like a little cycle that goes here between code cache instruction
decoder and instruction pointer and so you know we’re always kind of deciding what’s the next
instruction that we’re going to execute and then we like you know send the decoded instruction to
the control unit the control unit decides you know are you going to do some addition are we
going to use registers or not and then you know like are you not going to do anything or are maybe
you are going to do something in this case I’m just saying the floating point won’t do anything
integers. And then once that is all processed, you know, it comes to the data cache and, um,
well, we can, we can basically just, uh, you know, write it back to memory. I think this
diagram is not showing an arrow that will write it, write it back to memory. Um,
yeah, the code cache is definitely not going to feed directly into memory. That’s just a cache,
but you know, so, so imagine like there’s a, there’s like another wire here that goes
so when we have a result we can just write it into system ram
let me see if i forgot to say anything rip
yeah that’s basically all i wanted to say okay so now you have a fairly good idea of at least
one level deeper of what’s going on inside of your computer how the cpu in a general way loads
and all these little subunits getting told what to do
and the results getting piped back to the instruction pointer
and also to system RAM and so forth.
And it just keeps going like this again and again and again.
And also just remember that at certain points
during even one cycle, we wait for a clock tick.
I’m not gonna say exactly when we wait
because it’s kind of specific to what’s going on
to be on the scope of this video.
But yeah, the clock speed controls
how fast these cycles go.
And there’s much more advanced stuff
And there’s much more advanced stuff that you could learn later,
like pipelining and such to increase efficiency.
But this is a basic idea of how your computer works.
I hope you enjoyed this video.
I hope you learned a little bit of stuff and had a little bit of fun.
I’ll see you in the next video.
Hey, everybody.
Thanks for watching this video again from the bottom of my heart.
I really appreciate it.
I do hope you did learn something and have some fun.
If you could do me a please, a small little favor,
Could you please subscribe and follow this channel or these videos or whatever it is you do on the current social media
Website that you’re looking at right now
It would really mean the world to me and it’ll help make more videos and grow this community
So we’ll be able to do more videos longer videos better videos or just I’ll be able to keep making videos in general
So please do do me a kindness and and subscribe
You know sometimes I’m sleeping in the middle of the night and I just wake up because I know somebody subscribed or followed
subscribed or followed it just wakes me up and I get filled with joy that’s
exactly what happens every single time so you could do it as a nice favor to me
or you could you control me if you want to just wake me up in the middle of the
night just subscribe and then I’ll just wake up I promise that’s what will
happen also if you look at the middle of the screen right now you should see a QR
code which you can scan in order to go to the website which I think is also
named somewhere at the bottom of this video and it’ll take you to my main
website where you can just kind of like see all the videos I published and the
all the videos i published and the services and tutorials and things that i offer and all that
good stuff and uh if you have a suggestion for uh uh clarifications or errata or just future videos
that you want to see please leave a comment or if you just want to say hey what’s up what’s going on
you know just send me a comment whatever i also wake up for those in the middle of the night i
get i wake up in a cold sweat and i’m like it would really it really mean the world to me i
really appreciate it. So again, thank you so much for watching this video and enjoy the cool music
as I fade into the darkness, which is coming for us all.
Thank you.
