ReviewCPSC 321

Andreas Klappenecker

Administrative Issues

• Midterm is on October 12• Allen Parish’s help session Friday 10:15-

12:15

Questions? Project partners?

Today’s Menu

What happened so far...

History

One of the first calculation tools was the abacus, presumably invented sometime between 1000-500 B.C.

Early History

• around 1600, John Napier invents the Napier bones, a tool that helps in calculations

• 1621, William Oughtred invents the slide rule that exploit Napier’s logarithms to assist in calculations

• 1625 Wilhelm Schickard invents a mechanical device to add, subtract, multiply and divide numbers

• 1640 Blaise Pascal invents his Arithmetic Machine (which could only add)

• 1671 Wilhelm von Leibniz invents the Step Reckoner, a device that allows to perform additions, subtractions, multiplications, divisions, and evaluation of square roots (by stepped additions)

Early History

• Charles Babbage proposes in 1822 a machine to calculate tables for logarithms and trigonometric functions, called the Difference Engine.

• Before completing the machine, he invents in 1833 the more sophisticated Analytic Engine that uses Jacquard punch cards to control the arithmetic calculations• The machine is programmable, has storage capabilities, and

control flow mechanisms – it is a general purpose computer.• The Analytic Engine was never completed.

• Augusta Ada Lovelace writes the first program for the Analytical Engine (to calculate Bernoulli numbers). Some consider her as the first programmer.

Z1

The Z1 computer was clocked at 1 Hz. The memory consists of 64 words with 22 bits. Input and output is done by a punch tape reader and a punch tape writer. The computer has two registers with 22 bits and is able to perform additions and subtractions (it is not a general purpose computer).

Z3

Zuse constructed the Z3, a fully programmable general purpose computer, in 1939-1941. Remarkably, it contained a binary floating point arithmetic. It was clocked at 5.33 Hz, based on relays, and had 64 words of 22 bits. The small memory did not allow for storage of the program.

(Art and photo courtesy of Horst Zuse)

Performance

• Response time: time between start and finish of the task (aka execution time)

• Throughput: total amount of work done in a given time

Performance

Relative Performance

(Absolute) Performance

Amdahl’s Law

The execution time after making an improvement to the system is given by

Exec time after improvement = I/A + E

I = execution time affected by improvementA = amount of improvementE = execution time unaffected

Assembly Language

.text # code section

.globl main

main: li $v0, 4 # system call for print string

la $a0, str # load address of string to print

syscall # print the string

li $v0, 10 # system call for exit

syscall # exit

.data

str: .asciiz “Hello world!\n” # NUL terminated string, as in C

Things to know...

• Instruction and pseudo-instructions• Register conventions (strictly

enforced)• Machine language instruction given,

find the corresponding assembly language instruction

• Code puzzles • Solve a small programming task

Instruction Word Formats

• Register format

• Immediate format

• Jump format

op-code rs rt rd shamt functop-code rs rt rd shamt funct

op-code rs rt immediate valueop-code rs rt immediate value

op-code 26 bit current segment addressop-code 26 bit current segment address

6 5 5 16

6 5 5 5 5 6

6 26

Machine Language

• Machine language level programming means that we have to provide the bit encodings for the instructions

• For example, add $t0, $s1, $s2 represents the 32bit string

• 00000010001100100100000000100000• Assembly language mnemonics usually

translate into one instruction• We also have pseudo-instructions that

translate into several instructions

What does that

mean?

Watson, the case is clear…

• add $t0, $s1, $s2• 00000010001100100100000000100000

• 000000 10001 10010 01000 00000 100000• Operation and function field tell the computer to

perform an addition

• 000000 10001 10010 01000 00000 100000• registers $17, $18 and $8

op-code rs rt rd shamt functop-code rs rt rd shamt funct

6 5 5 5 5 6

Number Representations

• Signed and unsigned integers• Number conversions• Comparisons• Overflow rules

• No overflow when adding a positive and a negative number

• No overflow when signs are the same for subtraction

• Overflow occurs when the value affects the sign:• overflow when adding two positives yields a negative • or, adding two negatives gives a positive• or, subtract a negative from a positive and get a

negative• or, subtract a positive from a negative and get a positive

Detecting Overflow

Detecting Overflow

Operation

Operand A

Operand B

Overflow if result

A+B >=0 >=0 <0

A+B <0 <0 >=0

A-B >=0 <0 <0

A-B <0 >=0 >=0

Logic Design: Build ALU, etc.

Result31a31

b31

Result0

CarryIn

a0

b0

Result1a1

b1

Result2a2

b2

Operation

ALU0

CarryIn

CarryOut

ALU1

CarryIn

CarryOut

