Arithmetic. Chapter 3 Computer Organization and Design

Transcription

1 Arithmetic Chapter 3 Computer Organization and Design

2 Addition Addition is similar to decimals = Subtraction (negate) =

3 Over(under)flow For signed addition If signs are the same It has to agree with the arguments If signs different There can be no over(under)flow.

4 Over(under)flow For signed subtraction If signs are the same There can be no over(under)flow If signs are different It has to match the subtractant (zero?)

5 Over(under)flow For unsigned addition If result smaller than the argument, it is overflow For unsigned subtraction If the result is greater than the subtractant it is overflow

6 In practice... MIPS signed ops can cause overflow Causes exception and saves the offending instruction in Exception PC (mfc0) Unsigned ops will not cause C ignores integer overflows.

7 Multimedia Operations Operations like MMX, SSE, etc Graphics and image processing often work with 8 or 16 bits Treat a 32 bit register as 4 8 bit registers or 2 16 bits registers. Break the carry chain

8 Multiplication 1000 x =

9 Hardware Multiplicant Adder Multiplier Product Control

10 Can we speed up? All operations could be done in parallel Have a cascade of adders and add them all Gate delays will be a problem Have a tree of additions Logarithmic time Use carry save adders

11 Cascade of Adders multiplier multiplicant & & & Adder & Adder Adder

12 Tree of Adders mplier3*mcant mplier2*mcant mplier1*mcant mplier0*mcant Adder Adder Adder Pr7 Pr6 2 Pr1 Pr0

13 Division unsigned long int rem, ldvsr; int i; rem = divident; ldvsr = ((long)divisor)<<31; quot = 0; for (i=1; i<32; i++){ quot = quot<<1; if (rem>=ldvsr){ rem =ldvsr; quot+=1; } }

14 Doing it faster Hard! The reason is that we do not know the reminder in advance to compare Cannot unroll the loop Can do it with octals or hex Resembles the pen an pencil decimal method Tricky on hardware

15 Multiply on MIPS Result can be up to 64 bits All registers are 32 bits MIPS uses two special registers Hi, Lo And two special commands mfhi (move from hi) mflo (move from lo)

16 Divide on MIPS Similar problem We need a 32 bit register for quotient Another for remainder We use the same registers Hi, Lo, Hi: remainder Lo: quotient

17 Signed Mult/Div We have two versions mult/multu and div/divu for signed and unsigned. For signed mult CPU converts to positive and remembers the signs If signs the same result is positive o/w negative

18 Signed Mult/Div Division is tricky Follows the formula Divident = q * divisor + r For example 7 = 2 * = ( 2)* 3 + ( 1) 7 = 2 *( 3)+ ( 1) 7 = ( 2)*( 3)+ 1

19 The Rule If divident and divisor have same sign Quotient is positive If divident and divisor have different sign Quotient is negative The sign of the reminder... Matches the divident

20 Floating point So far we dealt with integers A.K.A. Fixed point In mathematics we have reals We can only approximate reals We do not distinguish rationals and irrationals We follow the scientific notation The one preferred by scientists

21 Scientific notation 32.43*10 2 =.3243 For computer use we improve it * = We further improve it (normalize) * = Since the first bit is always 1 We make it implicit (do not include it in the representation)

22 Representation * We need Sign Fraction Exponent We need to compromise between space for fraction and space for exponent We care more for accuracy that representing large numbers

23 MIPS Representation (32 bits) Sign: 1 bit, 0: positive, 1: negative Exponent: 8 bits biased complement of 2 Fraction: 23 bits sign and magnitude Overflow: too big (positive) or too small (negative) to be represented Underflow: too small (positive) or too big (negative) to be represented

24 MIPS Representation (64 bits) Sign: 1 bit Exponent: 11 bits Fraction: 52 bits.

25 IEEE 754 Floating point std Introduced to facilitate the exchange of floating point numbers, increase portability and imporve the quality of computation. MIPS follows IEEE 754 Has implicit leading bit is represented as and the leading 1 is implied Definition: significant

