“The Class That Gives KUET Its Zip!

 Topics
› Why bits?
› Representing information as bits
 Binary/Hexadecimal
 Byte representations
 numbers
 characters and strings
 Instructions
› Bit-level manipulations
 Boolean algebra
 Expressing in C
 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
 1.5213 X 104
 Implementing Electronically
› Hard to store
 ENIAC (First electronic computer) used 10 vacuum tubes / digit
› Hard to transmit
 Need high precision to encode 10 signal levels on single wire
› Messy to implement digital logic functions
 Addition, multiplication, etc.
 Base 2 Number Representation
› Represent 1521310 as 111011011011012
› Represent 1.2010 as 1.0011001100110011[0011]…2
› Represent 1.5213 X 104 as 1.11011011011012 X 213
 Electronic Implementation
› Easy to store with bistable elements
› Reliably transmitted
0 on noisy and inaccurate
1 wires 0
3.3V
2.8V

0.5V
0.0V
› Straightforward implementation of arithmetic functions
 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 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
› Multiple mechanisms: static, stack, and heap
› In any case, all allocation within single virtual address space
 Byte = 8 bits al y
im ar
x c n
He De Bi
› Binary 000000002 to
0 0 0000
111111112 1 1 0001
2 2 0010
3 3 0011
› Decimal: 010 to 25510 4 4 0100
5 5 0101
› Hexadecimal 0016 to FF16 6 6 0110
7 7 0111
 Base 16 number representation 8 8 1000
9 9 1001
 Use characters ‘0’ to ‘9’ and ‘A’ to ‘F’ A 10 1010
B 11 1011
 Write FA1D37B16 in C as 0xFA1D37B C 12 1100
D 13 1101
 Or 0xfa1d37b E 14 1110
F 15 1111
 Machine Has “Word Size”
› Nominal size of integer-valued data
 Including addresses
› Most current machines are 32 bits (4 bytes)
 Limits addresses to 4GB
 Becoming too small for memory-intensive applications
› High-end systems are 64 bits (8 bytes)
 Potentially address 1.8 X 1019 bytes
› Machines support multiple data formats
 Fractions or multiples of word size
 Always integral number of bytes
 32-bit 64-bit Bytes Addr.
Words Words
0000
Addr
0001
 Addresses Specify Byte =
0000 0002
Addr
Locations = 0003
0000 0004
› Address of first byte in Addr
= 0005
word 0004 0006
0007
› Addresses of successive 0008
words differ by 4 (32- Addr
= 0009
bit) or 8 (64-bit) 0008
Addr
0010
= 0011
0008 0012
Addr
= 0013
0012 0014
0015
 Sizes of C Objects (in Bytes)
C Data Type Compaq Alpha Typical 32-bit
int 4 4
long int 8 4
char 1 1
short 2 2
float 4 4
double 8 8
char * 8 4
 Or any other pointer
 Issue
› How should bytes within multi-byte word be ordered in memory
 Conventions
› Alphas, PC’s are “Little Endian” machines
 Least significant byte has lowest address
› Sun’s, Mac’s are “Big Endian” machines
 Least significant byte has highest address
 Example
› Variable x has 4-byte representation 0x1234567
› Address given by &x is 0x100

Big Endian 0x100 0x101 0x102 0x103

01 23 45 67
Little Endian 0x100 0x101 0x102 0x103
67 45 23 01
 Code to Print Byte Representation of Data
› Cast pointer to unsigned char * creates byte array

typedef unsigned char *pointer;

