Recap so far (Not gotten to last time)

1. Recap so far (Not gotten to last time) • So there were issues about the number of operands. • Recall that we have a fetch-execute cycle – first an instruction is retrieved from memory and then acted upon. • With unary instructions adding two numbers and storing the result required three instructions, that’s three fetches and three executions. • With ternary instructions it can be done with one instruction, one fetch and one execute. The execution is now more complicated but we have saved time on fetches.

2. Recap so far (Cont.) • More operators means more complicated circuitry, the load and store aspects of the instruction would have to built into each separate instruction. • There is a speed versus complexity issue. And complexity also brings the issue of cost along with it.

3. Recap so far (Cont.) • After determining the number of operands, came the issue of what the operands mean. • Are they data, addresses of data, or addresses of addresses of data? • Either we can decide to support all of these types of instructions (addressing modes) and choose complexity. Or we can choose to support only some of them and sacrifice efficiency. • You can eliminate Add Immediate if you always store the values you want to add.

4. Data Types • Apart from addressing, another issue is the type of data the operation is acting on. • The process for adding integers is different from the process for adding floating point numbers. • So one may have separate ADD and FADD for the addition of integers and floats respectively. • Furthermore, one may need to add instructions to convert from one type to another. • To add an integer to a float, convert the integer to a float and then add the floats.

5. Binary Numbers Material on Data Representation can be found in Chapter 2 of Computer Architecture (Nicholas Carter)

6. Why Binary? • Maximal distinction among values  minimal corruption from noise. • Imagine taking the same physical attribute of a circuit, e.g. a voltage lying between 0 and 5 volts, to represent a number. • The overall range can be divided into any number of regions.

7. Don’t sweat the small stuff • For decimal numbers, fluctuations must be less than 0.25 volts. • For binary numbers, fluctuations must be less than 1.25 volts. 5 volts 0 volts Decimal Binary

8. Range actually split in three High Forbidden range Low

9. It doesn’t matter …. • Two of the standard voltages coming from a computer’s power supply are ideally supposed to be 5.00 volts and 12.00 volts • Measurements often reveal values that are slightly off – e.g. 5.14 volts or 12.22 volts or some such value. • So what, who cares.

10. How to represent big integers • Use positional weighting, same as with decimal numbers • 205 = 2102 + 0101 + 5100 • 11001101 = 127 + 126 + 025 + 024 + 123 + 122 + 021 + 120 = 128 + 64 + 8 + 4 + 1 = 205

11. Converting 205 to Binary • 205/2 = 102 with a remainder of 1, place the 1 in the least significant digit position • Repeat 102/2 = 51, remainder 0

12. Iterate • 51/2 = 25, remainder 1 • 25/2 = 12, remainder 1 • 12/2 = 6, remainder 0

13. Iterate • 6/2 = 3, remainder 0 • 3/2 = 1, remainder 1 • 1/2 = 0, remainder 1

14. Recap 127 + 126 + 025 + 024 + 123 + 122 + 021 + 120 205

15. Finite representation • Typically we just think computers do binary math. • But an important distinction between binary math in the abstract and what computers do is that computers are finite. • There are only so many flip-flops or logic gates in the computer. • When we declare a variable, we set aside a certain number of flip-flops (bits of memory) to hold the value of the variable. And this limits the values the variable can have.

16. Same number, different representation • 5 using 8 bits • 0000 0101 • 5 using 16 bits • 0000 0000 0000 0101 • 5 using 32 bits • 0000 0000 0000 0000 0000 0000 0000 0101

17. Adding Binary Numbers • Same as decimal; if the sum of digits in a given position exceeds the base (10 for decimal, 2 for binary) then there is a carry into the next higher position

18. Adding Binary Numbers carries 39 35 74

19. Uh oh, overflow • What if you use a byte (8 bits) to represent an integer • A byte may not be enough to represent the sum of two such numbers. 170 204 118???

20. Biggest unsigned* integers • 4 bit: 1111  15 = 24 - 1 • 8 bit: 11111111  255 = 28 – 1 • 16 bit: 1111111111111111  65535= 216 – 1 • 32 bit: 11111111111111111111111111111111  4294967295= 232 – 1 • Etc. *If one uses all of the bits available to represent only positive counting numbers, one is said to be working with unsigned integers.

21. Bigger Numbers • High-level languages often offer a hierarchy of types that differ in the number of bits used. • You can represent larger numbers than allowed by the highest type in the hierarchy by using more words. • You just have to keep track of the overflows to know how the lower numbers (less significant words) are affecting the larger numbers (more significant words).

22. Negative numbers • Negative x is the number that when added to x gives zero • Ignoring overflow the two eight-bit numbers above add up to zero  x  -x

23. Two’s Complement: a two-step procedure for finding -x from x • Step 1: exchange 1’s and 0’s • Step 2: add 1 (to the lowest bit only)  x  -x

