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 = 1
  • (1'0,0'1) represents adding 1 and 0 (or 0 and 1)
  • These partial sums can be constructed in parallel.
  • 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 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.