1. Bits and Bytes Spring, 2015 Topics Why bits? Representing information as bits Binary / Hexadecimal Byte representations »Numbers »Characters and strings »Instructions Bit-level manipulations Boolean algebra Expressing in C COMP 21000 Comp Org & Assembly Lang

2. – 2 – COMP 21000, S’15 Why Don’t Computers Use Base 10? Base 10 Number Representation That’s why fingers are known as “digits” Natural representation for financial transactions Floating point number cannot exactly represent $1.20 Even carries through in scientific notation 15.213 X 10 3 (1.5213e4)

3. – 3 – COMP 21000, S’15 Why Don’t Computers Use Base 10? Implementing Electronically Hard to store ENIAC (First electronic computer) used 10 vacuum tubes / digit IBM 650 used 5+2 bits (1958, successor to IBM’s Personal Automatic Computer, PAC from 1956) Hard to transmit Need high precision to encode 10 signal levels on single wire Messy to implement digital logic functions Addition, multiplication, etc.

4. – 4 – COMP 21000, S’15 Binary Representations Base 2 Number Representation Represent 15213 10 as 11101101101101 2 Represent 1.20 10 as 1.0011001100110011[0011]… 2 Represent 1.5213 X 10 4 as 1.1101101101101 2 X 2 13 Electronic Implementation Easy to store with bistable elements Reliably transmitted on noisy and inaccurate wires 0.0V 0.5V 2.8V 3.3V 010

5. – 5 – COMP 21000, S’15 Encoding Byte Values Byte = 8 bits Binary 00000000 2 to 11111111 2 Decimal: 0 10 to 255 10 First digit must not be 0 in C Octal: 000 8 to 0377 8 Use leading 0 in C Hexadecimal 00 16 to FF 16 Base 16 number representation Use characters ‘0’ to ‘9’ and ‘A’ to ‘F’ Use leading 0x in C, »write FA1D37B 16 as 0xFA1D37B »Or 0xfa1d37b 000000 110001 220010 330011 440100 550101 660110 770111 881000 991001 A101010 B111011 C121100 D131101 E141110 F151111 Hex Decimal Binary

6. – 6 – COMP 21000, S’15 Bases Every number system uses a base Decimal numbers use base 10 Other common bases used in computer science: Octal (base 8) Hexadecimal (base 16) Binary (base 2)

7. – 7 – COMP 21000, S’15 Decimal 7537 x 10 2 + 5 x 10 1 + 3 x 10 0 7537 x 10 2 + 5 x 10 1 + 3 x 10 0

8. – 8 – COMP 21000, S’15 Octal 753 7 x 8 2 + 5 x 8 1 + 3 x 8 0 753 7 x 8 2 + 5 x 8 1 + 3 x 8 0

9. – 9 – COMP 21000, S’15 Counting in octal

10. – 10 – COMP 21000, S’15 Converting Converting octal to decimal: 753 = 7 x 8 2 + 5 x 8 1 + 3 x 8 0 = 448 + 40 + 3 = 491

11. – 11 – COMP 21000, S’15 Translating to octal writing 157 in base 8 157 remainder: 157 remainder: 8 19 5 2 3 2 3 0 2 0 2 2 3 5 2 x 8 2 + 3 x 8 1 + 5 x 8 0 = 128 + 24 + 5 = 157 Divisor

12. – 12 – COMP 21000, S’15 Hexadecimal 7537 x 16 2 + 5 x 16 1 + 3 x 16 0 7537 x 16 2 + 5 x 16 1 + 3 x 16 0

