Lectures for 3rd Edition

1
Lectures for 3rd Edition

• Note these lectures are often supplemented with
  other materials and also problems from the text
  worked out on the blackboard. Youll want to
  customize these lectures for your class. The
  student audience for these lectures have had
  exposure to logic design and attend a hands-on
  assembly language programming lab that does not
  follow a typical lecture format.

2
Chapter Three
3
Numbers

• Bits are just bits (no inherent meaning)
  conventions define relationship between bits and
  numbers
• Binary numbers (base 2) 0000 0001 0010 0011 0100
  0101 0110 0111 1000 1001... decimal 0...2n-1
• Of course it gets more complicated numbers are
  finite (overflow) fractions and real
  numbers negative numbers e.g., no MIPS subi
  instruction addi can add a negative number
• How do we represent negative numbers? i.e.,
  which bit patterns will represent which numbers?

4
Possible Representations

• Sign Magnitude One's Complement
  Two's Complement 000 0 000 0 000
  0 001 1 001 1 001 1 010 2 010
  2 010 2 011 3 011 3 011 3 100
  -0 100 -3 100 -4 101 -1 101 -2 101
  -3 110 -2 110 -1 110 -2 111 -3 111
  -0 111 -1
• Issues balance, number of zeros, ease of
  operations
• Which one is best? Why?

5
MIPS

• 32 bit signed numbers0000 0000 0000 0000 0000
  0000 0000 0000two 0ten0000 0000 0000 0000 0000
  0000 0000 0001two 1ten0000 0000 0000 0000
  0000 0000 0000 0010two 2ten...0111 1111
  1111 1111 1111 1111 1111 1110two
  2,147,483,646ten0111 1111 1111 1111 1111 1111
  1111 1111two 2,147,483,647ten1000 0000 0000
  0000 0000 0000 0000 0000two
  2,147,483,648ten1000 0000 0000 0000 0000 0000
  0000 0001two 2,147,483,647ten1000 0000 0000
  0000 0000 0000 0000 0010two
  2,147,483,646ten...1111 1111 1111 1111 1111
  1111 1111 1101two 3ten1111 1111 1111 1111
  1111 1111 1111 1110two 2ten1111 1111 1111
  1111 1111 1111 1111 1111two 1ten

6
Two's Complement Operations

• Negating a two's complement number invert all
  bits and add 1
• remember negate and invert are quite
  different!
• Converting n bit numbers into numbers with more
  than n bits
• MIPS 16 bit immediate gets converted to 32 bits
  for arithmetic
• copy the most significant bit (the sign bit) into
  the other bits 0010 -gt 0000 0010 1010 -gt
  1111 1010
• "sign extension" (lbu vs. lb)

7
Addition Subtraction

• Just like in grade school (carry/borrow 1s)
  0111 0111 0110  0110 - 0110 - 0101
• Two's complement operations easy
• subtraction using addition of negative numbers
  0111  1010
• Overflow (result too large for finite computer
  word)
• e.g., adding two n-bit numbers does not yield an
  n-bit number 0111  0001 note that overflow
  term is somewhat misleading, 1000 it does not
  mean a carry overflowed

8
Detecting Overflow

• 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
• Consider the operations A B, and A B
• Can overflow occur if B is 0 ?
• Can overflow occur if A is 0 ?

9
Effects of Overflow

• An exception (interrupt) occurs
• Control jumps to predefined address for exception
• Interrupted address is saved for possible
  resumption
• Details based on software system / language
• example flight control vs. homework assignment
• Don't always want to detect overflow new MIPS
  instructions addu, addiu, subu note addiu
  still sign-extends! note sltu, sltiu for
  unsigned comparisons

10
Multiplication

• More complicated than addition
• accomplished via shifting and addition
• More time and more area
• Let's look at 3 versions based on a gradeschool
  algorithm 0010 (multiplicand) __x_101
  1 (multiplier)
• Negative numbers convert and multiply
• there are better techniques, we wont look at them

11
Multiplication Implementation
Datapath
Control
12
Final Version

• Multiplier starts in right half of product

What goes here?
13
Floating Point (a brief look)