26 Special Numbers How do we represent zero? We can't if we have implicit leading bit We define zero to be (all zeros) The exponent is biased (add 127 or 1023) For normalized numbers ( 1) sign * ( 1+ Fraction ) * 2 (exponent bias) For de normalized numbers (when exponent has the smallest value) ( 1) sign * ( Fraction ) * 2 (exponent bias)

27 Special Numbers Infinity (positive or negative) Exponent 255, fraction 0 Not a Number (NaN) Exponent 255, fraction not zero Division by zero gives infinity Infinity minus infinity gives NaN

28 Comparisons in Floating Point Placement of sign, bias of exponent chosen to make comparison a bit simpler. No need to convert to a different representation

29 Floating Point Addition Add 1.111*2 1 and 1.011*2 1. Step 1: shift the smallest in abs. val. to make exponents the same *2 1. Step 2: Add the fractions = Step 3: Normalize *2 1 = *2 2 = Step 4: Round (Might need to jump to Step: 3)

30 Floating Point Multiplication 1.100*2 1 * 1.110*2 2 Step 1: add the exponents: 1 2 = 3 Step 2: multiply the significands 1.100*1.110 = Step 3: Normalize and check for overflow *2 3 Step 4: Round: 1.011*2 3 Step 5: Adjust signs

31 Example void mm(double x[ ][ ], double y[ ][ ], double z[ ][ ]) { int, i, j, k; for (i=0; i!=32; i++) for (j=0; i!=32; j++) for (k=0; k!=32; k++) x[i][j] += y[i][k] * z[k][j]; }

32 Example void mm(double x[ ][ ], double y[ ][ ], double z[ ][ ]) Mm: ; save s0, s1, s2 on stack addi $sp, 12 { int, i, j, k; for (i=0; i!=32; i++) sw $s2, 8($sp) for (j=0; i!=32; j++) sw $s1, 4($sp) for (k=0; k!=32; k++) sw $s0, 0($sp) mmexit: ; restore from stack } x[i][j] += y[i][k] * z[k][j]; lw lw lw $s2, 8($sp) $s1, 4($sp) $s0, 0($sp) addi $sp, 12 jr $ra

33 li $t1, 32 # mat. size li $s0, 0 # i=0 Example L1: li $s1, 0 # j = 0 void mm(double x[ ][ ], double y[ ][ ], double z[ ][ ]) L2: li $s2, 0 # k = 0 { sll $t2, $s0, 5 # i rows int, i, j, k; addu $t2, $t2, $s1 # j elements for (i=0; i!=32; i++) sll $t2, $t2, 3 # doubles are 8 bytes for (j=0; i!=32; j++) addu $t2, $a0, $t2 # for (k=0; k!=32; k++) l.d $f4, 0($t2) x[i][j] += y[i][k] * z[k][j]; L3: sll $t0, $s2, 5 # Load z[k][j] }... l.d $f16, 0($t0)... # Load y[i][k] mul.d $f16, $f18, $f16 add.d $f4, $f4, $f16 # f4 += y[i][k]*z[k][j] addiu $s2,$s2, 1 bne s.d $s2, $t1, L3 $f4, 0($t2)... bne $s0, $t1, L1

34 Floating point instructions add.s, sub.s, mul.s div.s add.d sub.d, mul.d div.d lwc1, swc1, mfc1, mtc1 c.lt.s, c.gt.s, c.eq.s, c.ne.s, c.le.s, c.ge.s c.lt.d, c.gt.d, c.eq.d, c.ne.d, c.le.d, c.ge.d bc1t, bc1f

35 Floating point registers f0..f3: return results f4..f11, f16..f19: temporary f12..f15: arguments f20..f31: saved temporary

36 Accuracy To round properly we need to cary extra bits (typically two) Many architectures have multiply and add in one instruction A += b*c Floating point arithmetic is not associative ( ) 10 10!= 1