Download presentation

Presentation is loading. Please wait.

Published bySimone Wales Modified about 1 year ago

1
1 IKI10230 Pengantar Organisasi Komputer Bab 6: Aritmatika 7 & 14 Mei 2003 Bobby Nazief Qonita Shahab bahan kuliah: Sumber: 1. Hamacher. Computer Organization, ed Materi kuliah CS61C/2000 & CS152/1997, UCB.

2
2 Number Representation

3
3 How to Represent Negative Numbers? °So far, unsigned numbers °Obvious solution: define leftmost bit to be sign! 0 => +, 1 => - Rest of bits can be numerical value of number °Representation called sign and magnitude

4
4 Shortcomings of sign and magnitude? °Arithmetic circuit more complicated Special steps depending whether signs are the same or not °Also, Two zeros 0x = +0 ten 0x = -0 ten What would it mean for programming? °Sign and magnitude abandoned

5
5 Another try: complement the bits °Example: 7 10 = = °Called one’s Complement °Note: postive numbers have leading 0s, negative numbers have leadings 1s °What is ? °How many positive numbers in N bits? °How many negative ones?

6
6 Shortcomings of ones complement? °Arithmetic not too hard °Still two zeros 0x = +0 ten 0xFFFFFFFF = -0 ten What would it mean for programming? °One’s complement eventually abandoned because another solution was better

7
7 Search for Negative Number Representation °Obvious solution didn’t work, find another °What is result for unsigned numbers if tried to subtract large number from a small one? Would try to borrow from string of leading 0s, so result would have a string of leading 1s With no obvious better alternative, pick representation that made the hardware simple: leading 0s positive, leading 1s negative xxx is >=0, xxx is < 0 °This representation called two’s complement

8
8 Two’s Complement Number line °2 N-1 non-negatives °2 N-1 negatives °one zero °how many positives? °comparison? °overflow?

9
9 Two’s Complement Numbers two = 0 ten two = 1 ten two = 2 ten two = 2,147,483,645 ten two = 2,147,483,646 ten two = 2,147,483,647 ten two = –2,147,483,648 ten two = –2,147,483,647 ten two = –2,147,483,646 ten two =–3 ten two =–2 ten two =–1 ten °One zero, 1st bit => >=0 or <0, called sign bit but one negative with no positive –2,147,483,648 ten

10
10 Two’s Complement Formula °Can represent positive and negative numbers in terms of the bit value times a power of 2: d 31 x d 30 x d 2 x d 1 x d 0 x 2 0 °Example two = 1x x x x2 2 +0x2 1 +0x2 0 = = -2,147,483,648 ten + 2,147,483,644 ten = -4 ten °Note: need to specify width: we use 32 bits

11
11 Two’s complement shortcut: Negation °Invert every 0 to 1 and every 1 to 0, then add 1 to the result Sum of number and its one’s complement must be two two = -1 ten Let x’ mean the inverted representation of x Then x + x’ = -1 x + x’ + 1 = 0 x’ + 1 = -x °Example: -4 to +4 to -4 x : two x’: two +1: two ()’: two +1: two

12
12 Two’s comp. shortcut: Sign extension °Convert 2’s complement number using n bits to more than n bits °Simply replicate the most significant bit (sign bit) of smaller to fill new bits 2’s comp. positive number has infinite 0s 2’s comp. negative number has infinite 1s Bit representation hides leading bits; sign extension restores some of them 16-bit -4 ten to 32-bit: two two

13
13 Distribusi Nilai UTS

14
14 Addition of Positive Numbers

15
15 One-Bit Full Adder (1/3) °Example Binary Addition: Carries °Thus for any bit of addition: The inputs are a i, b i, CarryIn i The outputs are Sum i, CarryOut i °Note: CarryIn i+1 = CarryOut i a: b: Sum:

16
16 One-Bit Full Adder (2/3) Definition Sum = ABC in + ABC in + ABC in + ABC in CarryOut = AB + AC in + BC in ¯ ¯ ¯ ¯ ¯ ¯

17
17 One-Bit Full Adder (3/3) °To create one-bit full adder: implement gates for Sum implement gates for CarryOut connect all inputs with same name Sum A B CarryIn CarryOut +

18
18 Ripple-Carry Adders: adding n-bits numbers °Critical Path of n-bit Rippled-carry adder is n*CP CP = 2 gate-delays (C out = AB + AC in + BC in ) A0 B0 1-bit FA Sum0 CarryIn0 CarryOut0 A1 B1 1-bit FA Sum1 CarryIn1 CarryOut1 A2 B2 1-bit FA Sum2 CarryIn2 CarryOut2 A3 B3 1-bit FA Sum3 CarryIn3 CarryOut3

19
19 Fast Adders

20
20 Carry Look Ahead: reducing Carry Propagation delay A B S G P A B S G P A B S G P C1 = G0 + C0 P0 = A0 B0 + C0 (A0+B0) C2 = G1 + G0 P1 + C0 P0 P1 C3 = G2 + G1 P2 + G0 P1 P2 + C0 P0 P1 P2 G = G3 + P3·G2 + P3·P2·G1 + P3·P2·P1·G0 C4 =... P = P3·P2·P1·P0 ABC-out 000“kill” 01C-in“propagate” 10C-in“propagate” 111“generate” A0 B0B0 S0S0 G P P = A + B G = A B Cin

21
21 Carry Look Ahead: Delays °Expression for any carry: C i+1 = G i + P i G i-1 + … + P i P i-1 … P 0 C 0 °All carries can be obtained in 3 gate-delays: 1 needed to developed all P i and G i 2 needed in the AND-OR circuit °All sums can be obtained in 6 gate-delays: 3 needed to obtain carries 1 needed to invert carry 2 needed in the AND-OR circuit of Sum’s circuit °Independent of the number of bits (n) °4-bit Adder: CLA: 6 gate-delays RC: (3*2 + 3) gate-delays °16-bit Adder: CLA: 6 gate-delays RC: (15*2 + 3) gate-delays Sum = ABC in + ABC in + ABC in + ABC in ¯ ¯ ¯ ¯ ¯ ¯

22
22 Cascaded CLA: overcoming Fan-in constraint 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 Delay = = 8 Delay RC = 15*2 + 3 = 33

23
23 Signed Addition & Subtraction

24
24 Addition & Subtraction Operations °Addition: Just add the two numbers Ignore the Carry-out from MSB Result will be correct, provided there’s no overflow (+5) (+2) (+7) (+5) (-6) (-1) (-5) (-2) (-7) (+7) (-3) (+4) (+2) (+4) (-4) (-2) (-2) (-5) (+5) (+3) °Subtraction: Form 2’s complement of the subtrahend Add the two numbers as in Addition

25
25 Overflow °Examples: = 10 but... ° - 4 5 = - 9 but... 2’s ComplementBinaryDecimal Decimal – 6 – 4 – 5 7

26
26 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 – 6 –4 – 5 7 0

27
27 Overflow Detection Logic °Carry into MSB ° Carry out of MSB For a N-bit Adder: Overflow = CarryIn[N - 1] XOR CarryOut[N - 1] A0 B0 1-bit FA Result0 CarryIn0 CarryOut0 A1 B1 1-bit FA Result1 CarryIn1 CarryOut1 A2 B2 1-bit FA Result2 CarryIn2 A3 B3 1-bit FA Result3 CarryIn3 CarryOut3 Overflow XYX XOR Y

28
28 Arithmetic & Branching Conditions

29
29 Condition Codes °CC Flags will be set/cleared by arithmetic operations: N (negative): 1 if result is negative (MSB = 1), otherwise 0 C (carry): 1 if carry-out(borrow) is generated, otherwise 0 V (overflow): 1 if overflow occurs, otherwise 0 Z (zero): 1 if result is zero, otherwise (+5) (-6) (-1) (+7) (-3) (+4) (+5) (+4) (-7?) (+3) (-3) (0)