• We need a way to represent
• numbers with fractions, e.g., 3.1416
• very small numbers, e.g., .000000001
• very large numbers, e.g., 3.15576 109
• Representation
• sign, exponent, significand (1)sign
  significand 2exponent
• more bits for significand gives more accuracy
• more bits for exponent increases range
• IEEE 754 floating point standard
• single precision 8 bit exponent, 23 bit
  significand
• double precision 11 bit exponent, 52 bit
  significand

14
IEEE 754 floating-point standard

• Leading 1 bit of significand is implicit
• Exponent is biased to make sorting easier
• all 0s is smallest exponent all 1s is largest
• bias of 127 for single precision and 1023 for
  double precision
• summary (1)sign (1significand)
  2exponent bias
• Example
• decimal -.75 - ( ½ ¼ )
• binary -.11 -1.1 x 2-1
• floating point exponent 126 01111110
• IEEE single precision 10111111010000000000000000
  000000

15
Floating point addition

16
Floating Point Complexities

• Operations are somewhat more complicated (see
  text)
• In addition to overflow we can have underflow
• Accuracy can be a big problem
• IEEE 754 keeps two extra bits, guard and round
• four rounding modes
• positive divided by zero yields infinity
• zero divide by zero yields not a number
• other complexities
• Implementing the standard can be tricky
• Not using the standard can be even worse
• see text for description of 80x86 and Pentium bug!

17
Chapter Three Summary

• Computer arithmetic is constrained by limited
  precision
• Bit patterns have no inherent meaning but
  standards do exist
• twos complement
• IEEE 754 floating point
• Computer instructions determine meaning of the
  bit patterns
• Performance and accuracy are important so there
  are many complexities in real machines
• Algorithm choice is important and may lead to
  hardware optimizations for both space and time
  (e.g., multiplication)
• You may want to look back (Section 3.10 is great
  reading!)

18
Chapter 4
19
Performance

• Measure, Report, and Summarize
• Make intelligent choices
• See through the marketing hype
• Key to understanding underlying organizational
  motivationWhy is some hardware better than
  others for different programs?What factors of
  system performance are hardware related? (e.g.,
  Do we need a new machine, or a new operating
  system?)How does the machine's instruction set
  affect performance?

20
Which of these airplanes has the best performance?
Airplane Passengers Range (mi) Speed
(mph) Boeing 737-100 101 630 598 Boeing
747 470 4150 610 BAC/Sud Concorde 132 4000 1350 Do
uglas DC-8-50 146 8720 544

• How much faster is the Concorde compared to the
  747?
• How much bigger is the 747 than the Douglas DC-8?

21
Computer Performance TIME, TIME, TIME

• Response Time (latency) How long does it take
  for my job to run? How long does it take to
  execute a job? How long must I wait for the
  database query?
• Throughput How many jobs can the machine run
  at once? What is the average execution
  rate? How much work is getting done?
• If we upgrade a machine with a new processor what
  do we increase?
• If we add a new machine to the lab what do we
  increase?

22
Execution Time

• Elapsed Time
• counts everything (disk and memory accesses, I/O
  , etc.)
• a useful number, but often not good for
  comparison purposes
• CPU time
• doesn't count I/O or time spent running other
  programs
• can be broken up into system time, and user time
• Our focus user CPU time
• time spent executing the lines of code that are
  "in" our program

23
Book's Definition of Performance

• For some program running on machine X,
  PerformanceX 1 / Execution timeX
• "X is n times faster than Y" PerformanceX /
  PerformanceY n
• Problem
• machine A runs a program in 20 seconds
• machine B runs the same program in 25 seconds

24
Clock Cycles

• Instead of reporting execution time in seconds,
  we often use cycles
• Clock ticks indicate when to start activities
  (one abstraction)
• cycle time time between ticks seconds per
  cycle
• clock rate (frequency) cycles per second (1
  Hz. 1 cycle/sec)A 4 Ghz. clock has a
  
  cycle time

25
How to Improve Performance

• So, to improve performance (everything else being
  equal) you can either (increase or
  decrease?)________ the of required cycles for
  a program, or________ the clock cycle time or,
  said another way, ________ the clock rate.

