1. Lecture 3: Computation and Representation CS 2011 Fall 2014, Dr. Rozier

2. COMPUTING SYSTEMS

3. Computing Introduction to Computing Systems What is a computing system?

4. Finite Automata

5. Pushdown Automata

6. Turing Machine

7. Turing Equivalence What does it take to create a Turing Machine? What does this say about computing systems?

8. Bits, Bytes, and Ints

9. Binary Representations 0.0V 0.5V 2.8V 3.3V 010

10. Encoding Byte Values Byte = 8 bits – Binary 00000000 2 to 11111111 2 – Decimal: 0 10 to 255 10 – Hexadecimal 00 16 to FF 16 Base 16 number representation Use characters ‘0’ to ‘9’ and ‘A’ to ‘F’ Write FA1D37B 16 in C as – 0xFA1D37B – 0xfa1d37b 000000 110001 220010 330011 440100 550101 660110 770111 881000 991001 A101010 B111011 C121100 D131101 E141110 F151111 Hex Decimal Binary

11. Byte-Oriented Memory Organization Programs Refer to Virtual Addresses – Conceptually very large array of bytes – Actually implemented with hierarchy of different memory types – System provides address space private to particular “process” Program being executed Program can clobber its own data, but not that of others Compiler + Run-Time System Control Allocation – Where different program objects should be stored – All allocation within single virtual address space 000 FFF

12. Machine Words Machine Has “Word Size” – Nominal size of integer-valued data Including addresses – Most current machines use 32 bits (4 bytes) words Limits addresses to 4GB Becoming too small for memory-intensive applications – High-end systems use 64 bits (8 bytes) words Potential address space ≈ 1.8 X 10 19 bytes x86-64 machines support 48-bit addresses: 256 Terabytes – Machines support multiple data formats Fractions or multiples of word size Always integral number of bytes

13. Word-Oriented Memory Organization Addresses Specify Byte Locations – Address of first byte in word – Addresses of successive words differ by 4 (32-bit) or 8 (64-bit) 0000 0001 0002 0003 0004 0005 0006 0007 0008 0009 0010 0011 32-bit Words BytesAddr. 0012 0013 0014 0015 64-bit Words Addr = ?? Addr = ?? Addr = ?? Addr = ?? Addr = ?? Addr = ?? 0000 0004 0008 0012 0000 0008

14. Data Representations C Data TypeTypical 32-bitIntel IA32x86-64 char111 short222 int444 long448 888 float444 double888 long double810/1210/16 pointer448

15. Byte Ordering How should bytes within a multi-byte word be ordered in memory? Conventions – Big Endian: Sun, PPC Mac, Internet Least significant byte has highest address – Little Endian: x86 Least significant byte has lowest address

16. Byte Ordering Example Big Endian – Least significant byte has highest address Little Endian – Least significant byte has lowest address Example – Variable x has 4-byte representation 0x01234567 – Address given by &x is 0x100 0x1000x1010x1020x103 01234567 0x1000x1010x1020x103 67452301 Big Endian Little Endian 01234567 452301

17. AddressInstruction CodeAssembly Rendition 8048365:5b pop %ebx 8048366:81 c3 ab 12 00 00 add $0x12ab,%ebx 804836c:83 bb 28 00 00 00 00 cmpl $0x0,0x28(%ebx) Reading Byte-Reversed Listings Disassembly – Text representation of binary machine code – Generated by program that reads the machine code Example Fragment Deciphering Numbers – Value: 0x12ab – Pad to 32 bits: 0x000012ab – Split into bytes: 00 00 12 ab – Reverse: ab 12 00 00

18. Representing Integers Decimal:15213 Binary: 0011 1011 0110 1101 Hex: 3 B 6 D Decimal:15213 Binary: 0011 1011 0110 1101 Hex: 3 B 6 D 6D 3B 00 IA32, x86-64 3B 6D 00 Sun int A = 15213; 93 C4 FF IA32, x86-64 C4 93 FF Sun Two’s complement representation (Covered later) int B = -15213; long int C = 15213; 00 6D 3B 00 x86-64 3B 6D 00 Sun 6D 3B 00 IA32

19. Representing Pointers Different compilers & machines assign different locations to objects int B = -15213; int *P = &B; int B = -15213; int *P = &B; x86-64SunIA32 EF FF FB 2C D4 F8 FF BF 0C 89 EC FF 7F 00

20. Strings How might we represent a string?

21. char S[6] = "18243"; Representing Strings Strings in C – Represented by array of characters – Each character encoded in ASCII format Standard 7-bit encoding of character set Character “0” has code 0x30 – Digit i has code 0x30+i – String should be null-terminated Final character = 0 Compatibility – Byte ordering not an issue Linux/AlphaSun 31 38 32 34 33 00 31 38 32 34 33 00

22. Today: Bits, Bytes, and Integers Representing information as bits Bit-level manipulations Integers – Representation: unsigned and signed – Conversion, casting – Expanding, truncating – Addition, negation, multiplication, shifting Summary

