Computer Architecture
This document is a collection of web pages on computer
architecture.
The first part is an introduction to digital circuits. We recommend
you read the pages in this order:
- Gates. Here, we introduce the
fundamental building blocks of digital computers.
- Truth tables. We discuss truth
tables as a way both of describing an existing circuit and of
specifying a circuit to be built.
- Combinatorial circuits. We
introduce circuits whose output values depend only on a
combination of the input values.
- Logic expressions. We explain
how to describe circuits as algebraic formulae and how to
manipulate those formulae with algebraic laws.
- Multiplexer. A particular
combinatorial circuit so commonly used that we discuss it
separately.
- Demultiplexer. A particular
combinatorial circuit so commonly used that we discuss it
separately.
- Decoder. A particular
combinatorial circuit so commonly used that we discuss it
separately.
- Binary arithmetic. In
this section, we introduce the fundamentals of binary
arithmetic and representation of numbers.
- Circuits for
binary arithmetic. We show different circuits for binary
arithmetic and explain trade-offs between speed and number of
gates.
- Latches and flip-flops.
Flip-flops are the basic elements of sequential circuits, the
way gates are the basic elements of combinatorial circuits.
- State table. We discuss state
tables as a way both of describing an existing sequential
circuit and as a way of specifying a sequential circuit to be
built.
- Sequential circuits. We
introduce circuits whose output values depend not only on the
inputs, but also on previous input and output values.
- Registers. A register is a
particularly simple sequential circuit that can be instructed
to store its input values indefinitely.
- Counters. A counter is a
another particularly simple sequential circuit that normally
increments its stored value for each clock pulse.
- Binary multiplication. We
show how to build a circuit for binary multiplication.
- Tri-state logic circuits.
Tri-state logic circuits represent a pragmatic solution to some
problems of circuit complexity.
- Buses. With tri-state logic, we can
use a bus to transport data.
- Memories. While memories are
clearly sequential circuits, they have a special structure that
makes it interesting to look at them separately.
- Read-only memories. A read-only memory
is nothing more than a combinatorial circuit, but often built
as a memory.
Next, we design a number of specific combinatorial and sequential
circuits, which will be the building blocks of a simple computer:
- Counter with clear. This
sequential circuit is nominally an ordinary counter, but an
additional input allows us to clear the contents of the
counter.
- Counter register. This
sequential circuit is a combination of a counter and a
register.
- Counter register
with clear. This sequential circuit is a combination of a
counter with clear and a register.
- Counter
register with clear and explicit increment. This sequential
circuit is similar to a counter register with clear, except
that it does not increment unless explicitly instructed to.
- Micro memory. This is a
combinatorial circuit sometimes in the form of a PROM.
- Instruction decoder.
This is a combinatorial circuit sometimes in the form of a PROM.
- Arithmetic and logic unit. This is a
combinatorial circuit for doing arithmetic and logic
operations. The operation can be selected by the value of
inputs.
- The first computer. We present
our first simple computer, allowing us to make some very simple
computations.
Now, we gradually complicate our simple computer:
- Conditional jumps. So far, our
computer could only do unconditional jumps. Now, we show how
to introduce conditional jumps as well.
- Subprograms. We add support for
procedures and functions in high-level languages and discuss
call/return protocols.
- Parameter passing. We add
support for passing parameters to subroutines on the stack.
- Local variables We show how to
use existing instructions to allocate space on the stack for
local variables.
- Interrupts. Our computer must
know how to react to external events from timers and
peripherals. The mechanism for interrupts makes that possible.