ALU2

CarryIn

CarryOut

ALU31

CarryIn

b

0

2

Result

Operation

a

1

CarryIn

CarryOut

Logic Design

• Determine truth tables of combinatorial circuits

• Determine combinatorial circuits from truth tables

• Determine critical path• Overflow detection in ALU

SLT

0

3

Result

Operation

a

1

CarryIn

CarryOut

0

1

Binvert

b 2

Less

0

3

Result

Operation

a

1

CarryIn

0

1

Binvert

b 2

Less

Set

Overflowdetection

Overflow

a.

b.

• 4 operations• subtraction output available• Connect • MSB set output

w/ LSB less

Adders

• Ripple carry• Carry-lookahead

Fast Adders

Iterate the idea, generate and propagateci+1 = gi + pici

= gi + pi(gi-1 + pi-1 ci-1)

= gi + pigi-1+ pipi-1ci-1

= gi + pigi-1+ pipi-1gi-2 +…+ pipi-1 …p1g0

+pipi-1 …p1p0c0

Two level AND-OR circuit Carry is known early!

Multiplication

Done

1. TestMultiplier0

1a. Add multiplicand to product andplace the result in Product register

2. Shift the Multiplicand register left 1 bit

3. Shift the Multiplier register right 1 bit

32nd repetition?

Start

Multiplier0 = 0Multiplier0 = 1

No: < 32 repetitions

Yes: 32 repetitions

64-bit ALU

Control test

MultiplierShift right

ProductWrite

MultiplicandShift left

64 bits

64 bits

32 bits

0010 (multiplicand)__ x_1011 (multiplier) 0010 x 1 00100 x 1

001000 x 0 0010000 x 1

0010110

Booth Multiplication

Current and previous bit

00: middle of run of 0s, no action01: end of a run of 1s, add multiplicand10: beginning of a run of 1s, subtract

mcnd11: middle of string of 1s, no action

Example: 0010 x 0110

Iteration

Mcand

Step Product

0 0010 Initial values 0000 0110,0

1 0010 0010

00: no op arith>> 1

0000 0110,0

0000 0011,0

2 0010 0010

10: prod-=Mcandarith>> 1

1110 0011,0 1111 0001,1

3 0010 0010

11: no oparith>> 1

1111 0001,1 1111 1000,1

4 0010

0010

01: prod+=Mcandarith>> 1

0001 1000,1 0000 1100,0

IEEE 754 Floating Point Representation

• Float – 1 sign bit, 8 exponent bits, 23 bits for significand.

seeeeeeeefffffffffffffffffffffffvalue = (-1)s x F x 2E-127

with F= 1 + .ffffffff .... fff

• Double – 1 sign bit, 11 exponent bits, 52 bits for significand

Processor

• Be able to build the datapath• Be able to explain issues concerning

datapath and control

Control

PC

Instructionmemory

Readaddress

Instruction[31– 0]

Instruction [20– 16]

Instruction [25– 21]

Add

Instruction [5– 0]

MemtoReg

ALUOp

MemWrite

RegWrite

MemRead

BranchRegDst

ALUSrc

Instruction [31– 26]

4

16 32Instruction [15– 0]

0

0Mux

0

1

Control

Add ALUresult

Mux

0

1

RegistersWriteregister

Writedata

Readdata 1

Readdata 2

Readregister 1

Readregister 2

Signextend

Shiftleft 2

Mux

1

ALUresult

Zero

Datamemory

Writedata

Readdata

Mux

1

Instruction [15– 11]

ALUcontrol

ALUAddress

Single- versus Multicycle Processor

• What are the differences? • What is executed during the 7th

cycle?• How many cycles do we need?

Summary

Step nameAction for R-type

instructionsAction for memory-reference

instructionsAction for branches

Action for jumps

Instruction fetch IR = Memory[PC]PC = PC + 4

Instruction A = Reg [IR[25-21]]decode/register fetch B = Reg [IR[20-16]]

ALUOut = PC + (sign-extend (IR[15-0]) << 2)

Execution, address ALUOut = A op B ALUOut = A + sign-extend if (A ==B) then PC = PC [31-28] IIcomputation, branch/ (IR[15-0]) PC = ALUOut (IR[25-0]<<2)jump completion

Memory access or R-type Reg [IR[15-11]] = Load: MDR = Memory[ALUOut]completion ALUOut or

Store: Memory [ALUOut] = B

Memory read completion Load: Reg[IR[20-16]] = MDR

Need for Speed

• You need to be able to answer the question in a short time (75 minutes)

• Routine calculations, such as number conversions, should not slow you down

• Read the chapters very carefully!• Many repetitions will help you to gain

a better understanding