24. Sign bit • With the two’s complement approach, all positive numbers start with a 0 in the left-most, most-significant bit and all negative numbers start with 1. • So the first bit is called the sign bit. • But note you have to work harder than just strip away the first bit. • 10000001 IS NOT the 8-bit version of –1

25. Add 1’s to the left to get the same negative number using more bits • -5 using 8 bits • 11111011 • -5 using 16 bits • 1111111111111011 • -5 using 32 bits • 11111111111111111111111111111011 • When the numbers represented are whole numbers (positive or negative), they are called integers.

26. 3-bit signed and unsigned Think of driving a brand new car in reverse. What would happen to the odometer?

27. Biggest signed integers • 4 bit: 0111  7 = 23 - 1 • 8 bit: 01111111  127 = 27 – 1 • 16 bit: 0111111111111111  32767= 215 – 1 • 32 bit: 01111111111111111111111111111111  2147483647= 231 – 1 • Etc.

28. Most negative signed integers • 4 bit: 1000  -8 = - 23 • 8 bit: 10000000  - 128 = - 27 • 16 bit: 1000000000000000  -32768= - 215 • 32 bit: 10000000000000000000000000000000  -2147483648= - 231 • Etc.

29. Riddle • Is it 214? • Or is it – 42? • Or is it Ö? • Or is it …? • It’s a matter of interpretation • How was it declared?

30. Hexadecimal Numbers • Even moderately sized decimal numbers end up as long strings in binary. • Hexadecimal numbers (base 16) are often used because the strings are shorter and the conversion to binary is easier. • There are 16 digits: 0-9 and A-F.

31. 0  0000  0 1  0001  1 2  0010  2 3  0011  3 4  0100  4 5  0101  5 6  0110  6 7  0111  7 8  1000  8 9  1001  9 10  1010  A 11  1011  B 12  1100  C 13  1101  D 14  1110  E 15  1111  F Decimal  Binary  Hex

32. Binary to Hex • Break a binary string into groups of four bits (nibbles). • Convert each nibble separately.

33. Numbers from Logic • All of the numerical operations we have talked about are really just combinations of logical operations. • E.g. the adding operation is just a particular combination of logic operations • Possibilities for adding two bits • 0+0=0 (with no carry) • 0+1=1 (with no carry) • 1+0=1 (with no carry) • 1+1=0 (with a carry)

34. Addition Truth Table

35. Multiplication: Shift and add shift shift

36. Fractions • Similar to what we’re used to with decimal numbers

37. Converting decimal to binary II • 98.61 • Integer part • 98 / 2 = 49 remainder 0 • 49 / 2 = 24 remainder 1 • 24 / 2 = 12 remainder 0 • 12 / 2 = 6 remainder 0 • 6 / 2 = 3 remainder 0 • 3 / 2 = 1 remainder 1 • 1 / 2 = 0 remainder 1 • 1100010

38. Converting decimal to binary III • 98.61 • Fractional part • 0.61  2 = 1.22 • 0.22  2 = 0.44 • 0.44  2 = 0.88 • 0.88  2 = 1.76 • 0.76  2 = 1.52 • 0.52  2 = 1.04 • .100111

39. Another Example (Whole number part) • 123.456 • Integer part • 123 / 2 = 61 remainder 1 • 61 / 2 = 30 remainder 1 • 30 / 2 = 15 remainder 0 • 15 / 2 = 7 remainder 1 • 7 / 2 = 3 remainder 1 • 3 / 2 = 1 remainder 1 • 1 / 2 = 0 remainder 1 • 1111011

40. Checking: Go to Programs/Accessories/Calculator

41. Put the calculator in Scientific view

42. Enter number while in decimal mode, then put Calculator into binary mode

43. Another Example (fractional part) • 123.456 • Fractional part • 0.456  2 = 0.912 • 0.912  2 = 1.824 • 0.824  2 = 1.648 • 0.648  2 = 1.296 • 0.296  2 = 0.592 • 0.592  2 = 1.184 • 0.184  2 = 0.368 • … • .0111010…

44. Checking fractional part: Enter digits found in binary mode Note that the leading zero does not display.

45. Convert to decimal mode, then

46. Divide by 2 raised to the number of digits (in this case 7, including leading zero) 2 1 3 4

47. In most cases it will not be exact

48. Other way around • Multiply fraction by 2 raised to the desired number of digits in the fractional part. For example • .456  27 = 58.368 • Throw away the fractional part and represent the whole number • 58 111010 • But note that we specified 7 digits and the result above uses only 6. Therefore we need to put in the leading 0 • 0111010

49. Fixed point • If one has a set number of bits reserved for representing the whole number part and another set number of bits reserved for representing the fractional part of a number, then one is said to be using fixed point representation. • The point dividing whole number from fraction has an unchanging (fixed) place in the number.

50. Limits of the fixed point approach • Suppose you use 4 bits for the whole number part and 4 bits for the fractional part (ignoring sign for now). • The largest number would be 1111.1111 = 15.9375 • The smallest, non-zero number would be 0000.0001 = .0625