void show_bytes(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
int a = 15213;
printf("int a = 15213;\n");
show_bytes((pointer) &a, sizeof(int));

Result:
int a = 15213;
0x11ffffcb8 0x6d
0x11ffffcb9 0x3b
0x11ffffcba 0x00
0x11ffffcbb 0x00
 int A = 15213; Decimal: 15213
 int B = -15213; Binary: 0011 1011 0110 1101
 long int C = 15213;
Hex: 3 B 6 D

Alpha A Sun A Alpha C Sun C

6D 00 6D 00
3B 00 3B 00
00 3B 00 3B
00 6D 00 6D
00
Alpha B Sun B 00
00
93 FF
00
C4 FF
FF C4
FF 93 Two’s complement representation
(Covered next lecture)
 Alpha P
 int B = -15213;
A0
 int *P = &B; FC
FF
Alpha Address FF
Hex: 1 F F F F F C A 0 01
00
Binary: 0001 1111 1111 1111 1111 1111 1100 1010 0000
00
00

Sun P
EF Sun Address
FF
FB Hex: E F F F F B 2 C
Binary: 1110 1111 1111 1111 1111 1011 0010
2C
1100
Different compilers & machines assign different locations to objects
 Alpha F Sun F
 Float F = 15213.0;
00 46
B4 6D
6D B4
46 00

IEEE Single Precision Floating Point Representation

Hex: 4 6 6 D B 4 0 0
Binary: 0100 0110 0110 1101 1011 0100 0000
0000
15213: 1110 1101 1011 01

Not same as integer representation, but consistent across machines

 Strings in C char S[6] = "15213";
› Represented by array of characters
› Each character encoded in ASCII format
 Standard 7-bit encoding of character set Alpha S Sun S
 Other encodings exist, but uncommon
 Character “0” has code 0x30 31 31
 Digit i has code 0x30+i 35 35
› String should be null-terminated 32 32
 Final character = 0
31 31
 Compatibility 33 33
› Byte ordering not an issue
00 00
 Data are single byte quantities
› Text files generally platform independent
 Except for different conventions of line
termination character!
 Encode Program as Sequence of Instructions
› Each simple operation
 Arithmetic operation
 Read or write memory
 Conditional branch
› Instructions encoded as bytes
 Alpha’s, Sun’s, Mac’s use 4 byte instructions
 Reduced Instruction Set Computer (RISC)
 PC’s use variable length instructions
 Complex Instruction Set Computer (CISC)
› Different instruction types and encodings for different
machines
 Most code not binary compatible
 Programs are Byte Sequences Too!
 Alpha sum Sun sum PC sum
 int sum(int x, int y)
 { 00 81 55
 return x+y; 00 C3 89
30 E0 E5
 }
42 08 8B
01 90 45
• For this example, Alpha & Sun
use two 4-byte instructions 80 02 0C
– Use differing numbers of FA 00 03
instructions in other cases 6B 09 45
• PC uses 7 instructions with 08
lengths 1, 2, and 3 bytes 89
– Same for NT and for Linux EC
– NT / Linux not binary 5D
compatible C3

Different machines use totally different instructions and encodings

  Developed by George Boole in 19th Century
› Algebraic representation of logic
 Encode “True” as 1 and “False” as 0
And Or
• A&B = 1 when both A=1 and B=1 • A|B = 1 when either A=1 or B=1

Not
Exclusive-Or (Xor)
• ~A = 1 when A=0
• A^B = 1 when either A=1 or B=1,
but not both
 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 ~B Connection when
A&~B | ~A&B
~A B = A^B
 Integer Arithmetic
› Z, +, *, –, 0, 1 forms a “ring”
› Addition is “sum” operation
› Multiplication is “product” operation
› – is additive inverse
› 0 is identity for sum
› 1 is identity for product
 Boolean Algebra
› {0,1}, |, &, ~, 0, 1 forms a “Boolean algebra”
› Or is “sum” operation
› And is “product” operation
› ~ is “complement” operation (not additive inverse)
› 0 is identity for sum
› 1 is identity for product
 Boolean Algebra
Integer Ring
› Commutativity
A| B = B|A A+ B = B +A
A& B = B &A A* B = B*A
› Associativity
(A | B) | C = A | (B | C) (A + B) + C = A + (B + C)
(A & B) & C = A & (B & C) (A * B) * C = A * (B * C)
› Product distributes over sum
A & (B | C) = (A & B) | (A & C) A * (B + C) = A * B + B * C
› Sum and product identities
A| 0 = A A+ 0 = A
A&1 = A A* 1 =A
› Zero is product annihilator
A&0 = 0 A* 0 = 0
› Cancellation of negation
~ (~ A) = A – (– A) = A
 Boolean Algebra
Integer Ring
› Boolean: Sum distributes over product
A | (B & C) = (A | B) & (A | C) A + (B * C)  (A + B) * (B
+ C)
› Boolean: Idempotency
A|A = A A +AA
 “A is true” or “A is true” = “A is true”
A&A = A A *AA
› Boolean: Absorption
A | (A & B) = A A + (A * B)  A
 “A is true” or “A is true and B is true” = “A is true”
A & (A | B) = A A * (A + B)  A
› Boolean: Laws of Complements
A | ~A = 1 A + –A  1
 “A is true” or “A is false”
› Ring: Every element has additive inverse
A | ~A  0 A + –A = 0
 Boolean Ring
› {0,1}, ^, &, , 0, 1
› Identical to integers mod 2
›  is identity operation: (A) = A
A^A=0
 Property Boolean Ring
› Commutative sum A^B = B ^A
› Commutative product A& B = B &A
› Associative sum (A ^ B) ^ C = A ^ (B ^ C)
› Associative product (A & B) & C = A & (B & C)
› Prod. over sum A & (B ^ C) = (A & B) ^ (B & C)
› 0 is sum identity A^0 = A
› 1 is prod. identity A&1 = A
› 0 is product annihilator A&0=0
› Additive inverse A^A = 0
 DeMorgan’s Laws
› Express & in terms of |, and vice-versa
A & B = ~(~A | ~B)
 A and B are true if and only if neither A nor B is false
A | B = ~(~A & ~B)
 A or B are true if and only if A and B are not both false
 Exclusive-Or using Inclusive Or
A ^ B = (~A & B) | (A & ~B)
 Exactly one of A and B is true
A ^ B = (A | B) & ~(A & B)
 Either A is true, or B is true, but not both
 Operate on Bit Vectors
› Operations applied bitwise

01101001 01101001 01101001

& 01010101 | 01010101 ^ 01010101 ~ 01010101
01000001 01111101 00111100 10101010
 Representation of Sets
› Width w bit vector represents subsets of {0, …, w–1}
› aj = 1 if j  A
 01101001 { 0, 3, 5, 6 }
 01010101 { 0, 2, 4, 6 }
› & Intersection 01000001 { 0, 6 }
› | Union 01111101 { 0, 2, 3, 4, 5,
6}
› ^ Symmetric difference 00111100 { 2, 3, 4, 5 }
› ~ Complement 10101010 { 1, 3, 5, 7 }
 Operations &, |, ~, ^ Available in C
› Apply to any “integral” data type
 long, int, short, char
› View arguments as bit vectors
› Arguments applied bit-wise
 Examples (Char data type)
› ~0x41 --> 0xBE
~010000012 --> 101111102
› ~0x00 --> 0xFF
~000000002 --> 111111112

› 0x69 & 0x55 --> 0x41

011010012 & 010101012 --> 010000012
› 0x69 | 0x55 --> 0x7D
011010012 | 010101012 --> 011111012
 Contrast to Logical Operators
› &&, ||, !
 View 0 as “False”
 Anything nonzero as “True”
 Always return 0 or 1
 Examples (char data type)
› !0x41 --> 0x00
› !0x00 --> 0x01
› !!0x41 --> 0x01

› 0x69 && 0x55 -->

0x01
› 0x69 || 0x55 -->
0x01
 Left Shift: x << y
› Shift bit-vector x left y positions Argument x 01100010
 Throw away extra bits on left
<< 3 00010000
 Fill with 0’s on right
 Right Shift: x >> y Log. >> 2 00011000
› Shift bit-vector x right y positions Arith. >> 2 00011000
 Throw away extra bits on right
› Logical shift
 Fill with 0’s on left Argument x 10100010
› Arithmetic shift << 3 00010000
 Replicate most significant bit on
right Log. >> 2 00101000
 Useful with two’s complement Arith. >> 2 11101000
integer representation
› Bitwise Xor is form of void funny(int *x, int *y)
addition {
› With extra property *x = *x ^ *y; /* #1 */
that every value is its *y = *x ^ *y; /* #2 */
own additive inverse
A^A= 0 *x = *x ^ *y; /* #3 */
}

Step *x *y
Begin A B
1 A^B B
2 A^B (A^B)^B = A^(B^B) =
A^0 = A
3 (A^B)^A = (B^A)^A = A
B^(A^A) = B^0 = B
End B A