13. – 13 – COMP 21000, S’15 Hexadecimal 0 1 2 3 4 5 6 7 8 9 A B C D E F 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F 20 21 22 23 24 25 26 27 28 29 2A 2B 2C 2D 2E 2F 30 31 32 33 34 35 36 37 38 39 3A 3B 3C 3D 3E 3F 40 41 42 43 44 45 46 47 48 49 4A 4B 4C 4D 4E 4F 50 51 52 53 54 55 56 57 58 59 5A 5B 5C 5D 5E 5F 60 61 62 63 64 65 66 67 68 69 6A 6B 6C 6D 6E 6F 70 71 72 73 74 75 76 77 78 79 7A 7B 7C 7D 7E 7F 80 81 82 83 84 85 86 87 88 89 8A 8B 8C 8D 8E 8F 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 10A 10B 10C 10D 10E 10F 120 …

14. – 14 – COMP 21000, S’15 Translating to hex 365 remainder: 365 remainder: 16 22 D 1 6 1 6 0 1 0 1 1 6 D 1 x 16 2 + 6 x 16 1 + D x 16 0 = 256 + 96 + 13 = 365

15. – 15 – COMP 21000, S’15 Binary 1011 x 2 2 + 0 x 2 1 + 1 x 2 0 1011 x 2 2 + 0 x 2 1 + 1 x 2 0

16. – 16 – COMP 21000, S’15 Counting in binary

17. – 17 – COMP 21000, S’15 Translating to binary 4 remainder: 4 remainder: 2 2 0 10 10 01 01 Divisor1 0 0

18. – 18 – COMP 21000, S’15 Translating to binary 11 remainder: 11 remainder: 2 5 1 21 21 10 10 0 1 0 1 1 0 1 1

19. – 19 – COMP 21000, S’15 Literary Hex Common 8-byte hex filler: 0xdeadbeef Can you think of other 8-byte fillers?

20. – 20 – COMP 21000, S’15 Relation between hex and binary Hexadecimal: Hexadecimal: 16 characters, Each represents a number between 0 and 15 Binary: Binary: Consider 4 places Represent numbers between 0000 and 1111 Or between 0 and 15 Result: Result: 1 hex digit represents 4 binary digits

21. – 21 – COMP 21000, S’15 Relation between hex and binary HexBinaryDecimal 000001 100012 200103 300114 401005 501016 601107 701118 810009 9100110 A101011 B101112 C110013 D110114 E111015 F111116

22. – 22 – COMP 21000, S’15 Converting main() { octal_print(0);/* result: 00 */ octal_print(-1);/* result: -01*/ octal_print(123456);/* result: 0361100 */ octal_print(-123456);/* result: -0361100 */ octal_print(0123456);/* result: 0123456 since 0 at */ /* beginning indicates octal num */ octal_print(-0123456);/* result: -123456*/ octal_print(999);/* result: 01747*/ octal_print(-999);/* result: -01747*/ octal_print(1978);/* result: 03672*/ }

23. – 23 – COMP 21000, S’15 Converting #define DIG 20 void octal_print(int x) { int i = 0, od; char s[DIG];/* up to DIG octal digits */ if ( x < 0 )/* treat negative x*/ { putchar ('-');/* output a minus sign*/ x = - x; } do { od = x % 8;/* next higher octal digit */ s[i++] = (od + '0');/* octal digits in char form*/ } while ( (x = x/8) > 0);/* quotient by integer division */ putchar('0');/* octal number prefix*/ do { putchar(s[--i]);/* output characters on ss*/ } while ( i > 0 ); putchar ('\n'); } See /home/barr/Student/Examples/baseConversion/octal.c

24. – 24 – COMP 21000, S’15 Memory What is memory (RAM)? What is memory (RAM)? To the processor, it’s just a big array of cells To the processor, it’s just a big array of cells Each cell has an address Each cell contains a specific value 0123401234 Address Contents 15213 “John” 3.14219 Sunday ‘a’‘a’‘a’‘a’

25. – 25 – COMP 21000, S’15 Memory Of course, addresses and content are actually in binary Of course, addresses and content are actually in binary 000 001 010 011 100 Address Contents 10011011 00111001 11000011 01011111 00001001 Memory is byte addressable i.e., every byte has an address.