30
30 Multiplication of Positive Numbers

31
31 Unsigned Multiplication °Paper and pencil example (unsigned): Multiplicand 1101(13) Multiplier 1011(11) Product (143) °m bits x n bits = m+n bit product °Binary makes it easy: 0 => place 0 ( 0 x multiplicand) 1 => place a copy ( 1 x multiplicand)

32
32 Unsigned Combinational Multiplier °Stage i accumulates A * 2 i if B i == 1 B0B0 A0A0 A1A1 A2A2 A3A3 A0A0 A1A1 A2A2 A3A3 A0A0 A1A1 A2A2 A3A3 A0A0 A1A1 A2A2 A3A3 B1B1 B2B2 B3B3 P0P0 P1P1 P2P2 P3P3 P4P4 P5P5 P6P6 P7P7 0000

33
33 How does it work? °at each stage shift A left ( x 2) °use next bit of B to determine whether to add in shifted multiplicand °accumulate 2n bit partial product at each stage B0B0 A0A0 A1A1 A2A2 A3A3 A0A0 A1A1 A2A2 A3A3 A0A0 A1A1 A2A2 A3A3 A0A0 A1A1 A2A2 A3A3 B1B1 B2B2 B3B3 P0P0 P1P1 P2P2 P3P3 P4P4 P5P5 P6P6 P7P

34
34 Multiplier Circuit Product (Multiplier) Multiplicand 4-bit FA Add/NoAdd Control 4 bits 8 bits Shift Right MUX 0 4 bits C Multiplicand 1101 C ProductMultiplier Add Shift Add Shift NoAdd Shift Add Shift

35
35 Signed-Operand & Multiplication

36
36 Signed Multiplication °Negative Multiplicand: Multiplicand 10011(-13) Multiplier 01011(+11) Product (-143) °Negative Multiplier: Form 2’s complement of both multiplier and multiplicand Proceed as above

37
37 Motivation for Booth’s Algorithm °Works well for both Negative & Positive Multipliers °Example 2 x 6 = 0010 x 0110: 0010 x shift (0 in multiplier) add (1 in multiplier) add (1 in multiplier) shift (0 in multiplier) °FA with add or subtract gets same result in more than one way: 6= – = – = °For example ° 0010 x shift (0 in multiplier) sub (first 1 in multpl.) shift (mid string of 1s) add (prior step had last 1)

38
38 Booth’s Algorithm Current BitBit to the RightExplanationExampleOp 1 0Begins run of 1s sub 1 1Middle of run of 1s none 0 1End of run of 1s add 0 0Middle of run of 0s none Originally for Speed (when shift was faster than add) Small number of additions needed when multiplier has a few large blocks of 1s

39
39 Booths Example (2 x 7) 1a. P = P - m shift P (sign ext) 1b > nop, shift > nop, shift > add 4a shift 4b done OperationMultiplicandProductnext? 0. initial value > sub

40
40 Booths Example (2 x -3) 1a. P = P - m shift P (sign ext) 1b > add a shift P 2b > sub a shift 3b > nop 4a shift 4b done OperationMultiplicandProductnext? 0. initial value > sub

41
41 Fast Multiplication (read yourself!)

42
42 Integer Division

43
43 Divide: Paper & Pencil 1001 Quotient Divisor Dividend – – Remainder (or Modulo result) °See how big a number can be subtracted, creating quotient bit on each step Binary => 1 * divisor or 0 * divisor °Dividend = Quotient x Divisor + Remainder => | Dividend | = | Quotient | + | Divisor |

44
44 Division Circuit Remainder (Quotient) Divisor 33-bit FA Control 33 bits 65 bits Shift Left 33 bits Q Setting Sign-bit Checking

