Arithmetic for Computers

# Arithmetic for Computers

## Arithmetic for Computers

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
##### Presentation Transcript

1. Arithmetic for Computers CPSC 252 Computer Organization Ellen Walker, Hiram College

2. Encoding Numbers • Two symbols (1 vs. 0) • Binary logic easiest to implement electronically • How to represent arbitrary numbers? • Ascii Characters • 4 bits per decimal digit (Binary Coded Decimal) • Raw binary (base 2 numbers)

3. ASCII vs. BCD vs. Binary • 33 in ASCII 00110011 00110011 (8*log10 bits) • 33 in Binary Coded Decimal 0011 0011 (4*log10 bits) • 33 in Binary 100001 log2 bits

4. Bit Numbering Convention • Bits numbered from right to left, starting with 0 33 = 0 0 1 0 0 0 0 1 Bits: 7 6 5 4 3 2 1 0 • Bit 0 is Least Significant Bit (LSB) • Bit 7 is Most Significant Bit (MSB)

5. Signed Numbers (Sign / Magnitude) • Sign + Magnitude • One bit used for sign (convention 1 = negative) • N-1 bits for magnitude • Difficulties • 2 representations for 0 • Where does the sign go? (MSB vs. LSB) • Complex addition algorithm

6. Two’s Complement • MSB (sign bit) is the -2^(N-1) place and all other bits are 2^x (0<=x<N-1) • Advantages: • No changes to addition algorithm • Easy negation (flip the bits and add 1) • Easy test for negative (MSB is 1)

7. Largest & Smallest Values • N bits can represent 2^N combinations • Unsigned: 0 to (2^N) - 1 • Sign/Magnitude -(2^N-1)+1 to (2^N-1)-1 • 2’s Complement -2^N-1 to (2^N-1)-1 • Arithmetic operations that result in values outside this range cause arithmetic overflow

8. Arithmetic Overflow • Arithmetic overflow occurs when the sign bit is incorrect after an operation • Example (8 bit 2’s complement) 01111111 127 + 00000011 3 -------------------- 10000010 -126

9. Unsigned Integers • If negative values aren’t appropriate, use all bits • Values from 0 to (2^N)-1 (all positive) • Example: addresses

10. Effect on Instruction sets • Instructions for both signed and unsigned values • Loading / storing • Comparisons • Arithmetic / Logic operations

11. Sign Extension • When copying a shorter signed number into a longer register, don’t change the sign! • 11110000 = 111111110000, not 000011110000 • To avoid this, replicate the sign bit all the way to the MSB • Sign bit replication never changes the value of a number

12. Shortcuts for Decimal to Binary • Compute minimal bit pattern for absolute value • Repeated divide-by-two, saving remainders • MSB must be 0 (add one if needed) • If negative value is desired, flip the bits and add 1 • Sign-extend to required number of bits

13. Decimal-to-binary examples • 1037 (16 bit) • -38 (8 bit)

14. Loading Numbers into Registers • A complete register - lw • No special cases, since all 32 bits specified • A byte • lb (load byte) sign-extends • lbu (load byte unsigned) pads with 0’s • A halfword (2 bytes) • lh (load halfword) sign-extends • Lhu (load halfword unsigned) pads with 0’s

15. Comparisons • Set on less than (slt, slti) • Treats registers as signed numbers • Set on less than unsigned (sltu, sltui) • Treats registers as unsigned numbers • Example • \$s1 holds 00….001, \$s2 holds 11..110 • Slt \$t0, \$s1, \$s2 puts 0 in \$t0 • Sltu \$t0, \$s1, \$s2 puts 1 in \$t0

16. Shortcut for 0<=x < y • Bit patterns for negative numbers, when treated as unsigned, are larger than all bit patterns for positive numbers. (Why?) • If (unsigned) x < (unsigned) y, and y is known to be positive, we also know that x is positive. • Use sltu to check both negative and too big in one instruction.

17. Integer Addition & Subtraction • Algorithm in base 2 is same as base 10 • Add up each column of numbers from right to left • A column consists of 2 numbers plus the carry from the previous column (0 if first column) • If the sum is greater than 1, carry a 1 to the next column, e.g. 1+1+1 = 3 (1, carry the 1)

19. Addition example (8 bit 2’s complement) • Carry shown above in red 01100000 00110100 52 + 00010010 18 -------------------- 01000110 70

20. Subtraction • Use the usual subtraction algorithm with borrows • Negate the second operand, then add • Advantage: reuse existing hardware • Negation is easy in hardware • Bit flip • Increment

21. Overflow (Signed Numbers) • Adding two positive numbers • Overflow if sign bit becomes 1 • Adding two negative numbers • Overflow if sign bit becomes 0 • Adding positive and negative number • Overflow cannot occur (why?)

22. Signed Overflow Detection Algorithm • IF the sign bits of the operands are equal, • AND the sign bit of the result does not equal the sign bits of the operands • THEN overflow has occurred

23. Unsigned Integers • Overflow could be detected by having a separate sign bit in addition to the 32 bit register • However, overflow in memory addresses is commonly ignored • “Wrap” from highest to lowest location

24. Relevant Instructions • Add, addi, sub, subi • Detect overflow and cause an exception when it occurs • Addu, addiu, subu • Never cause an overflow exception

25. Dealing with Overflow • Exception code (like a procedure call) • Special conditional branch • Many architectures, not MIPS • “Branch on overflow” instruction • Write your own code • Do an unsigned arithmetic operation • Check signs of operands and result • Use xor operation: 1 if different, 0 if equal (see p. 228)

26. Consequences of Fixed Integer Representations • Limited number of values (both positive and negative) • Moving from shorter to longer format requires sign extension • Unsigned representations allow twice as many values (but no negatives) • Arithmetic overflow must be detected • Correct algorithm on valid inputs yields incorrect result

27. Multiplication • Multiplication result needs twice as many bits • E.g. 7*7 = 49 (7 is 3 bits, 49 is 6 bits) • Multiplication is more complex than addition/subtraction • Develop algorithm, implement using simpler hardware

28. Multiplication Algorithms • Repeated addition • Easy to implement in software • Can only multiply positive numbers directly • Time depends on magnitude of operands • Shift-and add • Efficient use of hardware • Time depends only on width of operands • No special case for negative numbers

29. Shift and Add Algorithm • For each bit in multiplier • If bit = 1, add multiplicand to result • Shift multiplicand left by 1

30. Shift and Add example 10101 21 X 101 5 --------- 10101 000000 (included for completeness) + 1010100 ------------------ 1101001 105 (1+8+32+64)

31. Division • Use the long division algorithm (shift and subtract) • Put 1 in the quotient whenever leading bit is 1, else put 0 in the quotient • When all bits from dividend have been used, if difference is not 0, it is the remainder.

32. Division Example 10101 101 | 1101001 101 0110 101 0101 101 0