Instructor: In this lesson,
we're going to talk about CPU architectures.
Now, the CPU or central processing unit,
which is normally just referred to as the processor,
is the device that's going to be the brains of your computer
and it's used to execute the different program code
that exists within your software or firmware.
This tells the computer exactly how to do its job
for whatever type of function you want to do.
Essentially, the CPU is going to perform the basic operations
on each and every instruction.
The CPU is first going to fetch that instruction,
take the next instruction in the sequence
from the system memory
or the cache inside of the processor,
which is essentially a very high-speed type of memory.
Then, the control unit or processor
is going to be able to decode each of those instructions
and then either execute it
or pass it on to a secondary unit
that's going to help it do that process.
For example, in a lot of processors,
there are things like a floating point unit
or an arithmetic logic unit,
and these can be used to do different instructions
based on the type of code
and the type of instruction being run.
Then, once the processor is done
doing the execution of that instruction,
it's going to send that information back to the register,
cache, or memory, so that it can be stored
and used later on by the system
later on during the program
or present its output to the user
for them to be able to take action on.
This is the basic way that processors work
in the motherboard and inside of your computer.
Now, as we look at the processor itself,
it has its own architecture.
And similar to the way that the motherboard
has a form factor that defines what it can do,
the processor's architecture is going to define
what capabilities that processor has.
There are three main architectures
that you're going to come across
in the field as a technician.
The first one is known as X86.
Now, X86 is also sometimes called the IA-32
or Intel architecture 32-bit instruction set.
This is because X86 was originally developed by Intel
with some of the first PCs
all the way back in the 1970s and 1980s.
Over time, computers went from being 8-bit,
to 16-bit, to 32-bit, and all along the way,
Intel created this backwards compatibility
and all of those systems
became known as this X86 generation of processors.
And this is because the first processors
used in computers by Intel
was called the 8086 series.
And the next one became the 286 series,
then 386, then 486, then 586,
and then at that point
they shifted over to using brand names,
things like Celeron or Pentium, and things like that.
Either way, though, all of these devices
originally were X86 processors,
and it kept that way all the way up
until we got to 64-bit processors.
Once we moved into a 64-bit processor,
we started calling this an X64 processor
or X64 architecture.
Now, anytime you see X64 as the instruction set,
this means that we have now extended the X86
or 32-bit instruction set
to be able to support 64-bit operations.
This is an important thing to understand
because when you're dealing with 32-bit processors,
which are X86 processors,
they can only support a maximum amount of memory
of four gigabytes of RAM.
They physically cannot address
anything higher than four gigabytes
because there's only 32 bits available for addressing.
And if you take 2 to the 32nd power,
you get about 4 billion bits,
which is about four gigabytes.
So you can see why it was important for us
to move beyond the X86 processor
because four gigabytes of RAM
is really not a lot in modern systems.
In fact, that would be considered
a very low memory system these days.
Most computers are going to have 8, 16, 32,
or even 64 gigabytes of RAM
as their main system memory.
And to be able to address all of that,
you need to move into a 64-bit instruction set
using an X64 processor.
Oftentimes, you'll hear this referred to
based on their brand name, either AMD64 or Intel 64,
depending on which model is being made
by which manufacturer.
But they are both considered X64-based architectures
for that particular processor.
Now, another important thing to remember
when it comes to 64-bit versus 32-bit
is the fact that 32-bit systems
can only run 32-bit programs
but 64-bit processors can run 64-bit programs
and 32-bit programs
because they are fully backwards compatible.
For this reason,
most systems you're going to come across these days
are going to be X64-based processors
because that is heavily used in the PC market
and supported widely by Windows and all of its variants.
Now, the third type of processor you may come across
is what's known as an ARM processor.
ARM stands for the advanced RISC machines
and RISC is actually an acronym itself,
that's spelled R-I-S-C,
which is the reduced instruction set computer.
Now, ARM for a long time was used
for low-power devices,
things like tablets and cell phones and things like that.
But back in the early 2020s,
Apple decided to release a new series of processors
for their desktops and laptops
that used ARM chips as well
and these are known as the M1 series,
the M1 Pro, the M1 Max,
and now the newer ones are coming out
with the M2 series and beyond.
All of these are now being moved
into this ARM instruction set
because ARM allows you to do some very special things
that you can't do in an X86 or X64-based processor.
The most important of these
is actually extended battery life.
ARM actually produces a lot less heat
to be able to do all of the same calculations
as an X64 or X86-based processor,
and this actually saves a lot of battery power
and a lot of cooling.
So it's very popular in system on a chip configurations,
things like smart TVs, smart speakers,
and other devices as well as newer laptops.
And so when you're using something
that is not Windows-based,
such as an Apple device, a Chromebook,
or even an Android phone or tablet,
these tend to use ARM-based processors
instead of X64 or X86
because of its longer battery life
and lower power consumption
that creates less heat inside of the device.
Now, when you look at a RISC-based or ARM-based processor
versus an X64 or X86-based processor,
you are dealing with this reduced instruction set
instead of a full complex instruction set.
Now you may think this actually gives you less capability
but it doesn't.
When you're using a RISC-based system,
these RISC systems use a smaller number of instructions
to be able to do all the same task
but they rely more on code to be able to do it.
This allows each piece of code inside of that RISC
to do more things with less code
and this causes less consumption of power
and longer battery life.
As we continue to evolve in computers,
you're going to see that RISC and ARM-based processors
are going to become more popular
in a wide variety of systems
including desktops and laptops.
And this is already starting to make its way
into the Windows environment
as they are now starting to offer Windows 11 versions
that will support an ARM-based processor.
Once that goes out of beta and into general production,
we're going to see a larger amount of desktops and laptops
using ARM beyond just using them for Apple systems.