26. – 26 – COMP 21000, S’15 Memory When we look at memory in a debugger (like gdb), usually use hex notation When we look at memory in a debugger (like gdb), usually use hex notation 000 001 002 003 004 Address Contents 9B 39 C3 5F 09

27. – 27 – COMP 21000, S’15 Memory How do we talk about the size of memory? How do we talk about the size of memory? in terms of powers of 2 (addresses are binary) 202020201 212121212 222222224 232323238 2424242416 2525252532 2626262664 27272727128 28282828256 29292929512 2 10 1024 2 11 2048 2 12 4096 2 13 8192 2 14 16384 2 10 x 2 10 = 2 20 1,048,576 2 10 x 2 10 x 2 10 = 2 30 1,073,741,824 2 10 x 2 10 x 2 10 x 2 10 = 2 40 1,099,511,627,776

28. – 28 – COMP 21000, S’15 Memory How do we talk about the size of memory? How do we talk about the size of memory? in bytes (how may bytes of memory do you have?) in terms of powers of 2 (addresses are binary) 1 bit 1 byte 1 Kilobyte (Kb) 1 Megabyte (Mb) 1 Gigabyte (Gb) 1 Terabyte (Tb) 1 bit 8 bits 1 byte 2 10 bytes 1024 bytes 2 10 x 2 10 = 2 20 1,048,576 bytes 2 10 x 2 10 x 2 10 = 2 30 1,073,741,824 bytes 2 10 x 2 10 x 2 10 x 2 10 = 2 40 1,099,511,627,776bytes 1,099,511,627,776 bytes

29. – 29 – COMP 21000, S’15 Byte-Oriented Memory Organization Programs Refer to Virtual Addresses Conceptually very large array of bytes Actually implemented with hierarchy of different memory types SRAM, DRAM, disk Only allocate for regions actually used by program In Unix and Windows NT, address space is private to particular “process” Program being executed Program can clobber its own data, but not that of others

30. – 30 – COMP 21000, S’15 Byte-Oriented Memory Organization Virtual memory is organized by the OS VM is implemented by the Compiler + Run-Time System Control Allocation (or process manager) Where different program objects should be stored Multiple mechanisms: static, stack, and heap In any case, all allocation within single virtual address space

31. – 31 – COMP 21000, S’15 Machine Words Machine (or processor) Has “Word Size” Nominal size of integer-valued data Including addresses Last generation machines used 32 bits (4 bytes) words Limits addresses to 4GB Becoming too small for memory-intensive applications We’ll use 32 bits as the word size in this class Most current systems use 64 bits (8 bytes) words Potential address space = 2 64  1.8 X 10 19 bytes Machines support multiple data formats Fractions or multiples of word size Always integral number of bytes

32. – 32 – COMP 21000, S’15 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

33. – 33 – COMP 21000, S’15 Range A computer cell holds a fixed number of bits. The range is the numbers that will fit in a cell. Examples: 0 0 0 = 0 1 1 1 = 7range is 0 to 7 0 0 0 0 = 0 1 1 1 1 = 15range is 0 to 15

34. – 34 – COMP 21000, S’15 Range In general range is 0 to 2 n – 1 where there are n bits in the representation Intuition: 111 = 1 x 2 2 + 1 x 2 1 + 1 x 2 0 Which is 1 less than 1000 = 1 x 2 3 + 0 x 2 2 + 0 x 2 1 + 0 x 2 0 Number of numbers represented: n bits can represent 2 n different numbers i.e., from 0 to 2 n – 1

35. – 35 – COMP 21000, S’15 Data Representations Sizes of C Objects (in Bytes) C Data TypeAlpha (RIP)Typical 32-bitIntel IA32 unsigned444 int444 long int844 char111 short222 float444 double888 long double8/16 † 810/12 char *844 »Or any other pointer ( †: Depends on compiler&OS, 128bit FP is done in software)