26
How many cycles are required for a program?

• Could assume that number of cycles equals number
  of instructions

time
This assumption is incorrect, different
instructions take different amounts of time on
different machines.Why? hint remember that
these are machine instructions, not lines of C
code
27
Different numbers of cycles for different
instructions
time

• Multiplication takes more time than addition
• Floating point operations take longer than
  integer ones
• Accessing memory takes more time than accessing
  registers
• Important point changing the cycle time often
  changes the number of cycles required for various
  instructions (more later)

28
Example

• Our favorite program runs in 10 seconds on
  computer A, which has a 4 GHz. clock. We are
  trying to help a computer designer build a new
  machine B, that will run this program in 6
  seconds. The designer can use new (or perhaps
  more expensive) technology to substantially
  increase the clock rate, but has informed us that
  this increase will affect the rest of the CPU
  design, causing machine B to require 1.2 times as
  many clock cycles as machine A for the same
  program. What clock rate should we tell the
  designer to target?"
• Don't Panic, can easily work this out from basic
  principles

29
Now that we understand cycles

• A given program will require
• some number of instructions (machine
  instructions)
• some number of cycles
• some number of seconds
• We have a vocabulary that relates these
  quantities
• cycle time (seconds per cycle)
• clock rate (cycles per second)
• CPI (cycles per instruction) a floating point
  intensive application might have a higher CPI
• MIPS (millions of instructions per second) this
  would be higher for a program using simple
  instructions

30
Performance

• Performance is determined by execution time
• Do any of the other variables equal performance?
• of cycles to execute program?
• of instructions in program?
• of cycles per second?
• average of cycles per instruction?
• average of instructions per second?
• Common pitfall thinking one of the variables is
  indicative of performance when it really isnt.

31
CPI Example

• Suppose we have two implementations of the same
  instruction set architecture (ISA). For some
  program,Machine A has a clock cycle time of 250
  ps and a CPI of 2.0 Machine B has a clock cycle
  time of 500 ps and a CPI of 1.2 What machine is
  faster for this program, and by how much?
• If two machines have the same ISA which of our
  quantities (e.g., clock rate, CPI, execution
  time, of instructions, MIPS) will always be
  identical?

32
of Instructions Example

• A compiler designer is trying to decide between
  two code sequences for a particular machine.
  Based on the hardware implementation, there are
  three different classes of instructions Class
  A, Class B, and Class C, and they require one,
  two, and three cycles (respectively). The
  first code sequence has 5 instructions 2 of A,
  1 of B, and 2 of CThe second sequence has 6
  instructions 4 of A, 1 of B, and 1 of C.Which
  sequence will be faster? How much?What is the
  CPI for each sequence?

33
MIPS example

• Two different compilers are being tested for a 4
  GHz. machine with three different classes of
  instructions Class A, Class B, and Class C,
  which require one, two, and three cycles
  (respectively). Both compilers are used to
  produce code for a large piece of software.The
  first compiler's code uses 5 million Class A
  instructions, 1 million Class B instructions, and
  1 million Class C instructions.The second
  compiler's code uses 10 million Class A
  instructions, 1 million Class B instructions,
  and 1 million Class C instructions.
• Which sequence will be faster according to MIPS?
• Which sequence will be faster according to
  execution time?

34
Benchmarks

• Performance best determined by running a real
  application
• Use programs typical of expected workload
• Or, typical of expected class of
  applications e.g., compilers/editors, scientific
  applications, graphics, etc.
• Small benchmarks
• nice for architects and designers
• easy to standardize
• can be abused
• SPEC (System Performance Evaluation Cooperative)
• companies have agreed on a set of real program
  and inputs
• valuable indicator of performance (and compiler
  technology)
• can still be abused

35
Benchmark Games