45
45 RemainderQuotient Initially Shift _ Sub(-11)11101 Set q Restore Shift _ Sub(-11) Set q Restore Shift _ Sub(-11) Set q Shift _ Sub(-11) _ Set q Restore Restoring Division Algorithm 0010 Quotient Divisor Dividend 11 10Remainder

46
46 Floating-point Numbers & Operations

47
47 Review of Numbers °Computers are made to deal with numbers °What can we represent in N bits? Unsigned integers: 0to2 N - 1 Signed Integers (Two’s Complement) -2 (N-1) to 2 (N-1) - 1

48
48 Other Numbers °What about other numbers? Very large numbers? (seconds/century) 3,155,760, ( x 10 9 ) Very small numbers? (atomic diameter) ( x ) Rationals (repeating pattern) 2/3 ( ) Irrationals 2 1/2 ( ) Transcendentals e ( ), ( ) °All represented in scientific notation

49
49 Scientific Notation Review 6.02 x radix (base) decimal pointmantissa exponent °Normalized form: no leadings 0s (exactly one digit to left of decimal point) °Alternatives to representing 1/1,000,000,000 Normalized: 1.0 x Not normalized: 0.1 x 10 -8,10.0 x

50
50 Scientific Notation for Binary Numbers 1.0 two x 2 -1 radix (base) “binary point”Mantissa exponent °Computer arithmetic that supports it called floating point, because it represents numbers where binary point is not fixed, as it is for integers Declare such variable in C as float

51
51 Floating Point Representation (1/2) °Normal format: +1.xxxxxxxxxx two *2 yyyy two °Multiple of Word Size (32 bits) 0 31 SExponent Significand 1 bit8 bits23 bits °S represents Sign Exponent represents y’s Significand represents x’s °Represent numbers as small as 2.0 x to as large as 2.0 x 10 38

52
52 Floating Point Representation (2/2) °What if result too large? (> 2.0x10 38 ) Overflow! Overflow => Exponent larger than represented in 8-bit Exponent field °What if result too small? (>0, < 2.0x ) Underflow! Underflow => Negative exponent larger than represented in 8-bit Exponent field °How to reduce chances of overflow or underflow?

53
53 Double Precision Fl. Pt. Representation °Next Multiple of Word Size (64 bits) °Double Precision (vs. Single Precision) C variable declared as double Represent numbers almost as small as 2.0 x to almost as large as 2.0 x But primary advantage is greater accuracy due to larger significand 0 31 SExponent Significand 1 bit11 bits20 bits Significand (cont’d) 32 bits

54
54 IEEE 754 Floating Point Standard (1/4) °Single Precision, DP similar °Sign bit:1 means negative 0 means positive °Significand: To pack more bits, leading 1 implicit for normalized numbers bits single, bits double always true: 0 < Significand < 1(for normalized numbers) °Note: 0 has no leading 1, so reserve exponent value 0 just for number 0

55
55 IEEE 754 Floating Point Standard (2/4) °Kahan wanted FP numbers to be used even if no FP hardware; e.g., sort records with FP numbers using integer compares °Could break FP number into 3 parts: compare signs, then compare exponents, then compare significands °Wanted it to be faster, single compare if possible, especially if positive numbers °Then want order: Highest order bit is sign ( negative < positive) Exponent next, so big exponent => bigger # Significand last: exponents same => bigger #

56
56 IEEE 754 Floating Point Standard (3/4) °Negative Exponent? 2’s comp? 1.0 x 2 -1 v. 1.0 x2 +1 (1/2 v. 2) / This notation using integer compare of 1/2 v. 2 makes 1/2 > 2! °Instead, pick notation is most negative, and is most positive 1.0 x 2 -1 v. 1.0 x2 +1 (1/2 v. 2) 1/