36. – 36 – COMP 21000, S’15 Byte Ordering How should bytes within a multi-byte word be ordered in memory? Conventions Sun’s, PowerPC Mac’s are “Big Endian” machines Least significant byte has highest address Alphas, intel machines (including PC’s and Mac’s) are “Little Endian” machines Least significant byte has lowest address Most networking hardware is “Big-Endian” See http://en.wikipedia.org/wiki/Endianness for a history of “endian-ness”http://en.wikipedia.org/wiki/Endianness Aside: “endian” is from Gulliver’s Travels, a book written by Jonathan Swift, in 1726.

37. – 37 – COMP 21000, S’15 Byte Ordering Example Big Endian Least significant byte (e.g., 67) has highest address Little Endian Least significant byte has lowest addressExample Variable x has 4-byte representation 0x01234567 Address given by &x is 0x100 0x1000x1010x1020x103 01234567 0x1000x1010x1020x103 67452301 Big Endian Little Endian 01234567 452301 Endian is a function of hardware

38. – 38 – COMP 21000, S’15 Reading Byte-Reversed Listings Disassembly Text representation of binary machine code Generated by program that reads the machine code Example Fragment 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) Deciphering Numbers Value: 0x12ab Pad to 4 bytes: 0x000012ab Split into bytes: 00 00 12 ab Reverse: ab 12 00 00

39. – 39 – COMP 21000, S’15 Examining Data Representations Code to Print Byte Representation of Data Casting pointer to unsigned char * creates byte array typedef unsigned char *byte_pointer; void show_bytes(byte_pointer start, int len) { int i; for (i = 0; i < len; i++) printf("0x%p\t0x%.2x\n", start+i, start[i]); printf("\n"); } Printf directives: %p :Print pointer %x :Print Hexadecimal %.2x means print only 2 digits of hex Printf directives: %p :Print pointer %x :Print Hexadecimal %.2x means print only 2 digits of hex Don’t need the 0x for pointers in some compilers This program is described in section 2.1.4 of the textbook See /home/barr/Student/Examples/binOps

40. – 40 – COMP 21000, S’15 show_bytes Execution Example int a = 15213; printf("int a = %d;\n”, a); show_bytes((byte_pointer) &a, sizeof(int)); Result (Linux): int a = 15213; 0x11ffffcb80x6d 0x11ffffcb90x3b 0x11ffffcba0x00 0x11ffffcbb0x00 Real representation: 15213 0011 1011 0110 1101 3 B 6 D Address of bytes Content stored at the address

41. – 41 – COMP 21000, S’15 show_bytes Execution Example int a = 15213; printf("int a = %d;\n”, a); show_bytes((byte_pointer) &a, sizeof(int)); float b = 15.213; printf(”float b = %f;\n”, b); show_bytes((byte_pointer) &b, sizeof(float)); char c[10] = “abcd”; printf(”string c = %s;\n”, c); show_bytes((byte_pointer) &c, 10*sizeof(char));

42. – 42 – COMP 21000, S’15 Why does endian-ness matter? Web Client (browser) Web Server What is Lady Gaga’s age? 28 0x 00 00 00 1C (solaris box) (intel box) 469,762,048 0x 00 00 00 1C 0x 1C 00 00 00 Interpreted as Displayed as

43. – 43 – COMP 21000, S’15 Why does endian-ness matter? Spreadsheet created on big-endian machine Final cost: $ 28 0x 00 00 00 1C Your machine (solaris box) Your client’s machine (intel box) Final cost: $ 469,762,048 0x 00 00 00 1C 0x 1C00 00 00 Interpreted as Displayed as Spreadsheet read on big- endian machine Stored as

44. – 44 – COMP 21000, S’15 Summary of the Main Points It’s All About Bits & Bytes Numbers Programs Text Different Machines Follow Different Conventions for Word size Byte ordering Representations Boolean Algebra is the Mathematical Basis Basic form encodes “false” as 0, “true” as 1 General form like bit-level operations in C Good for representing & manipulating sets