• An embarrassed Intel Corp. acknowledged Friday
  that a bug in a software program known as a
  compiler had led the company to overstate the
  speed of its microprocessor chips on an industry
  benchmark by 10 percent. However, industry
  analysts said the coding errorwas a sad
  commentary on a common industry practice of
  cheating on standardized performance testsThe
  error was pointed out to Intel two days ago by a
  competitor, Motorola came in a test known as
  SPECint92Intel acknowledged that it had
  optimized its compiler to improve its test
  scores. The company had also said that it did
  not like the practice but felt to compelled to
  make the optimizations because its competitors
  were doing the same thingAt the heart of Intels
  problem is the practice of tuning compiler
  programs to recognize certain computing problems
  in the test and then substituting special
  handwritten pieces of code Saturday, January
  6, 1996 New York Times

36
SPEC 89

• Compiler enhancements and performance

37
SPEC CPU2000
38
SPEC 2000

• Does doubling the clock rate double the
  performance?
• Can a machine with a slower clock rate have
  better performance?

39
Experiment

• Phone a major computer retailer and tell them you
  are having trouble deciding between two different
  computers, specifically you are confused about
  the processors strengths and weaknesses (e.g.,
  Pentium 4 at 2Ghz vs. Celeron M at 1.4 Ghz )
• What kind of response are you likely to get?
• What kind of response could you give a friend
  with the same question?

40
Amdahl's Law

• Execution Time After Improvement Execution
  Time Unaffected ( Execution Time Affected /
  Amount of Improvement )
• Example "Suppose a program runs in 100 seconds
  on a machine, with multiply responsible for 80
  seconds of this time. How much do we have to
  improve the speed of multiplication if we want
  the program to run 4 times faster?" How about
  making it 5 times faster?
• Principle Make the common case fast

41
Example

• Suppose we enhance a machine making all
  floating-point instructions run five times
  faster. If the execution time of some benchmark
  before the floating-point enhancement is 10
  seconds, what will the speedup be if half of the
  10 seconds is spent executing floating-point
  instructions?
• We are looking for a benchmark to show off the
  new floating-point unit described above, and want
  the overall benchmark to show a speedup of 3.
  One benchmark we are considering runs for 100
  seconds with the old floating-point hardware.
  How much of the execution time would
  floating-point instructions have to account for
  in this program in order to yield our desired
  speedup on this benchmark?

42
Remember

• Performance is specific to a particular program/s
• Total execution time is a consistent summary of
  performance
• For a given architecture performance increases
  come from
• increases in clock rate (without adverse CPI
  affects)
• improvements in processor organization that lower
  CPI
• compiler enhancements that lower CPI and/or
  instruction count
• Algorithm/Language choices that affect
  instruction count
• Pitfall expecting improvement in one aspect of
  a machines performance to affect the total
  performance

43
Lets Build a Processor

• Almost ready to move into chapter 5 and start
  building a processor
• First, lets review Boolean Logic and build the
  ALU well need (Material from Appendix B)

44
Review Boolean Algebra Gates

• Problem Consider a logic function with three
  inputs A, B, and C. Output D is true if at
  least one input is true Output E is true if
  exactly two inputs are true Output F is true
  only if all three inputs are true
• Show the truth table for these three functions.
• Show the Boolean equations for these three
  functions.
• Show an implementation consisting of inverters,
  AND, and OR gates.

45
An ALU (arithmetic logic unit)

• Let's build an ALU to support the andi and ori
  instructions
• we'll just build a 1 bit ALU, and use 32 of
  them
• Possible Implementation (sum-of-products)

a
b
46
Review The Multiplexor

• Selects one of the inputs to be the output,
  based on a control input
• Lets build our ALU using a MUX

note we call this a 2-input mux even
though it has 3 inputs!
0
1
47
Different Implementations

• Not easy to decide the best way to build
  something
• Don't want too many inputs to a single gate
• Dont want to have to go through too many gates
• for our purposes, ease of comprehension is
  important
• Let's look at a 1-bit ALU for addition
• How could we build a 1-bit ALU for add, and, and
  or?
• How could we build a 32-bit ALU?

cout a b a cin b cin sum a xor b xor cin
48
Building a 32 bit ALU
49
What about subtraction (a b) ?

• Two's complement approach just negate b and
  add.
• How do we negate?
• A very clever solution

50
Adding a NOR function

