PowerPoint Slides

Computer Organisation and Architecture

Smruti Ranjan Sarangi,
IIT Delhi

Chapter 7 Computer Arithmetic 2

PROPRIETARY MATERIAL. © 2014 The McGraw-Hill Companies, Inc. All rights reserved. No part of this PowerPoint slide may be displayed, reproduced or distributed in any form or by any means, without the
prior written permission of the publisher, or used beyond the limited distribution to teachers and educators permitted by McGraw-Hill for their individual course preparation. PowerPoint Slides are being provided only
to authorized professors and instructors for use in preparing for classes using the affiliated textbook. No other use or distribution of this PowerPoint slide is permitted. The PowerPoint slide may not be sold and may
not be distributed or be used by any student or any other third party. No part of the slide may be reproduced, displayed or distributed in any form or by any means, electronic or otherwise, without the prior written
permission of McGraw Hill Education (India) Private Limited.
1
2nd version

www.basiccomparch.com
Download the pdf of the book

videos

Slides, software, solution manual

Print version
The pdf version of the book and
(Publisher: WhiteFalcon, 2021)
all the learning resources can be
Available on e-commerce sites.
freely downloaded from the
website: www.basiccomparch.com
 Outline

* Addition
* Multiplication
* Division
* Floating Point Addition
* Floating Point Multiplication
* Floating Point Division

3
 Integer Division
* Let us only consider positive numbers
* N = DQ + R
* N → Dividend
* D → Divisor
* Q → Quotient
* R → Remainder

* Properties
* [Property 1:] R < D, R >= 0
* [Property 2:] Q is the largest positive integer
satisfying the equation (N = DQ +R) and Property 1
4
 Reduction of the Divison Problem

𝑁 =𝐷𝑄+ 𝑅
𝑛−1
⏟ ⏟
𝑁 − 𝐷 𝑄 𝑛 2 =𝐷 𝑄1… 𝑛−1 +𝑅
𝑁′ 𝑄′

We have reduced the original problem to a smaller problem

5
 How to Reduce the Problem
* We need to find Qn
* We can try both values – 0 and 1
* First try 1
* If : N – D2n-1 >= 0, Qn = 1 (maximize the
quotient)
* Otherwise it is 0
* Once we have reduced the problem
* We can proceed recursively

6
 Iterative Divider
Divisor(D)

(U-D)

U V

Initial: V holds the dividend (N), U = 0

7
 Restoring Division
Algorithm 3: Restoring algorithm to divide two 32 bit numbers
Data: Divisor in D, Dividend in V, U = 0
Result: U contains the remainder (lower 32 bits), and V contains the quotient
i ← 0
for i < 32 do
i ← i + 1
/* Left shift UV by 1 position */
UV ← UV << 1
U ← U - D
if U ≥ 0 then
q ← 1
end
else
U ← U + D
q ← 0
end
/* Set the quotient bit */
LSB of V ← q
end

8
 Example
Dividend (N) 00111

Divisor (D) 0011

U V
beginning: 00000 0111

after shift: 00000 111X

1 end of 00000 1110
iteration:
after shift: 00001 110X
2 end of 00001 1100
iteration:
after shift: 00011 100X
3 end of 00000 1001
iteration:
after shift: 00001 001X
4
end of 00001 0010
iteration:

Quotient(Q) 0010

Remainder(R) 0001

9
 Restoring Division
* Consider each bit of the dividend
* Try to subtract the divisor from the U
register
* If the subtraction is successful, set the relevant
quotient bit to 1
* Else, set the relevant quotient bit to 0
* Left shift

10
 Proof
* Let us consider the value stored in UV
(ignoring quotient bits)
* After the shift (first iteration)
* UV = 2N
* After line 5, UV contains
* UV – 2nD = 2N – 2nD = 2 * (N – 2n-1 D)

* If (U – D) >= 0
* N' = N – 2n-1D.
* Thus, UV contains 2N'
11
 Proof - II
