# .1 1999©UCB CPSC 161 Lecture 6 Prof. L.N. Bhuyan

## Presentation on theme: ".1 1999©UCB CPSC 161 Lecture 6 Prof. L.N. Bhuyan"— Presentation transcript:

.1 1999©UCB CPSC 161 Lecture 6 Prof. L.N. Bhuyan http://www.cs.ucr.edu/~bhuyan/cs161/index.html

.2 1999©UCB °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...2 n -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? Numbers

.3 1999©UCB ° Sign Magnitude: One's Complement Two's Complement 000 = +0000 = +0000 = +0 001 = +1001 = +1001 = +1 010 = +2010 = +2010 = +2 011 = +3011 = +3011 = +3 100 = -0100 = -3100 = -4 101 = -1101 = -2101 = -3 110 = -2110 = -1110 = -2 111 = -3111 = -0111 = -1 °Issues: balance, number of zeros, ease of operations °Which one is best? Why? Possible Representations

.4 1999©UCB °32 bit signed numbers: 0000 0000 0000 0000 0000 0000 0000 0000 two = 0 ten 0000 0000 0000 0000 0000 0000 0000 0001 two = + 1 ten 0000 0000 0000 0000 0000 0000 0000 0010 two = + 2 ten... 0111 1111 1111 1111 1111 1111 1111 1110 two = + 2,147,483,646 ten 0111 1111 1111 1111 1111 1111 1111 1111 two = + 2,147,483,647 ten 1000 0000 0000 0000 0000 0000 0000 0000 two = – 2,147,483,648 ten 1000 0000 0000 0000 0000 0000 0000 0001 two = – 2,147,483,647 ten 1000 0000 0000 0000 0000 0000 0000 0010 two = – 2,147,483,646 ten... 1111 1111 1111 1111 1111 1111 1111 1101 two = – 3 ten 1111 1111 1111 1111 1111 1111 1111 1110 two = – 2 ten 1111 1111 1111 1111 1111 1111 1111 1111 two = – 1 ten maxint minint MIPS

.5 1999©UCB °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 -> 0000 0010 1010 -> 1111 1010 "sign extension" (lbu vs. lb) Two's Complement Operations

.6 1999©UCB °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” Addition & Subtraction

.7 1999©UCB MIPS ALU Instructions °Add, AddU, Sub, SubU, AddI, AddIU => 2’s complement adder/sub with overflow detection °And, Or, AndI, OrI, Xor, Xori, Nor => Logical AND, logical OR, XOR, nor °SLTI, SLTIU (set less than) => 2’s complement adder with inverter, check sign bit of result

.8 1999©UCB MIPS arithmetic instruction format R-type: I-Type: 3125201550 opRsRtRdfunct opRsRtImmed 16 Typeopfunct ADDI10xx ADDIU11xx SLTI12xx SLTIU13xx ANDI14xx ORI15xx XORI16xx LUI17xx Typeopfunct ADD0040 ADDU0041 SUB0042 SUBU0043 AND0044 OR0045 XOR0046 NOR0047 Typeopfunct 0050 0051 SLT0052 SLTU0053

.9 1999©UCB Refined Requirements (1) Functional Specification inputs: 2 x 32-bit operands A, B, 4-bit mode outputs:32-bit result S, 1-bit carry, 1 bit overflow operations:add, addu, sub, subu, and, or, xor, nor, slt, sltU (2) Block Diagram ALU AB m ovf S 32 4 c

.10 1999©UCB Refined Diagram: bit-slice ALU °Co = a.b + a.Cin + b.Cin °Sum = AB M S 32 4 Ovflw ALU0 a0b0 m cinco s0 ALU0 a31b31 m cinco s31

.11 1999©UCB Seven plus a MUX ? A B 1-bit Full Adder CarryOut Mux CarryIn Result °Design trick 2: take pieces you know (or can imagine) and try to put them together °Design trick 3: solve part of the problem and extend add and or S-select

.12 1999©UCB Additional operations °A - B = A + (– B) form two complement by invert and add one A B 1-bit Full Adder CarryOut Mux CarryIn Result add and or S-select invert Set-less-than? – left as an exercise

.13 1999©UCB °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 ? Detecting Overflow

.14 1999©UCB °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 Effects of Overflow

.15 1999©UCB Overflow Detection °Overflow: the result is too large (or too small) to represent properly Example: - 8 < = 4-bit binary number <= 7 °When adding operands with different signs, overflow cannot occur! °Overflow occurs when adding: 2 positive numbers and the sum is negative 2 negative numbers and the sum is positive °On your own: Prove you can detect overflow by: Carry into MSB ° Carry out of MSB 0111 0011+ 1010 1 1100 1011+ 0111 110 7 3 1 – 6 –4 – 5 7 0

.16 1999©UCB Overflow Detection Logic °Carry into MSB ° Carry out of MSB For a N-bit ALU: Overflow = CarryIn[N - 1] XOR CarryOut[N - 1] A0 B0 1-bit ALU Result0 CarryIn0 CarryOut0 A1 B1 1-bit ALU Result1 CarryIn1 CarryOut1 A2 B2 1-bit ALU Result2 CarryIn2 A3 B3 1-bit ALU Result3 CarryIn3 CarryOut3 Overflow XYX XOR Y 000 011 101 110

.17 1999©UCB But What about Performance? °Critical Path of n-bit Rippled-carry adder is n*CP A0 B0 1-bit ALU Result0 CarryIn0 CarryOut0 A1 B1 1-bit ALU Result1 CarryIn1 CarryOut1 A2 B2 1-bit ALU Result2 CarryIn2 CarryOut2 A3 B3 1-bit ALU Result3 CarryIn3 CarryOut3 Design Trick: throw hardware at it

.18 1999©UCB Carry Look Ahead (Design trick: peek) ABC-out 000“kill” 01C-in“propagate” 10C-in“propagate” 111“generate” A0 B1 S G P P = A and B G = A xor B A B S G P A B S G P A B S G P Cin C1 =G0 + C0  P0 C2 = G1 + G0  P1 + C0  P0  P1 C3 = G2 + G1  P2 + G0  P1  P2 + C0  P0  P1  P2 G C4 =... P

.19 1999©UCB Cascaded Carry Look-ahead (16-bit): Abstraction CLACLA 4-bit Adder 4-bit Adder 4-bit Adder C1 =G0 + C0  P0 C2 = G1 + G0  P1 + C0  P0  P1 C3 = G2 + G1  P2 + G0  P1  P2 + C0  P0  P1  P2 G P G0 P0 C4 =... C0

.20 1999©UCB Additional MIPS ALU requirements °Mult, MultU, Div, DivU (next lecture) => Need 32-bit multiply and divide, signed and unsigned °Sll, Srl, Sra (next lecture) => Need left shift, right shift, right shift arithmetic by 0 to 31 bits °Nor (leave as exercise to reader) => logical NOR or use 2 steps: (A OR B) XOR 1111....1111

.21 1999©UCB °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_1011 (multiplier) °Negative numbers: convert and multiply there are better techniques, we won’t look at them Multiplication

.22 1999©UCB Multiplication: Implementation Datapath Control

.23 1999©UCB Final Version What goes here? Multiplier starts in right half of product

.24 1999©UCB 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  10 9 °Representation: sign, exponent, significand: (–1) sign  significand  2 exponent 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

.25 1999©UCB 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  significand)  2 exponent – bias °Example: decimal: -.75 = - ( ½ + ¼ ) binary: -.11 = -1.1 x 2 -1 floating point: exponent = 126 = 01111110 IEEE single precision: 10111111010000000000000000000000