• Can also choose to invert a. How do we get a
  NOR b ?

51
Tailoring the ALU to the MIPS

• Need to support the set-on-less-than instruction
  (slt)
• remember slt is an arithmetic instruction
• produces a 1 if rs lt rt and 0 otherwise
• use subtraction (a-b) lt 0 implies a lt b
• Need to support test for equality (beq t5, t6,
  t7)
• use subtraction (a-b) 0 implies a b

52
Supporting slt

• Can we figure out the idea?

all other bits
Use this ALU for most significant bit
53
Supporting slt
54
Test for equality

• Notice control lines0000 and0001 or0010
  add0110 subtract0111 slt1100 NOR

• Note zero is a 1 when the result is zero!

55
Conclusion

• We can build an ALU to support the MIPS
  instruction set
• key idea use multiplexor to select the output
  we want
• we can efficiently perform subtraction using
  twos complement
• we can replicate a 1-bit ALU to produce a 32-bit
  ALU
• Important points about hardware
• all of the gates are always working
• the speed of a gate is affected by the number of
  inputs to the gate
• the speed of a circuit is affected by the number
  of gates in series (on the critical path or
  the deepest level of logic)
• Our primary focus comprehension, however,
• Clever changes to organization can improve
  performance (similar to using better algorithms
  in software)
• We saw this in multiplication, lets look at
  addition now

56
Problem ripple carry adder is slow

• Is a 32-bit ALU as fast as a 1-bit ALU?
• Is there more than one way to do addition?
• two extremes ripple carry and sum-of-products
• Can you see the ripple? How could you get rid of
  it?
• c1 b0c0 a0c0 a0b0
• c2 b1c1 a1c1 a1b1 c2
• c3 b2c2 a2c2 a2b2 c3
• c4 b3c3 a3c3 a3b3 c4
• Not feasible! Why?

57
Carry-lookahead adder

• An approach in-between our two extremes
• Motivation
• If we didn't know the value of carry-in, what
  could we do?
• When would we always generate a carry? gi
  ai bi
• When would we propagate the carry?
  pi ai bi
• Did we get rid of the ripple?
• c1 g0 p0c0
• c2 g1 p1c1 c2
• c3 g2 p2c2 c3
• c4 g3 p3c3 c4 Feasible! Why?

58
Use principle to build bigger adders

• Cant build a 16 bit adder this way... (too big)
• Could use ripple carry of 4-bit CLA adders
• Better use the CLA principle again!

59
ALU Summary

• We can build an ALU to support MIPS addition
• Our focus is on comprehension, not performance
• Real processors use more sophisticated techniques
  for arithmetic
• Where performance is not critical, hardware
  description languages allow designers to
  completely automate the creation of hardware!

60
Chapter Five
61
The Processor Datapath Control

• We're ready to look at an implementation of the
  MIPS
• Simplified to contain only
• memory-reference instructions lw, sw
• arithmetic-logical instructions add, sub, and,
  or, slt
• control flow instructions beq, j
• Generic Implementation
• use the program counter (PC) to supply
  instruction address
• get the instruction from memory
• read registers
• use the instruction to decide exactly what to do
• All instructions use the ALU after reading the
  registers Why? memory-reference? arithmetic?
  control flow?

62
More Implementation Details

• Abstract / Simplified ViewTwo types
  of functional units
• elements that operate on data values
  (combinational)
• elements that contain state (sequential)

63
State Elements

• Unclocked vs. Clocked
• Clocks used in synchronous logic
• when should an element that contains state be
  updated?

cycle time
64
An unclocked state element

• The set-reset latch
• output depends on present inputs and also on past
  inputs

65
Latches and Flip-flops

• Output is equal to the stored value inside the
  element (don't need to ask for permission to
  look at the value)
• Change of state (value) is based on the clock
• Latches whenever the inputs change, and the
  clock is asserted
• Flip-flop state changes only on a clock
  edge (edge-triggered methodology)

"logically true", could mean electrically low
A clocking methodology defines when signals can
be read and written wouldn't want to read a
signal at the same time it was being written
66
D-latch