* If (U – D) < 0
* We know that (N = N')
* Add D to U → Add 2nD to UV
* partial dividend = 2N = 2N'
* In both cases
* The partial dividend = 2N'
* After 32 iterations
* V will contain the entire quotient
12
 Proof - III

* At the end, UV = 232 * N32 (Ni is the partial

dividend after the ith iteration)
* N31 = DQ1 + R
* N31 – DQ1 = N32 = R
* Thus, U contains the remainder (R)

13
 Time Complexity

* n iterations
* Each iteration takes log(n) time
* Total time : n log(n)

14
 Restoring vs Non-Restoring Division

* We need to restore the value of register U

* Requires an extra addition or a register move
* Can we do without this ?
* Non Restoring Division

15
Algorithm 4: Non-restoring algorithm to divide two 32 bit numbers
Data: Divisor in D, Dividend in V, U = 0
Result: U contains the remainder (lower 32 bits), and V contains the quotient
i ← 0
for i < 32 do
i ← i + 1
/* Left shift UV by 1 position */
UV ← UV << 1
if U ≥ 0 then
U ← U − D
end
else
U ← U + D
end
if U ≥ 0 then
q ← 1
end
else
q ← 0
end
/* Set the quotient bit */
lsb of V ← q
end
if U <0 then
U ← U + D
end

16
Dividend (N) 00111

Divisor (D) 0011

U V
beginning: 00000 0111

after shift: 00000 111X

1 end of 11101 1110
iteration:
after shift: 11011 110X
2 end of 11110 1100
iteration:
after shift: 11101 100X
3 end of 00000 1001
iteration:
after shift: 00001 001X
4 end of 11110 0010
iteration:
U V
end (U=U+D): 0001 0010

Quotient(Q) 0010
Remainder(R) 0001

17
 Idea of the Proof
* Start from the beginning : If (U – D) >= 0
* Both the algorithms (restoring and non-restoring)
produce the same result, and have the same state
* If (U – D) < 0
* We have a divergence
* In the restoring algorithm
* value(UV) = A
* In the non-restoring algorithm
* value(UV) = A - 2nD

18
 Proof - II
* In the next iteration (just after the shift)
* Restoring : value(UV) = 2A
* Non - Restoring : value(UV) = 2A - 2n+1D
* If the quotient bit is 1 (end of iteration)
* Restoring :
* Subtract 2nD
* value(UV) = 2A - 2nD
* Non Restoring :
* Add 2nD
* value(UV) = 2A – 2n+1D + 2nD = 2A - 2nD

19
 Proof - III
* If the quotient bit is 0
* Restoring
* partial dividend = 2A
* Non restoring
* partial dividend = 2A – 2nD
* Next iteration (if quotient bit = 1) (after shift)
* Restoring : partial dividend : 4A
* Non restoring : partial dividend : 4A – 2n+1D

* Keep applying the same logic ….

20
 Outline
* Addition
* Multiplication
* Division
* Floating Point Addition
* Floating Point Multiplication
* Floating Point Division

21
 Adding Two Numbers (same sign)

Normalised form of a 32 bit (normal) floating point number.

A = (−1)S × P × 2E−bias, (1 ≤ P < 2, E ∈ Z, 1 ≤ E ≤ 254) (7.22)
Normalised form of a 32 bit (denormal) floating point number.

A = (−1)S × P × 2−126, (0 ≤ P < 1) (7.23)

Symbol Meaning
S Sign bit (0(+ve), 1(-ve))
P Significand (form: 1.xxx(normal) or 0.xxx(denormal))
M Mantissa (fractional part of significand)
E (exponent + 127(bias))
Z Set of integers

* Recap : Floating Point Number System

22
 Addition
* Add : A + B
* Unpack the E fields → EA , EB
* Let the E field of the result be → EC
* Unpack the significand (P)
* P contains → 1 bit before the decimal point, 23
mantissa bits (24 bits)
* Unpack to a 25 bit number (unsigned)
* W → Add a leading 0 bit, 24 bits of the signficand

23
 Addition - II
* With no loss of generality
* Assume EA >= EB

* Let significands of A and B be PA and PB

* Let us initially set W ← unpack (PB)
* We make their exponents equal and shift W to
the right by (EA – EB) positions
*

24
 Renormalisation
* Let the significand represented by register, W,
be PW

* There is a possibility that PW >= 2

* In this case, we need to renormalise
* W ← W >> 1
* E A ← EA + 1
* The final result
* Sign bit (same as sign of A or B)
* Significand (PW), exponent field (EA)
25
 Example

Example: Add the numbers: 1.012 * 23 + 1.112 * 21

Answer:
The decimal point in W is shown for enhancing
readability. For simplicity, biased notation not used.
1. A = 1.01 * 23 and B = 1.11 * 21
2. W = 01.11 (significand of B)
3. E = 3
4. W = 01.11 >> (3-1) = 00.0111
5. W + PA = 00.0111 + 01.0100 = 01.1011
6. Result: C = 1.011 * 23

26
 Example - II
Example: Add : 1.012 * 23 + 1.112 * 22

Answer:
The decimal point in W is shown for enhancing
readability. For simplicity, biased notation not used.

1. A = 1.01 * 23 and B = 1.11 * 22

2. W = 01.11 (significand of B)
3. E=3
4. W = 01.11 >> (3-2) = 00.111
5. W + PA = 00.111 + 01.0100 = 10.001
6. Normalisation: W = 10.001 >> 1 = 1.0001, E = 4
7. Result: C = 1.0001 * 24
27
 Rounding
* Assume that we were allowed only two
mantissa bits in the previous example
* We need to perform rounding
* Terminology :
* Consider the sum(W) of the significands after we
have normalised the result
* W ← (P + R) * 2-23 (R < 1)

28
 Rounding - II

* P represents the significand of the temporary

result
* R (is a residue)
* Aim :
* Modify P to take into account the value of R
* Then, discard R
* Process of rounding : P → P'

29
 IEEE 754 Rounding Modes
* Truncation
* P' = P
* Example in decimal : 9.5 → 9, 9.6 → 9
* Round to +∞
* P' = ⎡P +R⎤
* Example in decimal : 9.5 → 10, -3.2 → -3

30
 IEEE 754 Rounding - II
* Round to -∞
* P' = ⌊P+R⌋
* Example in decimal : 9.5 → 9, -3.2 → -4
* Round to nearest
* P' = [P + R]
* Example in decimal :
* 9.4 → 9 , 9.5 → 10 (even)
* 9.6 → 10 , -2.3 → -2
* -3.5 → -4 (even)

31
 Rounding Modes – Summary

Rounding Mode Condition for incrementing the significand

Sign of the result (+ve) Sign of the result (-ve)
Truncation
Round to +∞ R>0
Round to −∞ R>0
Round to Nearest (R > 0.5)||(R = 0.5 ∧ lsb(P) = 1) (R > 0.5)||(R = 0.5 ∧ lsb(P) = 1)
∧ (logical AND), R (residue)

32
 Implementing Rounding
* We need three bits
* lsb(P)
* msb of the residue (R) → r (round bit)
* OR of the rest of the bits of the residue (R) → s (sticky
bit)

Condition on Residue Implementation

R>0 r∨s=1
R = 0.5 r∧s=1
R > 0.5 r∧s=1
r (round bit), s(sticky bit)

33
 Renormalisation after Rounding

* In rounding : we might increment the

significand
* We might need to renormalise
* After renormalisation
* Possible that E becomes equal to 255
* In this, case declare an overflow

34
Addition of Numbers (Opposite Signs)
* C=A+B
* Same assumption EA >= EB

* Steps
* Load W with the significand of B (PB)
* Take the 2's complement of W (W = -B)
* W ← W >> (EA – EB)
* W ← W + PA
* If (W < 0) replace it with its 2's complement. Flip the sign of
the result.

35
Addition of Numbers (Opposite Signs)-II

* Normalise the result

* Possible that W < 1
* In this case, keep shifting W to the left till it is in
normal form. (simultaneously decrement EA)

* Round and Renormalise

36
 C=A+B
Y
A=0? C=B
N N
W < 0?
Y
B=0? C=A Y
N W - W (2's complement)
Swap A and B
such that E B
<= E A
S=S

W P B>> (EA – EB)

Normalize W and Overflow or Y
E EA , S sign(A) update E Report
underflow?

N
Y Y
sign(A) = sign(B)? Overflow or Construct C out
underflow? of W, E, and S
N
N Report
W - W (2's complement)
Round W

W W + PA
Normalize W and
C
update E

37
 Outline
* Addition
* Multiplication
* Division
* Floating Point Addition
* Floating Point Multiplication
* Floating Point Division

38
Multiplication of FP Numbers

* Steps
* E ← EA + EB - bias
* W ← PA * PB
* Normalise (shift left or shift right)
* Round
* Renormalise

39
 C=A*B
Y
A=0? C=0
Normalize W and
N
update E
Y
B=0? C=0
N
Overflow or Y
underflow?
S sign(A) sign(B)
E E A+ E B- bias N Report
Round W Construct C out
of W, E, and S
Normalize W and
Overflow or Y update E
underflow?

Report
N
C
Overflow or Y
underflow?
W P * P
A B
N Report

40
 Outline

* Addition
* Multiplication
* Division
* Floating Point Addition
* Floating Point Multiplication
* Floating Point Division

41
 Simple Division Algorithm
* Divide A/B to produce C
* There is no notion of a remainder in FP division
* Algorithm
* E ← EA – EB + bias
* W ← PA / PB
* normalise, round, renormalise
* Complexity : O(n log(n))

42
 Goldschmidt Division
* Let us compute the reciprocal of B (1/B)
* Then, we can use the standard floating point
multiplication algorithm
* Ignoring the exponent
* Let us compute (1/PB)

* If B is a normal floating point number

* 1 <= PB < 2
* PB = 1 + X (X < 1)
43
Goldschmidt Division - II

44
* No point considering Y32
* Cannot be represented in our format
45
 Generating the 1/(1-Y)

( 1+𝑌 ) ( 1+𝑌 2 ) …(1+ 𝑌 16 )

* We can compute Y2 using a FP multiplier.
* Again square it to obtain Y4, Y8, and Y16
* Takes 4 multiplications, and 5 additions, to
generate all the terms
* Need 4 more multiplications to generate the final
result (1/1-Y)

* Compute 1/PB by a single right shift

46
GoldSchmidt Division Summary
* Time complexity of finding the
reciprocal
* (log(n))2
* Time required for all the multiplications
and additions
* (log(n))2
* Total Time : (log(n))2

47
 Division using the Newton Raphson
Method
* Let us focus on just finding the reciprocal
of a number
* Let us designate PB as b (1 <= b < 2)
* Aim is to compute 1/b

* Let us create a function f(x) = 1/x – b

* f(x) = 0, when x = 1/b
* Problem of computing the reciprocal
* same as computing the root of f(x)

48
 Idea of the Method

* Start with an arbitrary value of x → x0

* Locate x0 on the graph of f(x)
* Draw a tangent to f(x) at (x0 , f(x0))
* Let the tangent intersect the x axis at x1
* Draw another tangent at (x2, f(x2))

* Keep repeating
* Ultimately, we will converge to the root
49
Newton Raphson Method

x0,f(x0)
f(x)
x1,f(x1)

root
x2 x1 x0
x

50
 Analysis

* f(x) = 1/x – b
* f’(x)= d f(x) / d(x) = -1 / x2
* f'(x0) = -1/x02

* Equation of the tangent : y = mx + c

* m = -1/x02
* y = -x/x02 + c

* At x0, y = 1/x0 - b

51
 Algebra

* The equation of the tangent is :

* y = -x/x02 + 2/x0 – b
* Let this intersect the x axis at x1

52
 Intersection with the x-axis

𝑥1 2
− 2 + − 𝑏=0
𝑥0 𝑥0

* Let us define : E(x) = bx – 1

* E(x) = 0, when x = 1/b

53
Evolution of the Error

𝜀 ( 𝑥 0 ) =𝑏 𝑥 0 − 1

54
 Bounding the Error

* 1 <= b < 2 (significand of a normal

floating point number)
* Let x0 = ½
* The range of (bx0 – 1) is [-1/2, 0]
* Hence, |E(x0)| <= ½
* The error thus reduces by a power of 2 every
iteration

55
 Evolution of the Error - II
Iteration max(e (x)
1
0 2
1
1 22
1
2 24
1
3 28
1
4 216
1
5 232

* E(x) = bx – 1 = b (x – 1/b)
* x – 1/b is the difference between the ideal value and the actual
estimate (x). This is near 2-32, which is too small to be considered.

* No point considering beyond 5 iterations

* Since, we are limited to 23 bit mantissas 56
 Time Complexity
* In every step, the operation that we
need to perform is :
* xn = 2xn-1 – bxn-12
* Requires a shift, multiply, and subtract operation
* O(log(n)) time
* Number of steps: O(log(n))
* Total time : O( log (n)2 )

57
THE END

58