General Computer Science 320201 GenCS I & II Lecture ... - Kwarc

Our notion of time is in this construction is very simplistic, in our analysis we assume a series
of discrete clock ticks that synchronize all events in the circuit. We will only observe the circuits
on each clock tick and assume that all computational devices introduced for the register machine
complete computation before the next tick. Real circuits, also have a clock that synchronizes events
(the clock frequency (currently around 3 GHz for desktop CPUs) is a common approximation
measure of processor performance), but the assumption of elementary computations taking only
one click is wrong in production systems.
We will now instantiate this general register machine with a concrete (hypothetical) realization,
which is sufficient for general programming, in principle. In particular, we will need to identify a
set of program operations. We will come up with 18 operations, so we need to set n ≥ 5. It is
possible to do programming with n = 4 designs, but we are interested in the general principles
more than optimization.
The main idea of programming at the circuit level is to map the operator code (an n-bit binary
number) of the current instruction to the control input of the ALU and the MMU, which will then
perform the action encoded in the operator.
Since it is very tedious to look at the binary operator codes (even it we present them as hexadecimal
numbers). Therefore it has become customary to use a mnemonic encoding of these in simple word
tokens, which are simpler to read, the “assembler language”.
Assembler Language
Idea: Store program instructions as n-bit values in program store, map these to control inputs
of ALU, MMU.
Definition 445 assembler language (ASM)as mnemonic encoding of n-bit binary codes.
instruction effect P C comment
LOAD i ACC : = P (i) P C : = P C +1 load data
STORE i P (i): = ACC P C : = P C +1 store data
ADD i ACC : = ACC +P (i) P C : = P C +1 add to ACC
SUB i ACC : = ACC −P (i) P C : = P C +1 subtract from ACC
LOADI i ACC : = i P C : = P C +1 load number
ADDI i ACC : = ACC +i P C : = P C +1 add number
SUBI i ACC : = ACC −i P C : = P C +1 subtract number
c○: Michael Kohlhase 276
Definition 446 The meaning of the program instructions are specified in their ability to change
the state of the memory of the register machine. So to understand them, we have to trace the
state of the memory over time (looking at a snapshot after each clock tick; this is what we do
in the comment fields in the tables on the next slide). We speak of an imperative programming
language, if this is the case.
Example 447 This is in contrast to the programming language SML that we have looked at
before. There we are not interested in the state of memory. In fact state is something that we
want to avoid in such functional programming languages for conceptual clarity; we relegated all
things that need state into special constructs: effects.
To be able to trace the memory state over time, we also have to think about the initial state of the
register machine (e.g. after we have turned on the power). We assume the state of the registers
and the data store to be arbitrary (who knows what the machine has dreamt). More interestingly,
we assume the state of the program store to be given externally. For the moment, we may assume
(as was the case with the first computers) that the program store is just implemented as a large
array of binary switches; one for each bit in the program store. Programming a computer at that
time was done by flipping the switches (2n) for each instructions. Nowadays, parts of the initial
154