• Two inputs
• the data value to be stored (D)
• the clock signal (C) indicating when to read
  store D
• Two outputs
• the value of the internal state (Q) and it's
  complement

67
D flip-flop

• Output changes only on the clock edge

68
Our Implementation

• An edge triggered methodology
• Typical execution
• read contents of some state elements,
• send values through some combinational logic
• write results to one or more state elements

69
Register File

• Built using D flip-flops

Do you understand? What is the Mux above?
70
Abstraction

• Make sure you understand the abstractions!
• Sometimes it is easy to think you do, when you
  dont

71
Register File

• Note we still use the real clock to determine
  when to write

72
Simple Implementation

• Include the functional units we need for each
  instruction

Why do we need this stuff?
73
Building the Datapath

• Use multiplexors to stitch them together

74
Control

• Selecting the operations to perform (ALU,
  read/write, etc.)
• Controlling the flow of data (multiplexor inputs)
• Information comes from the 32 bits of the
  instruction
• Example add 8, 17, 18 Instruction
  Format 000000 10001 10010 01000
  00000 100000 op rs rt rd shamt
  funct
• ALU's operation based on instruction type and
  function code

75
Control

• e.g., what should the ALU do with this
  instruction
• Example lw 1, 100(2) 35 2 1
  100 op rs rt 16 bit offset
• ALU control input 0000 AND 0001 OR 0010 add
  0110 subtract 0111 set-on-less-than 1100 NOR
• Why is the code for subtract 0110 and not 0011?

76
Control

• Must describe hardware to compute 4-bit ALU
  control input
• given instruction type 00 lw, sw 01 beq,
  10 arithmetic
• function code for arithmetic
• Describe it using a truth table (can turn into
  gates)

77

78
Control

• Simple combinational logic (truth tables)

79
Our Simple Control Structure

• All of the logic is combinational
• We wait for everything to settle down, and the
  right thing to be done
• ALU might not produce right answer right away
• we use write signals along with clock to
  determine when to write
• Cycle time determined by length of the longest
  path

We are ignoring some details like setup and hold
times
80
Single Cycle Implementation

• Calculate cycle time assuming negligible delays
  except
• memory (200ps), ALU and adders (100ps),
  register file access (50ps)

81
Where we are headed

• Single Cycle Problems
• what if we had a more complicated instruction
  like floating point?
• wasteful of area
• One Solution
• use a smaller cycle time
• have different instructions take different
  numbers of cycles
• a multicycle datapath

82
Multicycle Approach

• We will be reusing functional units
• ALU used to compute address and to increment PC
• Memory used for instruction and data
• Our control signals will not be determined
  directly by instruction
• e.g., what should the ALU do for a subtract
  instruction?
• Well use a finite state machine for control

83
Multicycle Approach

• Break up the instructions into steps, each step
  takes a cycle
• balance the amount of work to be done
• restrict each cycle to use only one major
  functional unit
• At the end of a cycle
• store values for use in later cycles (easiest
  thing to do)
• introduce additional internal registers

84
Instructions from ISA perspective

• Consider each instruction from perspective of
  ISA.
• Example
• The add instruction changes a register.
• Register specified by bits 1511 of instruction.
  
• Instruction specified by the PC.
• New value is the sum (op) of two registers.
• Registers specified by bits 2521 and 2016 of
  the instruction RegMemoryPC1511 lt
  RegMemoryPC2521 op
  RegMemoryPC2016
• In order to accomplish this we must break up the
  instruction. (kind of like introducing variables
  when programming)

85
Breaking down an instruction

• ISA definition of arithmeticRegMemoryPC151
  1 lt RegMemoryPC2521 op
  RegMemoryPC2016
• Could break down to
• IR lt MemoryPC
• A lt RegIR2521
• B lt RegIR2016
• ALUOut lt A op B
• RegIR2016 lt ALUOut
• We forgot an important part of the definition of
  arithmetic!
• PC lt PC 4

86
Idea behind multicycle approach

• We define each instruction from the ISA
  perspective (do this!)
• Break it down into steps following our rule that
  data flows through at most one major functional
  unit (e.g., balance work across steps)