23. Boolean Algebra Developed by George Boole in 19th Century – Algebraic representation of logic Encode “True” as 1 and “False” as 0 And A&B = 1 when both A=1 and B=1 Or A|B = 1 when either A=1 or B=1 Not ~A = 1 when A=0 Exclusive-Or (Xor) A^B = 1 when either A=1 or B=1, but not both

24. Application of Boolean Algebra Applied to Digital Systems by Claude Shannon – 1937 MIT Master’s Thesis – Reason about networks of relay switches Encode closed switch as 1, open switch as 0 A ~A ~B B Connection when A&~B | ~A&B A&~B ~A&B = A^B

25. General Boolean Algebras Operate on Bit Vectors – Operations applied bitwise All of the Properties of Boolean Algebra Apply 01101001 & 01010101 01000001 01101001 | 01010101 01111101 01101001 ^ 01010101 00111100 ~ 01010101 10101010 01000001011111010011110010101010

26. Representing & Manipulating Sets Representation – Width w bit vector represents subsets of {0, …, w–1} – aj = 1 if j ∈ A 01101001{ 0, 3, 5, 6 } 76543210 01010101{ 0, 2, 4, 6 } 76543210 Operations – & Intersection01000001{ 0, 6 } – | Union01111101{ 0, 2, 3, 4, 5, 6 } – ^ Symmetric difference00111100{ 2, 3, 4, 5 } – ~ Complement10101010{ 1, 3, 5, 7 }

27. Bit-Level Operations in C Operations &, |, ~, ^ Available in C – Apply to any “integral” data type long, int, short, char, unsigned – View arguments as bit vectors – Arguments applied bit-wise Examples (Char data type) –~0x41 ➙ 0xBE ~01000001 2 ➙ 10111110 2 –~0x00 ➙ 0xFF ~00000000 2 ➙ 11111111 2 –0x69 & 0x55 ➙ 0x41 01101001 2 & 01010101 2 ➙ 01000001 2 –0x69 | 0x55 ➙ 0x7D 01101001 2 | 01010101 2 ➙ 01111101 2

28. Contrast: Logic Operations in C Contrast to Logical Operators –&&, ||, ! View 0 as “False” Anything nonzero as “True” Always return 0 or 1 Early termination Examples (char data type) –!0x41 ➙ 0x00 –!0x00 ➙ 0x01 –!!0x41 ➙ 0x01 –0x69 && 0x55 ➙ 0x01 –0x69 || 0x55 ➙ 0x01 –p && *p (avoids null pointer access)

29. Shift Operations Left Shift: x << y – Shift bit-vector x left y positions – Throw away extra bits on left Fill with 0 ’s on right Right Shift: x >> y – Shift bit-vector x right y positions Throw away extra bits on right – Logical shift Fill with 0 ’s on left – Arithmetic shift Replicate most significant bit on right Undefined Behavior – Shift amount < 0 or ≥ word size 01100010 Argument x 00010000<< 300011000 Log. >> 2 00011000 Arith. >> 2 10100010 Argument x 00010000<< 300101000 Log. >> 2 11101000 Arith. >> 2 00010000 00011000 000100000010100011101000000100000010100011101000

30. Today: Bits, Bytes, and Integers Representing information as bits Bit-level manipulations Integers – Representation: unsigned and signed – Conversion, casting – Expanding, truncating – Addition, negation, multiplication, shifting Summary

31. Unsigned Binary Integers Given an n-bit number Range: 0 to +2 n – 1 Example 0000 0000 0000 0000 0000 0000 0000 1011 2 = 0 + … + 1×2 3 + 0×2 2 +1×2 1 +1×2 0 = 0 + … + 8 + 0 + 2 + 1 = 11 10 Using 32 bits 0 to +4,294,967,295

32. 2s-Complement Signed Integers Given an n-bit number Range: –2 n – 1 to +2 n – 1 – 1 Example 1111 1111 1111 1111 1111 1111 1111 1100 2 = –1×2 31 + 1×2 30 + … + 1×2 2 +0×2 1 +0×2 0 = –2,147,483,648 + 2,147,483,644 = –4 10 Using 32 bits –2,147,483,648 to +2,147,483,647

33. 2s-Complement Signed Integers Bit 31 is sign bit – 1 for negative numbers – 0 for non-negative numbers –(–2 n – 1 ) can’t be represented Non-negative numbers have the same unsigned and 2s-complement representation Some specific numbers – 0:0000 0000 … 0000 – –1:1111 1111 … 1111 – Most-negative:1000 0000 … 0000 – Most-positive:0111 1111 … 1111

34. Signed Negation Complement and add 1 – Complement means 1 → 0, 0 → 1 Example: negate +2 +2 = 0000 0000 … 0010 2 –2 = 1111 1111 … 1101 2 + 1 = 1111 1111 … 1110 2

35. Why two’s compliment? What is the advantage of using this representation?

