View
231
Download
4
Category
Preview:
Citation preview
3-1 Chapter 3 - Arithmetic
Computer Architecture and Organization by M. Murdocca and V. Heuring © 2007 M. Murdocca and V. Heuring
Computer Architecture andOrganization
Miles Murdocca and Vincent Heuring
Chapter 3 – Arithmetic
3-2 Chapter 3 - Arithmetic
Computer Architecture and Organization by M. Murdocca and V. Heuring © 2007 M. Murdocca and V. Heuring
Chapter Contents3.1 Fixed Point Addition and Subtraction3.2 Fixed Point Multiplication and Division3.3 Floating Point Arithmetic3.4 High Performance Arithmetic
3-3 Chapter 3 - Arithmetic
Computer Architecture and Organization by M. Murdocca and V. Heuring © 2007 M. Murdocca and V. Heuring
Computer Arithmetic
• Using number representations from Chapter 2, we will explore fourbasic arithmetic operations: addition, subtraction, multiplication,and division.
• Significant issues include: fixed point vs. floating point arithmetic,overflow and underflow, handling of signed numbers, andperformance.
• We look first at fixed point arithmetic, and then at floating pointarithmetic.
3-4 Chapter 3 - Arithmetic
Computer Architecture and Organization by M. Murdocca and V. Heuring © 2007 M. Murdocca and V. Heuring
Binary Numbers can be Representedon a Number Circle
• Numbers are added or subtracted on the number circle by traversingclockwise for addition and counterclockwise for subtraction.
• Unlike the number line (a) where overflow never occurs, overflowoccurs when a transition is made from+3 to -4 while proceeding aroundthe number circle when adding,or from -4 to +3 whilesubtracting.
3-5 Chapter 3 - Arithmetic
Computer Architecture and Organization by M. Murdocca and V. Heuring © 2007 M. Murdocca and V. Heuring
Overflow• Overflow occurs when the addition of two positive numbers produces a
negative result, or when the addition of two negative numbers producesa positive result. Adding operands of unlike signs never produces anoverflow.
• Notice that discarding the carry out of the most significant bit duringtwo’s complement addition is a normal occurrence, and does not byitself indicate overflow.
• As an example of overflow, consider adding (80 + 80 = 160)10, whichproduces a result of -9610 in an 8-bit two’s complement format: 01010000 = 80
+ 01010000 = 80
----------
10100000 = -96 (not 160 because the sign bit is 1.)
3-6 Chapter 3 - Arithmetic
Computer Architecture and Organization by M. Murdocca and V. Heuring © 2007 M. Murdocca and V. Heuring
Sign Extension• The leftmost bit is assigned to the sign. What happens to the sign bit if
we place a number into a larger or smaller word? For positive numbers,all that we need to do is pad the left side with 0s:
• For negative numbers, we cannot simply pad the left side with 0sbecause that would change the value of the number:
3-7 Chapter 3 - Arithmetic
Computer Architecture and Organization by M. Murdocca and V. Heuring © 2007 M. Murdocca and V. Heuring
Sign Extension (continued)• As it turns out, all that we need to do is copy the sign bit for as many
places as there are to the left and the number will be correctlyextended, regardless of the value of the sign. This is known as signextension:
3-8 Chapter 3 - Arithmetic
Computer Architecture and Organization by M. Murdocca and V. Heuring © 2007 M. Murdocca and V. Heuring
Sign Extension (continued)
• If we want to reduce the size of the word, we can simply remove bitson the left and the resulting sign will be correct, as long as the numbercan be represented in the remaining bits:
3-9 Chapter 3 - Arithmetic
Computer Architecture and Organization by M. Murdocca and V. Heuring © 2007 M. Murdocca and V. Heuring
Ripple Carry Adder• Two binary numbers A and B are added from right to left, creating a
sum and a carry at the outputs of each full adder for each bitposition.
3-10 Chapter 3 - Arithmetic
Computer Architecture and Organization by M. Murdocca and V. Heuring © 2007 M. Murdocca and V. Heuring
Constructing Larger Adders• A 16-bit adder can be made up of a cascade of four 4-bit ripple-carry
adders.
3-11 Chapter 3 - Arithmetic
Computer Architecture and Organization by M. Murdocca and V. Heuring © 2007 M. Murdocca and V. Heuring
Full Subtractor• Truth table and schematic symbol for a ripple-borrow subtractor:
3-12 Chapter 3 - Arithmetic
Computer Architecture and Organization by M. Murdocca and V. Heuring © 2007 M. Murdocca and V. Heuring
Ripple-Borrow Subtractor• A ripple-borrow subtractor can be composed of a cascade of full
subtractors.
• Two binary numbers A and B are subtracted from right to left, creating adifference and a borrow at the outputs of each full subtractor for eachbit position.
3-13 Chapter 3 - Arithmetic
Computer Architecture and Organization by M. Murdocca and V. Heuring © 2007 M. Murdocca and V. Heuring
Combined Adder/Subtractor• A single ripple-carry adder can perform both addition and subtraction,
by forming the two’s complement negative for B when subtracting.(Note that +1 is added at c0 for two’s complement.)
3-14 Chapter 3 - Arithmetic
Computer Architecture and Organization by M. Murdocca and V. Heuring © 2007 M. Murdocca and V. Heuring
One’s Complement Addition• An example of one’s complement integer addition with an end-around
carry:
3-15 Chapter 3 - Arithmetic
Computer Architecture and Organization by M. Murdocca and V. Heuring © 2007 M. Murdocca and V. Heuring
Number Circle (Revisited)• Number circle for a three-bit signed one’s complement representation.
Notice the two representations for 0.
3-16 Chapter 3 - Arithmetic
Computer Architecture and Organization by M. Murdocca and V. Heuring © 2007 M. Murdocca and V. Heuring
End-Around Carry for Fractions• The end-around carry complicates one’s complement addition for non-
integers, and is generally not used for this situation.
• The issue is that the distance between the two representations of 0 is1.0, whereas the rightmost fraction position is less than 1.
3-17 Chapter 3 - Arithmetic
Computer Architecture and Organization by M. Murdocca and V. Heuring © 2007 M. Murdocca and V. Heuring
Multiplication Example• Multiplication of two 4-bit unsigned binary integers produces an 8-bit
result.
• Multiplication of two 4-bit signed binary integers produces only a 7-bitresult (each operand reduces to a sign bit and a 3-bit magnitude foreach operand, producing a sign-bit and a 6-bit result).
3-18 Chapter 3 - Arithmetic
Computer Architecture and Organization by M. Murdocca and V. Heuring © 2007 M. Murdocca and V. Heuring
A Serial Multiplier
3-19 Chapter 3 - Arithmetic
Computer Architecture and Organization by M. Murdocca and V. Heuring © 2007 M. Murdocca and V. Heuring
Example of Multiplication Using SerialMultiplier
3-20 Chapter 3 - Arithmetic
Computer Architecture and Organization by M. Murdocca and V. Heuring © 2007 M. Murdocca and V. Heuring
Example of Base 2 Division• (7 / 3 = 2)10 with a remainder R of 1.
• Equivalently, (0111/ 11 = 10)2 with a remainder R of 1.
3-21 Chapter 3 - Arithmetic
Computer Architecture and Organization by M. Murdocca and V. Heuring © 2007 M. Murdocca and V. Heuring
Serial Divider
3-22 Chapter 3 - Arithmetic
Computer Architecture and Organization by M. Murdocca and V. Heuring © 2007 M. Murdocca and V. Heuring
Division Example Using Serial Divider
3-23 Chapter 3 - Arithmetic
Computer Architecture and Organization by M. Murdocca and V. Heuring © 2007 M. Murdocca and V. Heuring
Multiplication of Signed Integers• Sign extension to the target word size is needed for the negative
operand(s).
• A target word size of 8 bits is used here for two 4-bit signed operands,but only a 7-bit target word size is needed for the result.
3-24 Chapter 3 - Arithmetic
Computer Architecture and Organization by M. Murdocca and V. Heuring © 2007 M. Murdocca and V. Heuring
Carry-Lookahead Additionsi = aibici + aibici + aibici + aibici
ci+1 = bici + aici + aibi
ci+1 = aibi + (ai + bi)ci
ci+1 = Gi + Pici
Gi = aibi and Pi = ai + bi
c0 = 0
c1 = G0
c2 = G1 + P1G0
c3 = G2 + P2G1 + P2P1G0
c4 = G3 + P3G2 + P3P2G1 + P3P2P1G0
• Carries are represented interms of Gi (generate) and Pi(propagate) expressions.
3-25 Chapter 3 - Arithmetic
Computer Architecture and Organization by M. Murdocca and V. Heuring © 2007 M. Murdocca and V. Heuring
Carry Lookahead Adder• Maximum gate delay
for the carrygeneration is only 3.The full addersintroduce two moregate delays. Worstcase path is 5 gatedelays.
3-26 Chapter 3 - Arithmetic
Computer Architecture and Organization by M. Murdocca and V. Heuring © 2007 M. Murdocca and V. Heuring
Floating Point Arithmetic• Floating point arithmetic differs from integer arithmetic in that
exponents must be handled as well as the magnitudes of theoperands.
• The exponents of the operands must be made equal for addition andsubtraction. The fractions are then added or subtracted as appropriate,and the result is normalized.
• Ex: Perform the floating point operation: (.101 × 23 + .111 × 24)2
• Start by adjusting the smaller exponent to be equal to the largerexponent, and adjust the fraction accordingly. Thus we have .101 × 23
= .010 × 24, losing .001 × 23 of precision in the process.
• The resulting sum is (.010 + .111) × 24 = 1.001 × 24 = .1001 × 25, androunding to three significant digits, .100 × 25, and we have lost another0.001 × 24 in the rounding process.
3-27 Chapter 3 - Arithmetic
Computer Architecture and Organization by M. Murdocca and V. Heuring © 2007 M. Murdocca and V. Heuring
Floating Point Arithmetic (Cont’)• If we simply added the numbers using as much precision as we
needed and then applied rounding only in the final normalization step,then the calculation would go like this:
• Normalizing yields .10011 × 25, and rounding to three significant digitsusing the round to nearest even method yields .101 × 25.
• Which calculation is correct .100 x 25 or .101 x 25?
• According to the IEEE 754 standard, the final result should be thesame as if the maximum precision needed is used before applyingthe rounding method, and so the correct result is .101 × 25. So whatdo we do?
3-28 Chapter 3 - Arithmetic
Computer Architecture and Organization by M. Murdocca and V. Heuring © 2007 M. Murdocca and V. Heuring
Guard, Round, and Sticky Bits• This raises the issue of how to compute the intermediate results with
sufficient accuracy and without requiring too much hardware, and forthis we use guard, round, and sticky bits.
• For the previous example, applying guard (g) and round (r) bits withthe round toward nearest even method, we have:
• Only one extra bit is needed for this intermediate result, the guard bit(g), but we also show the round bit (r = 0) to locate its position. As weshift the number to normalize, we set a sticky bit (s) if any of theshifted out bits are nonzero. For this case, there are no nonzero bitsto the right of the r bit and so s = 0: (see next slide)
3-29 Chapter 3 - Arithmetic
Computer Architecture and Organization by M. Murdocca and V. Heuring © 2007 M. Murdocca and V. Heuring
Guard, Round, and Sticky Bits (Cont’)• Now for the rounding step: simply append the sticky bit to the right of
the result before rounding. There is no tie as there would be for.100100 and so we round up, otherwise we would have roundeddown to the closest even number (.100):
• For this case, the guard, round, and sticky bits changed our previousresult. Note that if r is 0 instead of 1, so that the grs combination is100, we would have rounded down to .100 because .100 is evenwhereas .101 is not.
3-30 Chapter 3 - Arithmetic
Computer Architecture and Organization by M. Murdocca and V. Heuring © 2007 M. Murdocca and V. Heuring
Floating Point Multiplication/Division• Floating point multiplication/division are performed in a manner similar to
floating point addition/subtraction, except that the sign, exponent, andfraction of the result can be computed separately.
• Like/unlike signs produce positive/negative results, respectively. Exponentof result is obtained by adding exponents for multiplication, or bysubtracting exponents for division. Fractions are multiplied or dividedaccording to the operation, and then normalized.
• Ex: Perform the floating point operation: (+.110 × 25) / (+.100 × 24)2
• The source operand signs are the same, which means that the result willhave a positive sign. We subtract exponents for division, and so theexponent of the result is 5 – 4 = 1.
• We divide fractions, producing the result: 110/100 = 1.10.
• Putting it all together, the result of dividing (+.110 × 25) by (+.100 × 24)produces (+1.10 × 21). After normalization, the final result is (+.110 × 22).
3-31 Chapter 3 - Arithmetic
Computer Architecture and Organization by M. Murdocca and V. Heuring © 2007 M. Murdocca and V. Heuring
The Booth Algorithm• Booth multiplication reduces the number of additions for intermediate
results, but can sometimes make it worse as we will see.
• Positive and negative numbers treated alike.
3-32 Chapter 3 - Arithmetic
Computer Architecture and Organization by M. Murdocca and V. Heuring © 2007 M. Murdocca and V. Heuring
A Worst Case Booth Example• A worst case situation in which the simple Booth algorithm requires
twice as many additions as serial multiplication.
3-33 Chapter 3 - Arithmetic
Computer Architecture and Organization by M. Murdocca and V. Heuring © 2007 M. Murdocca and V. Heuring
Bit-Pair Recoding (Modified BoothAlgorithm)
3-34 Chapter 3 - Arithmetic
Computer Architecture and Organization by M. Murdocca and V. Heuring © 2007 M. Murdocca and V. Heuring
Coding of Bit Pairs
3-35 Chapter 3 - Arithmetic
Computer Architecture and Organization by M. Murdocca and V. Heuring © 2007 M. Murdocca and V. Heuring
ParallelPipelined
ArrayMultiplier
3-36 Chapter 3 - Arithmetic
Computer Architecture and Organization by M. Murdocca and V. Heuring © 2007 M. Murdocca and V. Heuring
Newton’s Iteration for Zero Finding
• The goal is to find where thefunction f(x) crosses the x axis bystarting with a guess xi and thenusing the error between f(xi ) andzero to refine the guess.
• A three-bit lookup table forcomputing x0:
• The division operation a/b iscomputed as a × 1/b.Newton’s iteration providesa fast method of computing1/b.
3-37 Chapter 3 - Arithmetic
Computer Architecture and Organization by M. Murdocca and V. Heuring © 2007 M. Murdocca and V. Heuring
Residue Arithmetic• Implements carryless arithmetic (thus fast!), but comparisons are
difficult without converting to a weighted position code.
• Representation of the first twenty decimal integers in the residuenumber system for the given moduli:
3-38 Chapter 3 - Arithmetic
Computer Architecture and Organization by M. Murdocca and V. Heuring © 2007 M. Murdocca and V. Heuring
Examples of Addition andMultiplication in the Residue Number
System
3-39 Chapter 3 - Arithmetic
Computer Architecture and Organization by M. Murdocca and V. Heuring © 2007 M. Murdocca and V. Heuring
16-bit Group Carry Lookahead Adder• A16-bit GCLA is composed of four 4-bit CLAs, with additional logic
that generates the carries between the four-bit groups.
GG0 = G3 + P3G2 + P3P2G1 + P3P2P1G0
GP0 = P3P2P1P0
c4 = GG0 + GP0c0
c8 = GG1 + GP1c4 = GG1 + GP1GG0 + GP1GP0c0
c12 = GG2 + GP2c8 = GG2 + GP2GG1 + GP2GP1GG0 +
GP2GP1GP0c0
c16 = GG3 + GP3c12 = GG3 + GP3GG2 + GP3GP2GG1 +
GP3GP2GP1GG0 + GP3GP2GP1GP0c0
3-40 Chapter 3 - Arithmetic
Computer Architecture and Organization by M. Murdocca and V. Heuring © 2007 M. Murdocca and V. Heuring
16-Bit Group Carry Lookahead Adder
• Each CLAhas a longestpath of 5gate delays.
• In the GCLL section, GG and GP signals are generated in 3 gate delays;carry signals are generated in 2 more gate delays, resulting in 5 gatedelays to generate the carry out of each GCLA group and 10 gatesdelays on the worst case path (which is s15 – not c16).
Recommended