• Introduce new registers as needed (e.g, A, B,
  ALUOut, MDR, etc.)
• Finally try and pack as much work into each step
  (avoid unnecessary cycles)while also trying to
  share steps where possible (minimizes control,
  helps to simplify solution)
• Result Our books multicycle Implementation!

87
Five Execution Steps

• Instruction Fetch
• Instruction Decode and Register Fetch
• Execution, Memory Address Computation, or Branch
  Completion
• Memory Access or R-type instruction completion
• Write-back step INSTRUCTIONS TAKE FROM 3 - 5
  CYCLES!

88
Step 1 Instruction Fetch

• Use PC to get instruction and put it in the
  Instruction Register.
• Increment the PC by 4 and put the result back in
  the PC.
• Can be described succinctly using RTL
  "Register-Transfer Language" IR lt
  MemoryPC PC lt PC 4Can we figure out the
  values of the control signals?What is the
  advantage of updating the PC now?

89
Step 2 Instruction Decode and Register Fetch

• Read registers rs and rt in case we need them
• Compute the branch address in case the
  instruction is a branch
• RTL A lt RegIR2521 B lt
  RegIR2016 ALUOut lt PC
  (sign-extend(IR150) ltlt 2)
• We aren't setting any control lines based on the
  instruction type (we are busy "decoding" it in
  our control logic)

90
Step 3 (instruction dependent)

• ALU is performing one of three functions, based
  on instruction type
• Memory Reference ALUOut lt A
  sign-extend(IR150)
• R-type ALUOut lt A op B
• Branch if (AB) PC lt ALUOut

91
Step 4 (R-type or memory-access)

• Loads and stores access memory MDR lt
  MemoryALUOut or MemoryALUOut lt B
• R-type instructions finish RegIR1511 lt
  ALUOutThe write actually takes place at the
  end of the cycle on the edge

92
Write-back step

• RegIR2016 lt MDR
• Which instruction needs this?

93
Summary
94
Simple Questions

• How many cycles will it take to execute this
  code? lw t2, 0(t3) lw t3, 4(t3) beq
  t2, t3, Label assume not add t5, t2,
  t3 sw t5, 8(t3)Label ...
• What is going on during the 8th cycle of
  execution?
• In what cycle does the actual addition of t2 and
  t3 takes place?

95
(No Transcript)
96
Review finite state machines

• Finite state machines
• a set of states and
• next state function (determined by current state
  and the input)
• output function (determined by current state and
  possibly input)
• Well use a Moore machine (output based only on
  current state)

97
Review finite state machines

• Example B. 37 A friend would like you to
  build an electronic eye for use as a fake
  security device. The device consists of three
  lights lined up in a row, controlled by the
  outputs Left, Middle, and Right, which, if
  asserted, indicate that a light should be on.
  Only one light is on at a time, and the light
  moves from left to right and then from right to
  left, thus scaring away thieves who believe that
  the device is monitoring their activity. Draw
  the graphical representation for the finite state
  machine used to specify the electronic eye. Note
  that the rate of the eyes movement will be
  controlled by the clock speed (which should not
  be too great) and that there are essentially no
  inputs.

98
Implementing the Control

• Value of control signals is dependent upon
• what instruction is being executed
• which step is being performed
• Use the information weve accumulated to specify
  a finite state machine
• specify the finite state machine graphically, or
• use microprogramming
• Implementation can be derived from specification

99
Graphical Specification of FSM

• Note
• dont care if not mentioned
• asserted if name only
• otherwise exact value
• How many state bits will we need?

100
Finite State Machine for Control

• Implementation

101
PLA Implementation

• If I picked a horizontal or vertical line could
  you explain it?

102
ROM Implementation

• ROM "Read Only Memory"
• values of memory locations are fixed ahead of
  time
• A ROM can be used to implement a truth table
• if the address is m-bits, we can address 2m
  entries in the ROM.
• our outputs are the bits of data that the address
  points to.m is the "height", and n is
  the "width"

