Representing Integers

• With n bits, we can represent 2ⁿ numbers
  • 1 - 2ⁿ
  • 0 - 2ⁿ -1
  • -2^n-1 - 2^n-1 -1
  • Or any other range of numbers
• We are going to look at integers
  • Compare representations
  • And ease of performing math on them
  • As well as pick up a few definitions we need for chapter 8.
• We are going to look at addition too.

Addition of unsigned values

• Ripple adders
  • You know them
  • You love them
  • How long does it take to add two numbers?
  • How about 2 n bit numbers?
  • O(n)
  • Can we make this faster?
• Parallel vs Sequential
  • What makes a task parallelizable
  • Pipeline - a series of steps repeated again and again on differnt items
  • Building cars.
  • Independant Tasks - tasks that don't depend on each other
  • Making a 4 course meal
  • Some tasks are not obviously parallelizable
• Conditional Sum Adder
  • We can calculate the sum of two bits
  • We can come up with two different values, based on the carry in

  • Carryin /Bits	0 0		0 1		1 1
    	Cout	S	Cout	S	Cout	S
    0	0	0	0	1	1	0
    1	0	1	1	0	1	1

  • We have three things to represet here
    • The two bits
    • The sum if the carry in is 0/1
    • The carry_out
  • We will represent a sum of 1 and a carry_out of 0 as
  • 0'1
  • Or in general C'S
  • So the above table becomes:

  • Carryin /Bits	0 0	0 1	1 1
    0	0'0	0'1	1'0
    1	0'1	1'0	1'1

  • We wish to construct a set of conditional sums, so we will generate an orderd pair.
  • The first number represents the result if carry_in = 1
  • The second number represents the result if carry_in = 0
  • (1'0,0'1) represents adding 1 and 0 (or 0 and 1)
  • These partial sums can be constructed in parallel.
  • Algorithm:

    1. Allign the bits of the two numbers
    2. For each pair of bits, construct the partial sum (from the table above)
    3. Repeat until only one pair of sums exist
    4.    Construct the carryin=0 sum
    5.    Construct the carryin = 1 sum
    6. Look at carry in to determine final result.
    
    Construct carryin = 0 sum (a'wwww, b'xxxx) and (c'yyyy ,d'zzzz)
    1.  Leftmost bits = zzzz (since carryin = 0)
    2.  If d = 0, rightmost bits = b'xxxx  (output = b'xxxxzzzz)
    3.  If d = 1, rightmost bits = a'wwww  (output = a'wwwwzzzz)
    
    Construct carryin = 1 sum (a'wwww, b'xxxx) and (c'yyyy ,d'zzzz)
    1.  Leftmost bits = yyyy (since carryin = 1)
    2.  If c = 0, rightmost bits = b'xxxx  (output = b'xxxxyyyy)
    3.  If c = 1, rightmost bits = a'wwww  (output = a'wwwwyyyy)
    
         

  • Example: Add 111001 and 110010, form the partial sums

        1         1         1         0         0         1
        1         1         0         0         1         0
    (1'1,1'0) (1'1,1'0) (1'0,0'1) (0'1,0'0) (0'1,0'1) (1'0,0'1)
         

  • At the next stage, we can find the result from the previous stage

  • (1'1,1'0) (1'1,1'0) (1'0,0'1) (0'1,0'0) (0'1,0'1) (1'0,0'1)
        (1'11,1'10)         (0'11,0'10)         (0'10,0'11)
        (1'11,1'10)                 (0'1010,0'1011)
                  (1'101010,1'101011)
    

  • Since there is no carry_in the sum is 101011, and the carry_out = 1
  • Notice, that each partial sum is independant of the others
  • The time for each operation does not depend on the number of bits in the number, so
  • this is done is O(log₂ n)
  • A tk-gate implementation
• A Lookahead - Carry adder
  • Takes a different approch
  • Remember S = X xor Y xor C_i
  • and C_o = XY + C_i(X xor Y)
  • Let us let p_i = X_i xor Y_i
  • P because the value of p_i decides to propogate C_i or not.
  • and g_i = X_iY_i
  • Notice c_i = g_i + C_i-1p_i
  • MacCabe has an error in figure 7.5, he drops an xor for p_i
  • To add four bits, the carries are
    • c₁ =g₀+ c₀ p₀
    • c₂ =g₁+ c₁ p₁
    • c₃ =g₂+ c₂ p₂
    • c₄ =g₃+ c₃ p₃
  • so
    • c₂ =g₁+ (g₀+c₀p₀) p₁
    • c₃ =g₂+ (g₁+ (g₀+c₀p₀) p₁) p₂
    • c₄ =g₃+ ( g₂+ (g₁+ (g₀+c₀p₀) p₁) p₂) p₃
  • So we can calculate the carries in terms of the inputs ( x₃ to x₀, y₃ to y₀, and c₀)
  • Notice the number of terms grows each level, and is 6 gates deep
  • We would not want to go much deeper, but the equation gets larger
  • Remember, however, we can accomplish this in a 2 gate propogation delay
  • So a four bit ripple adder takes 4*2 or 8 gate delays
  • Our adder can accomplish the same thing in 2
  • And we can combine this with conditional sum logic to form a fairly large circuit.
  • 
• Carries
  • In any case, it is possible to get C_n and C_n-1
  • We will use these to detect overflow
  • That is when the number does not fit in the space provided
  • This is different from underflow, which comes in chapter 8
  • We can do multiple things on overflow
    • Possibly create an exception
      • This is where the hardware tells the OS that a problem has occured
      • The OS then takes corrective action
    • We can also set a condition bit in the status register
      • Then act on it with special jump instructions
      • BROC - branch on carry
      • BRNC - branch on no carry
    • Nothing - overflow isn't always an problem.

Other Basic Operations

• Subtraction
  • You have already designed a subtraction circuit
  • We can play the same games as above
  • Or we can do 2's compliment math
  • 
• Multiplication
  • This is more time consuming
  • Algorithm: a * b
    1. Sum = 0
    2. Multiply a by LSB of b
    3. shift sum left
    4. add in result of multiply
    5. shift b right
    6. if b = 0 exit, else go to step 2
  • 
  • Example 9*5

    a = 1001   b = 101   sum = 0
        a * 1 = 1001    sum = 0 + 1001 = 1001
    a = 1001  b = 10    sum  = 1001
        a * 0 = 0   sum << 1 + 0 = 10010
    a = 1001  b = 1    sum  = 10010
        a * 1 = 1001  sum << 1 = 100100
                                 + 1001
    			     101101 = 45
          

  • Notice, this takes n adds + 2n shifts + n multiplies (copies really)
  • The shifts can go on while the add is going on
  • In other words, much more time than an add.
  • Many machines have a seperate unit to perform these operations.
  • Notice too, This creates a 2n bit number
  • Use two registers for reslut?
• Divide is even worse.