57
57 IEEE 754 Floating Point Standard (4/4) °Called Biased Notation, where bias is number subtract to get real number IEEE 754 uses bias of 127 for single prec. Subtract 127 from Exponent field to get actual value for exponent 1023 is bias for double precision °Summary (single precision): 0 31 SExponent Significand 1 bit8 bits23 bits °(-1) S x (1 + Significand) x 2 (Exponent-127) Double precision identical, except with exponent bias of 1023

58
58 Special Numbers °What have we defined so far? (Single Precision) ExponentSignificandObject 000 0nonzero??? 1-254anything+/- fl. pt. # 2550+/- infinity 255nonzeroNaN

59
59 Infinity and NaNs result of operation overflows, i.e., is larger than the largest number that can be represented overflow is not the same as divide by zero (raises a different exception) +/- infinity S It may make sense to do further computations with infinity e.g., X/0 > Y may be a valid comparison Not a number, but not infinity (e.q. sqrt(-4)) invalid operation exception (unless operation is = or =) NaN S non-zero NaNs propagate: f(NaN) = NaN HW decides what goes here

60
60 FP Addition °Much more difficult than with integers °Can’t just add significands °How do we do it? De-normalize to match exponents Add significands to get resulting one Keep the same exponent Normalize (possibly changing exponent) °Note: If signs differ, just perform a subtract instead.

61
61 FP Subtraction °Similar to addition °How do we do it? De-normalize to match exponents Subtract significands Keep the same exponent Normalize (possibly changing exponent)

62
62 Extra Bits for rounding "Floating Point numbers are like piles of sand; every time you move one you lose a little sand, but you pick up a little dirt." How many extra bits? IEEE: As if computed the result exactly and rounded. Addition: 1.xxxxx1.xxxxx1.xxxxx +1.xxxxx0.001xxxxx0.01xxxxx 1x.xxxxy 1.xxxxxyyy 1x.xxxxyyy post-normalization pre-normalization pre and post °Guard Digits: digits to the right of the first p digits of significand to guard against loss of digits – can later be shifted left into first P places during normalization. °Addition: carry-out shifted in °Subtraction: borrow digit and guard °Multiplication: carry and guard, Division requires guard

63
63 Rounding Digits normalized result, but some non-zero digits to the right of the significand --> the number should be rounded E.g., B = 10, p = 3: = * 10 = * 10 = * 10 2-bias - one round digit must be carried to the right of the guard digit so that after a normalizing left shift, the result can be rounded, according to the value of the round digit IEEE Standard: four rounding modes: round to nearest (default) round towards plus infinity round towards minus infinity round towards 0 round to nearest: round digit < B/2 then truncate > B/2 then round up (add 1 to ULP: unit in last place) = B/2 then round to nearest even digit it can be shown that this strategy minimizes the mean error introduced by rounding

64
64 Sticky Bit Additional bit to the right of the round digit to better fine tune rounding d0. d1 d2 d3... dp X... X X X S X X S + Sticky bit: set to 1 if any 1 bits fall off the end of the round digit d0. d1 d2 d3... dp X... X X X 0 X X 0 - d0. d1 d2 d3... dp X... X X X 1 - generates a borrow Rounding Summary: Radix 2 minimizes wobble in precision Normal operations in +,-,*,/ require one carry/borrow bit + one guard digit One round digit needed for correct rounding Sticky bit needed when round digit is B/2 for max accuracy Rounding to nearest has mean error = 0 if uniform distribution of digits are assumed

65
65 Denormalized Numbers bias 1-bias 2-bias B = 2, p = 4 normal numbers with hidden bit --> denorm gap The gap between 0 and the next representable number is much larger than the gaps between nearby representable numbers. IEEE standard uses denormalized numbers to fill in the gap, making the distances between numbers near 0 more alike bias 1-bias 2-bias p bits of precision p-1 bits of precision same spacing, half as many values! NOTE: PDP-11, VAX cannot represent subnormal numbers. These machines underflow to zero instead.

Similar presentations

© 2017 SlidePlayer.com Inc.

All rights reserved.

Ads by Google