36. Mapping Signed  Unsigned Signed 0 1 2 3 4 5 6 7 -8 -7 -6 -5 -4 -3 -2 Unsigned 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 Bits 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111

37. Unsigned & Signed Numeric Values Equivalence – Same encodings for nonnegative values Uniqueness – Every bit pattern represents unique integer value – Each representable integer has unique bit encoding  Can Invert Mappings – U2B(x) = B2U -1 (x) Bit pattern for unsigned integer – T2B(x) = B2T -1 (x) Bit pattern for two’s comp integer XB2T(X)B2U(X) 00000 00011 00102 00113 01004 01015 01106 01117 –88 –79 –610 –511 –412 –313 –214 –115 1000 1001 1010 1011 1100 1101 1110 1111 0 1 2 3 4 5 6 7

38. T2U T2BB2U Two’s Complement Unsigned Maintain Same Bit Pattern xux X Mapping Between Signed & Unsigned U2T U2BB2T Two’s Complement Unsigned Maintain Same Bit Pattern uxx X Mappings between unsigned and two’s complement numbers: keep bit representations and reinterpret

39. Mapping Signed  Unsigned Signed 0 1 2 3 4 5 6 7 -8 -7 -6 -5 -4 -3 -2 Unsigned 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 Bits 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111 U2TT2U

40. Mapping Signed  Unsigned Signed 0 1 2 3 4 5 6 7 -8 -7 -6 -5 -4 -3 -2 Unsigned 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15Bits 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111 = +/- 16

41. 0 TMax TMin –1 –2 0 UMax UMax – 1 TMax TMax + 1 2’s Complement Range Unsigned Range Conversion Visualized 2’s Comp.  Unsigned – Ordering Inversion – Negative  Big Positive

42. Sign Extension Task: – Given w-bit signed integer x – Convert it to w+k-bit integer with same value Rule: – Make k copies of sign bit: – X = x w–1,…, x w–1, x w–1, x w–2,…, x 0 k copies of MSB X X w w k

43. Sign Extension Example Converting from smaller to larger integer data type C automatically performs sign extension short int x = 15213; int ix = (int) x; short int y = -15213; int iy = (int) y;

44. ADDITION AND SUBTRACTION

45. Unsigned Addition Standard Addition Function – Ignores carry output Implements Modular Arithmetic s= UAdd w (u, v)=u + v mod 2 w u v + u + v True Sum: w+1 bits Operands: w bits Discard Carry: w bits UAdd w (u, v)

46. Visualizing (Mathematical) Integer Addition Integer Addition – 4-bit integers u, v – Compute true sum Add 4 (u, v) – Values increase linearly with u and v – Forms planar surface Add 4 (u, v) u v

47. Visualizing Unsigned Addition Wraps Around – If true sum ≥ 2 w – At most once 0 2w2w 2 w+1 UAdd 4 (u, v) u v True Sum Modular Sum Overflow

48. Mathematical Properties Modular Addition Forms an Abelian Group – Closed under addition 0  UAdd w (u, v)  2 w –1 – Commutative UAdd w (u, v) = UAdd w (v, u) – Associative UAdd w (t, UAdd w (u, v)) = UAdd w (UAdd w (t, u ), v) – 0 is additive identity UAdd w (u, 0) = u – Every element has additive inverse Let UComp w (u ) = 2 w – u UAdd w (u, UComp w (u )) = 0

49. Two’s Complement Addition TAdd and UAdd have Identical Bit-Level Behavior – Signed vs. unsigned addition in C: int s, t, u, v; s = (int) ((unsigned) u + (unsigned) v); t = u + v – Will give s == t u v + u + v True Sum: w+1 bits Operands: w bits Discard Carry: w bits TAdd w (u, v)

50. TAdd Overflow Functionality – True sum requires w+1 bits – Drop off MSB – Treat remaining bits as 2’s comp. integer –2 w –1 –1 –2 w 0 2 w –1 True Sum TAdd Result 1 000…0 1 011…1 0 000…0 0 100…0 0 111…1 100…0 000…0 011…1 PosOver NegOver

51. Visualizing 2’s Complement Addition Values – 4-bit two’s comp. – Range from -8 to +7 Wraps Around – If sum  2 w–1 Becomes negative At most once – If sum < –2 w–1 Becomes positive At most once TAdd 4 (u, v) u v PosOver NegOver

52. Characterizing TAdd Functionality – True sum requires w+1 bits – Drop off MSB – Treat remaining bits as 2’s comp. integer (NegOver) (PosOver) u v < 0> 0 < 0 > 0 Negative Overflow Positive Overflow TAdd(u, v) 2w2w 2w2w

53. Mathematical Properties of TAdd Isomorphic Group to unsigneds with UAdd – TAdd w (u, v) = U2T(UAdd w (T2U(u ), T2U(v))) Since both have identical bit patterns Two’s Complement Under TAdd Forms a Group – Closed, Commutative, Associative, 0 is additive identity – Every element has additive inverse

54. For next time Read Rest of Chapter 2. First MP will be assigned Monday.