How Computers Calculate - the ALU: Crash Course Computer Science #5 Video Lecture | Introduction to Computer Science: An Overview - Software Development

Hi, I’m Carrie Ann and this is Crash Course Computer Science.
So last episode, we talked about how numbers can be represented in binary.
Representing
Like, 00101010 is 42 in decimal.
Representing and storing numbers is an important function of a computer, but the real goal is computation,
or manipulating numbers in a structured and purposeful way, like adding two numbers together.
These operations are handled by a computer’s Arithmetic and Logic Unit,
but most people call it by its street name: the ALU.
The ALU is the mathematical brain of a computer.
When you understand an ALU’s design and function, you’ll understand a fundamental
part of modern computers. It is THE thing
that does all of the computation in a computer,
so basically everything uses it.
First though, look at this beauty.
This is perhaps the most famous ALU ever, the Intel 74181.
When it was released in 1970, it was
It was the first complete ALU that fit entirely inside of a single chip -
Which was a huge engineering feat at the time.
So today we’re going to take those Boolean logic gates we learned about last week
to build a simple ALU circuit with much of the same functionality as the 74181.
And over the next few episodes we’ll use
this to construct a computer from scratch. So it’s going to get a little bit complicated,
but I think you guys can handle it.
INTRO
An ALU is really two units in one -- there’s
an arithmetic unit and a logic unit.
Let's start with the arithmetic unit, which is responsible for handling all numerical operations in a
computer, like addition and subtraction. It
also does a bunch of other simple things like
add one to a number, which is called an increment operation, but we’ll talk about those later.
Today, we’re going to focus on the pièce de résistance, the crème de la crème of
operations that underlies almost everything else a computer does - adding two numbers together.
We could build this circuit entirely out of
individual transistors, but that would get
confusing really fast.
So instead as we talked about in Episode 3 – we can use a high-level of abstraction and build our components
out of logic gates, in this case: AND, OR,
NOT and XOR gates.
The simplest adding circuit that we can build takes two binary digits, and adds them together.
So we have two inputs, A and B, and one output, which is the sum of those two digits.
Just to clarify: A, B and the output are all single bits.
There are only four possible input combinations.
The first three are:
0+0 = 0
1+0 = 1
0+1 = 1
Remember that in binary, 1 is the same as
true, and 0 is the same as false.
So this set of inputs exactly matches the boolean logic of an XOR gate, and we can use it as
our 1-bit adder.
But the fourth input combination, 1 + 1,
is a special case. 1 + 1 is 2 (obviously)
but there’s no 2 digit in binary, so as we talked about last episode, the result is
0 and the 1 is carried to the next column. So the sum is really 10 in binary.
Now, the output of our XOR gate is partially correct - 1 plus 1, outputs 0.
But, we need an extra output wire for that carry bit.
The carry bit is only “true” when the inputs are 1 AND 1, because that's the only
time when the result (two) is bigger than
1 bit can store… and conveniently we have
a gate for that! An AND gate, which is
only true when both inputs are true, so
we’ll add that to our circuit too.
And that's it. This circuit is called a half adder. It’s
It's not that complicated - just two logic gates - but let’s abstract away even this level
of detail and encapsulate our newly minted half adder as its own component, with two
inputs - bits A and B - and two outputs, the sum and the carry bits.
This takes us to another level of abstraction… heh… I feel like I say that a lot.
I wonder if this is going to become a thing.
Anyway, If you want to add more than 1 + 1
we’re going to need a “Full Adder.” That half-adder left us with a carry bit as output.
That means that when we move
on to the next column in a multi-column addition,
and every column after that, we are going to have to add three bits together, no two.
A full adder is a bit more complicated - it
takes three bits as inputs: A, B and C. So
the maximum possible input is 1 + 1 + 1,
which equals 1 carry out 1, so we still
only need two output wires: sum and carry.
We can build a full adder using half adders. To do this, we use a half adder to add A plus B
just like before – but then feed that
result and input C into a second half adder.
Lastly, we need a OR gate to check if either one of the carry bits was true.
That’s it, we just made a full adder! Again,we can go up a level of abstraction and wrap
up this full adder as its own component. It
takes three inputs, adds them, and outputs
the sum and the carry, if there is one.
Armed with our new components, we can now build a circuit that takes two, 8-bit numbers
– Let’s call them A and B – and adds them together.
Let’s start with the very first bit of
A and B, which we’ll call A0 and B0. At
this point, there is no carry bit to deal
with, because this is our first addition.
So we can use our half adder to add these
two bits together. The output is sum0.
Now we want to add A1 and B1 together.
It's possible there was a carry from the previous addition of A0 and B0, so this time we need
to use a full adder that also inputs the carry
bit. We output this result as sum1.
Then, we take any carry from this full adder, and run it into the next full adder that handles
A2 and B2. And we just keep doing this in
a big chain until all 8 bits have been added.
Notice how the carry bits ripple forward to
each subsequent adder. For this reason,
this is called an 8-bit ripple carry adder. Notice how our last full adder has a carry out.
If there is a carry into the 9th bit, it means the sum of the two numbers is too large to fit into 8-bits.
This is called an overflow.
In general, an overflow occurs when the result of an addition is too large to be represented by the number of bits you are using.
This can usually cause errors and unexpected behavior.
Famously, the original PacMan arcade game used 8 bits to keep track of what level you were on.
This meant that if you made it past level 255 – the largest number storablein 8 bits –
to level 256, the ALU overflowed.
This caused a bunch of errors and glitches making the level unbeatable.
The bug became a rite of passage for the greatest PacMan players.
So if we want to avoid overflows, we can extend our circuit with more full adders, allowing
us to add 16 or 32 bit numbers. This makes overflows less likely to happen, but at the
expense of more gates. An additional downside is that it takes a little bit of time for
each of the carries to ripple forward.
Admittedly, not very much time, electrons move pretty fast, so we’re talking about billionths of a second,
but that’s enough to make a difference in today’s fast computers.
For this reason, modern computers use a slightly different adding circuit called a ‘carry-look-ahead’ adder
which is faster, but ultimately does exactly the same thing-- adds binary numbers.
The ALU’s arithmetic unit also has circuits for other math operations
and in general these 8 operations are always supported.
And like our adder, these other operations are built from individual logic gates.
Interestingly, you may have noticed that there are no multiply and divide operations.
That's because simple ALUs don’t have a circuit for this, and instead just perform a series of additions.
Let’s say you want to multiply 12 by 5.
That’s the same thing as adding 12 to itself 5 times. So it would take 5 passes through
the ALU to do this one multiplication. And
this is how many simple processors,
like those in your thermostat, TV remote, and microwave, do multiplication.
It’s slow, but it gets the job done.
However, fancier processors, like those in your laptop or smartphone,
have arithmetic units with dedicated circuits for multiplication.
And as you might expect, the circuit is more complicated than addition -- there’s no
magic, it just takes a lot more logic gates
– which is why less expensive processors
don’t have this feature.
Ok, let’s move on to the other half of the ALU: the Logic Unit.
Instead of arithmetic
operations, the Logic Unit performs… well...
logical operations, like AND, OR and NOT, which we’ve talked about previously.
It also performs simple numerical tests, like checking if a number is negative.
For example, here’s a circuit that tests
if the output of the ALU is zero.
It does this using a bunch of OR gates to see if any of the bits are 1.
Even if one single bit is 1, we know the number can’t be zero and then we use a final NOT gate to flip this
input so the output is 1 only if the input number is 0.
So that’s a high level overview of what makes up an ALU. We even built several of
the main components from scratch, like our ripple adder.
As you saw, it’s just a big bunch of logic gates connected in clever ways.
Which brings us back to that ALU you admired so much at the beginning of the episode.
The Intel 74181.
Unlike the 8-bit ALU we made today, the 74181 could only handle 4-bit inputs,
which means YOU BUILT AN ALU THAT’S LIKE
TWICE AS GOOD AS THAT SUPER FAMOUS ONE. WITH
YOUR MIND! Well.. sort of.
We didn’t build the whole thing… but you get the idea.
The 74181 used about 70 logic gates, and it couldn’t multiply or divide.
But it was a huge step forward in miniaturization, opening the doors to more capable and less expensive computers.
This 4-bit ALU circuit is already a lot to take in,
but our 8-bit ALU would require hundreds of logic gates to fully build and engineers
don’t want to see all that complexity when using an ALU, so they came up with a special
symbol to wrap it all up, which looks like
a big ‘V’. Just another level of abstraction!
Our 8-bit ALU has two inputs, A and B, each with 8 bits. We also need a way to specify what operation the ALU should perform,
for example, addition or subtraction.
For that, we use a 4-bit operation code.
We’ll talk about this more in a later episode, but in brief, 1000 might be the command
to add, while 1100 is the command for subtract. Basically, the operation code tells the ALU
what operation to perform. And the result of that operation on inputs A and B is an 8-bit output.
ALUs also output a series of Flags, which are 1-bit outputs for particular states and statuses.
For example, if we subtract two numbers, and the result is 0, our zero-testing circuit, the one we made earlier,
sets the Zero Flag to True (1). This is useful if we are trying to determine if two numbers are are equal.
If we wanted to test if A was less than B,
we can use the ALU to calculate A subtract B and look to see if the Negative Flag was set to true.
If it was, we know that A was
smaller than B.
And finally, there’s also a wire attached to the carry out on the adder we built,
so if there is an overflow, we’ll know about it. This is called the Overflow Flag.
Fancier ALUs will have more flags, but these three flags are universal and frequently used.
In fact, we’ll be using them soon in a future episode.
So now you know how your computer does all its basic mathematical operations digitally
with no gears or levers required.
We’re going to use this ALU when we construct our CPU two episodes from now.
But before that, our computer is going to need some memory! We'll talk about that next week.