1
Representing Numbers Using Bases• Numbers in base 10 are called decimal numbers,
they are composed of 10 numerals ( ספרות ).9786 = 9*1000 + 7*100 + 8*10 + 6*1
= 9*103 + 7*102 + 8*101 + 6*100
• Numbers in base 2 are called binary numbers, they are composed of the numerals 0 and 1.110101 = 1*32 + 1*16 + 0*8 + 1*4 + 0*2 + 1*1 = 1*25 + 1*24 + 0*23 + 1*22 + 0*21 + 1*20
• 1111 1111 1111 1111 = 32768 + 16384 + 8192 + 4096 + 2048 + 1024 + 512 + 256 + 128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 = 215 + 214 + … + 21 + 20 =
2n = 216 -1
2
Converting Between Bases• From base 2 to base 10 is easy: just multiply each
numeral by its exponent. 1001b = 1*8 + 1*1 = 9d
• From base 10 to base 2 is slightly more complicated: In a loop from 31 to 0 (in the case of a 32 bit word) perform the following:– Divide the decimal number by 2n and write the
result in the nth position.
– Replace the number with the number minus the result multiplied by 2n
– Decrement n by 1.
3
A Base Conversion ExampleIn C++ it looks like this:for(n=31;n>=0;n--){
res = decimal/(int)pow(2,n);
decimal = decimal - res*(int)pow(2,n);
cout << res;
}
500/29 = 0 ; 500 - 0 = 500 4/23 = 0 ; 4 - 0 = 4
500/28 = 1 ; 500 - 256 = 244 4/22 = 1 ; 4 - 4 = 0
244/27 = 1 ; 244 - 128 = 116 0/21 = 0 ; 0 - 0 = 0
116/26 = 1 ; 116 - 64 = 52 0/20 = 0 ; 0 - 0 = 0
52/25 = 1 ; 52 - 32 = 20
20/24 = 1 ; 20 - 16 = 4 500d = 111110100b
4
Representation (יצוג) of Numbers
• int, long, short, char - positive numbers are stored as a binary number where the MSB (Most Significant Bit) is 0A short is represented by 16 bits 100d = 26 + 25 + 22 =0000000001100100An int is represented by 32 bits 65545d = 216 + 23 + 20 =
00000000000000010000000000001001 A char is represented by 8 bits ‘a’ = 48d = 25 + 24 = 00110000
5
Signed and Unsigned Numbers• In order to calculate both positive and negative
numbers we must be able to distinguish (להבדיל) between them.
• The most obvious solution is to add a bit that represents the sign. The name of this scheme is called: sign and magnitude (גודל).
• There were several problems with this scheme:– where do we put the sign?– an extra step is needed to calculate the sign bit– there is both a positive and negative zero
Thus a new representation was chosen
6
Two's Complement• In the representation chosen leading 0s means
positive and leading 1s means negative.• The positive half of the numbers from 0 to
2,147,483,647d (231 -1) uses the same representation as before.
• The smallest negative number is -2,147,483,648 (-231) and is represented by 10000…00000b
• It is followed by -2,147,483,647 (1000…0001b) up to -1 (1111…1111b).
• There is a negative number (-231) with no positive partner, beware when programming.
• The sum of a number and its inverse (נגדי) is -1.
7
Negative Integers• Negative integers are represented using the two's-
complement (משלים לשניים) method. The number is represented in binary, the bits are flipped and 1 is added. Thus the MSB is always 1
• Thus in a char:-100d = -01100100 = 10011011 + 1 = 10011100 11111111 = 00000000 + 1 = -1d-128d = -10000000 = 01111111 + 1 = 1000000011000101 = 00111010 + 1 = 00111011 = -59d
• In a short:-25,000d = -0110000110101000 = 1001111001010111 + 1 = 10011110011000
8
Unsigned Integers• Are stored as binary numbers. The MSB (sign bit) can be 1
or 0, the number is still positive.Thus in a char:10011100 = 27 + 24 + 23 + 22 = 156 11111111 = 27 + … + 20 = 28 - 1 = 255
• A problem arises when we have to compare numbers. How do we know if the number is an unsigned large number or a negative number. The solution is to add instructions which handle unsigned numbers. sltu $t0,$s0,$s1sltiu $t0,$s0,100
9
Hexadecimal Numbers• Number in base 16 are called hexadecimal
numbers, they are composed of 16 numerals (0-9,a-f).9786hex = 9*163 + 7*162 + 8*161 + 6*160 = = 9*4096 + 7*256 + 8*16 + 6*1 = 38790d
0xabcdef = 10*165 + 11*164 + 12*163 + 13*162 +
14*161 + 15*160 = 11259375d
• The conversion from binary to hex is very easy, each hex digit is 4 binary digits:0x0 = 0000 0x1 = 0001 0x2 = 0010 0x3 = 00110x4 = 0100 0x5 = 0101 0x6 = 0110 0x7 = 01110x8 = 1000 0x9 = 1001 0xa = 1010 0xb = 10110xc = 1100 0xd = 1101 0xe = 1110 0xf = 1111
10
Binary to Hexadecimal• Using the previous table it is easy to represent 32
bit binary numbers in a short form:0100 1100 0010 1101 1000 1100 0111 1001 = 4 a 2 d 8 c 7 9 =0x4a2d8c79.
• Conversion from decimal to hexadecimal is similar to converting decimal to binary.
for(n=7;n>=0;n--){
res = decimal/(int)pow(16,n);
decimal = decimal - res*(int)pow(16,n); if(res>9) cout << (char)((res -10) + 'a');
else cout << res;
}
11
Addition and Subtraction• Lets add 6 to 7:
00…00111 = 7d
00…00110 = 6d
00…01101 = 13d
• Subtraction uses addition, the operand is simply negated before being added:7 - 6 = 7 + (-6) =00…00111 = 7d
11…11010 = -6d 00…00001 = 1d
• The pseudoinstruction neg $t0,$t1 #$t0=-$t1is implemented by: sub $t0,$zero,$t1
1
0
(0) 1
1
1
(1) 0
(0)
1
1
(1) 1
(1)
0
0
(0) 1
(1)
0
0
(0) 0
(0)
0
0
(0) 0
(0) (Carries)
97108/Patterson Fig 4.03
12
Overflow (גלישה)• Overflow occurs when the result of a operation can't be
represented by the hardware. This can happen when we add two numbers of the same sign or subtract two large numbers of opposing signs.
• Overflow is detected by the following table:Operation A B Result A+B >=0 >=0 <0 A+B <0 <0 >=0 A- B >=0 <0 <0 A- B <0 >=0 >=0
• How is overflow detected in unsigned numbers? It isn't. The instructions add, addi, sub cause exceptions when overflow occurs. The instructions addu, addiu, subu ignore overflow. Guess what instructions MIPS C compilers use?
13
Logical Operations• All processors provide logical instructions that
operate on the bits of the operands.• and, andi, or, ori, xor and xori perform
the AND, OR and XOR (eXlusive OR) operations.• If $t0 contains 10 and $t1 contains 9 then:and $t2,$t0,$t1 # $t2=10&9=8or $t2,$t0,$t1 # $t2=10|9=11xor $t2,$t0,$t1 # $t2=10&9=3
• MIPS provides a NOR (Not OR) instruction as well:nor $t2,$t0,$t1 # $t2=~(10|9)=41100 NOR 1001 = 0100
• The logical NOT is a pseduinstruction in MIPS.
14
Shift Instructions• In order to access bits or fields of bits the logical
operations and the shift operations are used.• They move all bits in a word to the left or right, filling
the emptied bits with 0s. The instructions are shift left logical (sll) , and shift right logical (srl).These 2 instructions use the shamt field of the R-type instruction.
• sll $t0,$t1,6 # $t0 = $t1<<8;0000 0000 0000 1101 -> 0000 1101 0000 0000srl $t2,$t0,3 # $t2 = $t0>>3;0000 1101 0000 0000 -> 0000 0001 1010 0000
• The instructions sllv and slrv contain the shift amount in a register.sllv $t0,$t1,$t2 # $t0=$t1>>$t2
15
The Basic Building Blocksc = a . bba
000
010
001
111
b
ac
b
ac
a c
c = a + bba
000
110
101
111
10
01
c = aa
a0
b1
cd
0
1
a
c
b
d
1. AND gate (c = a . b)
2. OR gate (c = a + b)
3. Inverter (c = a)
4. Multiplexor (if d = = 0, c = a; else c = b)
16
Building an ALU• The arithmetic logic unit or ALU is the device that
performs arithmetic and logical operations in the computer. We will build it out of 4 basic building blocks. The AND gate, Or gate, Inverter and Multiplexor.
• We have now a 1-bit logical unit for AND and OR:
b
0
1
Result
Operation
a
17
1-bit Full Adder• 1-bit addition has 3 inputs (a, b, CarryIn) and 2
outputs (Sum, CarryOut). • The CarryOut is set if at least 2 out of a, b, and CarryIn
are 1.• The Sum is set when exactly one input is 1 or all three
are 1.
Sum
CarryIn
CarryOut
a
b b
CarryOut
a
CarryIn
18
1-bit ALU• We now have a 1-bit ALU that can perform AND,
OR and addition. • By connecting 32 of
these 1-bit ALUs we can build a 32-bit ALU. The CarryOut of the N 1-bit ALU is connected to the CarryIn of the N+11-bit ALU. This adder is called a ripple carry or ripple adder. A single carry out in the least significant bit (LSB) can cause a carry out of the MSB.
b
0
2
Result
Operation
a
1
CarryIn
CarryOut
19
32-bit ALU• Subtraction is performed by
adding the negative value. Thus we have to add an inverter to our ALU.
Result31a31
b31
Result0
CarryIn
a0
b0
Result1a1
b1
Result2a2
b2
Operation
ALU0
CarryIn
CarryOut
ALU1
CarryIn
CarryOut
ALU2
CarryIn
CarryOut
ALU31
CarryIn
0
2
Result
Operation
a
1
CarryIn
CarryOut
0
1
Binvert
b
20
Adding the slt instruction• slt produces 1 if rs < rt.
Thus slt will set all but the LSB to 0 with the LSB being dependent on the result. We add a new input to the multiplexor called Less, this will be the output of slt. To set the LSB we perform rs-rt. If the result is negative we must set the output. Thus the sign bit is the correct output. But it isn't the output of slt, so a new output is added to the 1-bit ALU of the MSB, Set.
0
3
Result
Operation
a
1
CarryIn
CarryOut
0
1
Binvert
b 2
Less
0
3
Result
Operation
a
1
CarryIn
0
1
Binvert
b 2
Less
Set
Overflowdetection
Overflow
a.
b.
21
The New ALU• As we can see all
the Less inputs are hardwired to zero except the LSB Less input which is wired to the Set output of the MSB 1-bit ALU.
Seta31
0
ALU0 Result0
CarryIn
a0
Result1a1
0
Result2a2
0
Operation
b31
b0
b1
b2
Result31
Overflow
Binvert
CarryIn
Less
CarryIn
CarryOut
ALU1Less
CarryIn
CarryOut
ALU2Less
CarryIn
CarryOut
ALU31Less
CarryIn
22
Comparison in the ALU• In order to
implement the bne and beq instructions we must compare between two numbers. a is equal to b if a-b=0The output line Zero is set to 1 if all the Results are 0, which happens if a == b. Set
a31
0
Result0a0
Result1a1
0
Result2a2
0
Operation
b31
b0
b1
b2
Result31
Overflow
Bnegate
Zero
ALU0Less
CarryIn
CarryOut
ALU1Less
CarryIn
CarryOut
ALU2Less
CarryIn
CarryOut
ALU31Less
CarryIn
23
ALU Summary• Our ALU can perform AND, OR, Addition,
Subtraction, Set on less then (slt), and Equality tests. The universal symbol of the ALU is shown here:
ALU ResultZero
Overflow
a
b
ALU operation
CarryOut