0 0 0 0 0 1 1 0 0 1 1 1 0 0 0 1 0 1 1 0 0 0 1 1 1
0 0 0 1 0 0 0 0 0 0 1 0 1 0 0 0 1 1 1 0 0 1 1
0 1 1 1 0 1 1 1
103
ROM Implementation

• How many inputs are there? 6 bits for opcode, 4
  bits for state 10 address lines (i.e., 210
  1024 different addresses)
• How many outputs are there? 16 datapath-control
  outputs, 4 state bits 20 outputs
• ROM is 210 x 20 20K bits (and a rather
  unusual size)
• Rather wasteful, since for lots of the entries,
  the outputs are the same i.e., opcode is often
  ignored

104
ROM vs PLA

• Break up the table into two parts 4 state bits
  tell you the 16 outputs, 24 x 16 bits of
  ROM 10 bits tell you the 4 next state bits,
  210 x 4 bits of ROM Total 4.3K bits of ROM
• PLA is much smaller can share product terms
  only need entries that produce an active
  output can take into account don't cares
• Size is (inputs product-terms) (outputs
  product-terms) For this example
  (10x17)(20x17) 510 PLA cells
• PLA cells usually about the size of a ROM cell
  (slightly bigger)

105
Another Implementation Style

• Complex instructions the "next state" is often
  current state 1

106
Details
107
Microprogramming

• What are the microinstructions ?

108
Microprogramming

• A specification methodology
• appropriate if hundreds of opcodes, modes,
  cycles, etc.
• signals specified symbolically using
  microinstructions
• Will two implementations of the same architecture
  have the same microcode?
• What would a microassembler do?

109
Microinstruction format
110
Maximally vs. Minimally Encoded

• No encoding
• 1 bit for each datapath operation
• faster, requires more memory (logic)
• used for Vax 780 an astonishing 400K of memory!
• Lots of encoding
• send the microinstructions through logic to get
  control signals
• uses less memory, slower
• Historical context of CISC
• Too much logic to put on a single chip with
  everything else
• Use a ROM (or even RAM) to hold the microcode
• Its easy to add new instructions

111
Microcode Trade-offs

• Distinction between specification and
  implementation is sometimes blurred
• Specification Advantages
• Easy to design and write
• Design architecture and microcode in parallel
• Implementation (off-chip ROM) Advantages
• Easy to change since values are in memory
• Can emulate other architectures
• Can make use of internal registers
• Implementation Disadvantages, SLOWER now that
• Control is implemented on same chip as processor
• ROM is no longer faster than RAM
• No need to go back and make changes

112
Historical Perspective

• In the 60s and 70s microprogramming was very
  important for implementing machines
• This led to more sophisticated ISAs and the VAX
• In the 80s RISC processors based on pipelining
  became popular
• Pipelining the microinstructions is also
  possible!
• Implementations of IA-32 architecture processors
  since 486 use
• hardwired control for simpler instructions
  (few cycles, FSM control implemented using PLA
  or random logic)
• microcoded control for more complex
  instructions (large numbers of cycles, central
  control store)
• The IA-64 architecture uses a RISC-style ISA and
  can be implemented without a large central
  control store

113
Pentium 4

• Pipelining is important (last IA-32 without it
  was 80386 in 1985)
• Pipelining is used for the simple instructions
  favored by compilersSimply put, a high
  performance implementation needs to ensure that
  the simple instructions execute quickly, and that
  the burden of the complexities of the instruction
  set penalize the complex, less frequently used,
  instructions

Chapter 7
Chapter 6
114
Pentium 4

• Somewhere in all that control we must handle
  complex instructions
• Processor executes simple microinstructions, 70
  bits wide (hardwired)
• 120 control lines for integer datapath (400 for
  floating point)
• If an instruction requires more than 4
  microinstructions to implement, control from
  microcode ROM (8000 microinstructions)
• Its complicated!

115
Chapter 5 Summary

• If we understand the instructions We can build
  a simple processor!
• If instructions take different amounts of time,
  multi-cycle is better
• Datapath implemented using
• Combinational logic for arithmetic
• State holding elements to remember bits
• Control implemented using
• Combinational logic for single-cycle
  implementation
• Finite state machine for multi-cycle
  implementation