1. Lecture 2 Representations
CSC 2400 Computer Systems I
Lecture 2
Representations

2. The Machine

3. 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
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.

4. How do we represent data in a computer?
At the lowest level, a computer is an electronic machine.
works by controlling the flow of electrons
Easy to recognize two conditions:
presence of a voltage – we’ll call this state “1”
absence of a voltage – we’ll call this state “0”
Could base state on value of voltage, but control and detection circuits more complex.
compare turning on a light switch to measuring or regulating voltage

5. Computer is a binary digital system.
finite number of symbols
Binary (base two) system:
has two states: 0 and 1
Basic unit of information is the binary digit, or bit.
Values with more than two states require multiple bits.
A collection of two bits has four possible states: 00, 01, 10, 11
A collection of three bits has eight possible states: 000, 001, 010, 011, 100, 101, 110, 111
A collection of n bits has 2n possible states.

6. What kinds of data do we need to represent?
Numbers – signed, unsigned, integers, floating point, complex, rational, irrational, …
Text – characters, strings, …
Images – pixels, colors, shapes, …
Sound
Logical – true, false
Instructions …
Data type:
representation and operations within the computer

7. Machine Words 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

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

9. Data Representations Sizes of C Objects (in Bytes)
C Data Type Sparc/Unix Typical 32-bit Intel IA32
int 4 4 4
long int 8 4 4
char 1 1 1
short 2 2 2
float 4 4 4
double 8 8 8
long double /12
char * 8 4 4
Or any other “pointer”

10. Pointers and Arrays Pointer Array Address of a variable in memory
Allows us to indirectly access variables
in other words, we can talk about its address rather than its value
Array
A list of values arranged sequentially in memory
Example: a list of telephone numbers
Expression a[4] refers to the 5th element of the array a

11. Address vs. Value
Sometimes we want to deal with the address of a memory location, rather than the value it contains.
Adding a column of numbers.
R2 contains address of first location.
Read value, add to sum, and increment R2 until all numbers have been processed.
R2 is a pointer -- it contains the address of data we’re interested in.
address
value
x3107
x3100
x2819
x3101 R2
x3100
x0110
x3102
x0310
x3103
x0100
x3104
x1110
x3105
x11B1
x3106
x0019
x3107

12. Byte Ordering
How should bytes within multi-byte word be ordered in memory?
Conventions
Sun’s, Mac’s are “Big Endian” machines
Least significant byte has highest address
Alphas, PC’s are “Little Endian” machines
Least significant byte has lowest address

13. Byte Ordering Example Big Endian Little Endian Example
Least significant byte has highest address
Little Endian
Least significant byte has lowest address
Example
Variable x has 4-byte representation 0x
Address given by &x is 0x100
Big Endian
0x100
0x101
0x102
0x103 01 23 45 67 01 23 45 67
Little Endian
0x100
0x101
0x102
0x103 67 45 23 01 67 45 23 01

14. Machine-Level Code Representation
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!

15. Big Idea: Information is Bits + Context
Computer stores the bits
You decide how to interpret them
Example (binary)
Decimal = 13
Float = E-44
Chapter 1

16. Integers

17. Unsigned Integers 329 101 102 101 100 22 21 20 Non-positional notation
could represent a number (“5”) with a string of ones (“11111”)
problems?
Weighted positional notation
like decimal numbers: “329”
“3” is worth 300, because of its position, while “9” is only worth 9
most
significant
least
significant
329
102
101
100
101 22 21 20
3x x10 + 9x1 = 329
1x4 + 0x2 + 1x1 = 5

18. Unsigned Integers (cont.)
An n-bit unsigned integer represents 2n values: from 0 to 2n-1. 22 21 20 1 2 3 4 5 6 7

19. Unsigned Binary Arithmetic
Base-2 addition – just like base-10!
add from right to left, propagating carry
carry
10111
+ 111

20. Signed Integers With n bits, we have 2n distinct values.
assign about half to positive integers (1 through 2n-1) and about half to negative (- 2n-1 through -1)
that leaves two values: one for 0, and one extra
Positive integers
just like unsigned – zero in most significant bit = 5
Negative integers
sign-magnitude – set top bit to show negative, other bits are the same as unsigned = -5
one’s complement – flip every bit to represent negative = -5
in either case, MS bit indicates sign: 0=positive, 1=negative

21. Two’s Complement + 11011 (-5) + (-9) 00000 (0) 00000 (0)
Problems with sign-magnitude and 1’s complement
two representations of zero (+0 and –0)
arithmetic circuits are complex
How to add two sign-magnitude numbers?
e.g., try 2 + (-3)
How to add to one’s complement numbers?
e.g., try 4 + (-3)
Two’s complement representation developed to make circuits easy for arithmetic.
for each positive number (X), assign value to its negative (-X), such that X + (-X) = 0 with “normal” addition, ignoring carry out
00101 (5) (9)
(-5) + (-9)
00000 (0) (0)

22. Two’s Complement Representation
If number is positive or zero,
normal binary representation, zeroes in upper bit(s)
If number is negative,
start with positive number
flip every bit (i.e., take the one’s complement)
then add one
00101 (5) (9)
11010 (1’s comp) (1’s comp)
11011 (-5) (-9)

23. Two’s Complement Signed Integers
MS bit is sign bit – it has weight –2n-1.
Range of an n-bit number: -2n-1 through 2n-1 – 1.
The most negative number (-2n-1) has no positive counterpart.
-23 22 21 20 1 2 3 4 5 6 7
-23 22 21 20 1 -8 -7 -6 -5 -4 -3 -2 -1

24. ASCII, etc.

25. Text: ASCII Characters
ASCII: Maps 128 characters to 7-bit code. (type man ascii)
both printable and non-printable (ESC, DEL, …) characters 00
nul 10
dle 20 sp 30 40 @ 50 P 60 ` 70 p 01
soh 11
dc1 21 ! 31 1 41 A 51 Q 61 a 71 q 02
stx 12
dc2 22
" 32 2 42 B 52 R 62 b 72 r 03
etx 13
dc3 23 # 33 3 43 C 53 S 63 c 73 s 04
eot 14
dc4 24 $ 34 4 44 D 54 T 64 d 74 t 05
enq 15
nak 25 % 35 5 45 E 55 U 65 e 75 u 06
ack 16
syn 26
& 36 6 46 F 56 V 66 f 76 v 07
bel 17
etb 27 ' 37 7 47 G 57 W 67 g 77 w 08 bs 18
can 28 ( 38 8 48 H 58 X 68 h 78 x 09 ht 19 em 29 ) 39 9 49 I 59 Y 69 i 79 y 0a nl 1a
sub 2a * 3a : 4a J 5a Z 6a j 7a z 0b vt 1b
esc 2b + 3b ; 4b K 5b [ 6b k 7b { 0c np 1c fs 2c , 3c
< 4c L 5c \ 6c l 7c | 0d cr 1d gs 2d - 3d = 4d M 5d ] 6d m 7d } 0e so 1e rs 2e . 3e
> 4e N 5e ^ 6e n 7e ~ 0f si 1f us 2f / 3f ? 4f O 5f _ 6f o 7f
del

26. Interesting Properties of ASCII Code
What is relationship between a decimal digit ('0', '1', …) and its ASCII code?
What is the difference between an upper-case letter ('A', 'B', …) and its lower-case equivalent ('a', 'b', …)?
Given two ASCII characters, how do we tell which comes first in alphabetical order?
Are 128 characters enough? (

27. Other Data Types Text strings Image Sound
sequence of characters, terminated with NULL (0)
typically, no special hardware support
Image
array of pixels
monochrome: one bit (1/0 = black/white)
color: red, green, blue (RGB) components (e.g., 8 bits each)
other properties: transparency
hardware support:
typically none, in general-purpose processors
MMX -- multiple 8-bit operations on 32-bit word
Sound
sequence of fixed-point numbers

28. Pointers in C
C lets us talk about and manipulate “pointers” (addresses) as variables and in expressions.
Declaration
int *p; /* p is a pointer to an int */
A pointer in C is always a pointer to a particular data type: int*, double*, char*, etc.
Operators
*p -- returns the value pointed to by p (“dereference”)
&z -- returns the address of variable z (“address of”)

29. Example int i; int *ptr; i = 4; ptr = &i; *ptr = *ptr + 1;
store the value 4 into the memory location
associated with i
store the address of i into the memory location associated with ptr
read the contents of memory at the address stored in ptr
store the result into memory
at the address stored in ptr

30. Converting Integer Representations

31. Converting Binary (2’s C) to Decimal
If leading bit is one, take two’s complement to get a positive number.
Add powers of 2 that have “1” in the corresponding bit positions.
If original number was negative, add a minus sign. n 2n 1 2 4 3 8 16 5 32 6 64 7
128
256 9
512 10
1024
X = two
= =
= 104ten
Assuming 8-bit 2’s complement numbers.

32. More Examples X = 00100111two = 25+22+21+20 = 32+4+2+1 = 39ten
= =
= 39ten n 2n 1 2 4 3 8 16 5 32 6 64 7
128
256 9
512 10
1024
X = two
-X =
= =
= 26ten
X = -26ten
Assuming 8-bit 2’s complement numbers.

33. Converting Decimal to Binary (2’s C)
First Method: Division
Divide by two – remainder is least significant bit.
Keep dividing by two until answer is zero, writing remainders from right to left.
Append a zero as the MS bit; if original number negative, take two’s complement.
X = 104ten 104/2 = 52 r0 bit 0
52/2 = 26 r0 bit 1
26/2 = 13 r0 bit 2
13/2 = 6 r1 bit 3
6/2 = 3 r0 bit 4
3/2 = 1 r1 bit 5
X = two 1/2 = 0 r1 bit 6

34. Converting Decimal to Binary (2’s C)1 2 4 3 8 16 5 32 6 64 7
128
256 9
512 10
1024
Second Method: Subtract Powers of Two
Change to positive decimal number.
Subtract largest power of two less than or equal to number.
Put a one in the corresponding bit position.
Keep subtracting until result is zero.
Append a zero as MS bit; if original was negative, take two’s complement.
X = 104ten = 40 bit 6
= 8 bit 5
8 - 8 = 0 bit 3
X = two

35. Hexadecimal Notation
It is often convenient to write binary (base-2) numbers as hexadecimal (base-16) numbers instead.
fewer digits -- four bits per hex digit
less error prone -- easy to corrupt long string of 1’s and 0’s
Binary
Hex
Decimal
0000
0001 1
0010 2
0011 3
0100 4
0101 5
0110 6
0111 7
Binary
Hex
Decimal
1000 8
1001 9
1010 A 10
1011 B 11
1100 C 12
1101 D 13
1110 E 14
1111 F 15

36. Converting from Binary to Hexadecimal
Every four bits is a hex digit.
start grouping from right-hand side 3 A 8 F 4 D 7
This is not a new machine representation, just a convenient way to write the number.

37. Operations in C

38. Overview of some C operators!
Logical NOT or “bang” ~
Bitwise NOT (“flips” bits)
&
Bitwise AND ^
Bitwise XOR |
Bitwise OR +
Addition
<<
Bitwise left shift (shifts bits to left)
>>
Bitwise right shift (shifts bits to right)

39. Addition + 11110000 (-16) + (-9) 01011000 (88) (-19)
2’s comp. addition is just binary addition.
assume all integers have the same number of bits
ignore carry out
for now, assume that sum fits in n-bit 2’s comp. representation
(104) (-10)
(-16) + (-9)
(88) (-19)
Assuming 8-bit 2’s complement numbers.

40. Subtraction - 00010000 (16) + (-9) + 11110000 (-16) + (9)
Negate subtrahend (2nd no.) and add.
assume all integers have the same number of bits
ignore carry out
for now, assume that difference fits in n-bit 2’s comp. representation
(104) (-10)
(16) + (-9)
(88) (-19)
(-16) + (9)
(88) (-1)
Assuming 8-bit 2’s complement numbers.

41. Sign Extension
To add two numbers, we must represent them with the same number of bits.
If we just pad with zeroes on the left:
Instead, replicate the MS bit -- the sign bit:
4-bit 8-bit
0100 (4) (still 4)
1100 (-4) (12, not -4)
4-bit 8-bit
0100 (4) (still 4)
1100 (-4) (still -4)

42. Overflow + 01001 (9) + 10111 (-9) 10001 (-15) 01111 (+15)
If operands are too big, then sum cannot be represented as an n-bit 2’s comp number.
We have overflow if:
signs of both operands are the same, and
sign of sum is different.
Another test -- easy for hardware:
carry into MS bit does not equal carry out
01000 (8) (-8)
(9) (-9)
10001 (-15) (+15)

43. Logical Operations Operations on logical TRUE or FALSE
two states -- takes one bit to represent: TRUE=1, FALSE=0
View n-bit number as a collection of n logical values
operation applied to each bit independently A B
A AND B 1 A B
A OR B 1 A
NOT A 1

44. Examples of Logical Operations
AND
useful for clearing bits
AND with zero = 0
AND with one = no change OR
useful for setting bits
OR with zero = no change
OR with one = 1
NOT
unary operation -- one argument
flips every bit
AND OR
NOT

45. Bit-Level Operations in C
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
~ >
~0x00 --> 0xFF
~ >
0x69 & 0x55 --> 0x41
& >
0x69 | 0x55 --> 0x7D
| >

46. Relations Between Operations
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

47. General Boolean Algebras
Operate on Bit Vectors
Operations applied bitwise
All of the Properties of Boolean Algebra Apply
& | ^ ~

48. 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)

49. Shift Operations Left Shift: x << y Right 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
Useful with two’s complement integer representation
Argument x
<< 3
Log. >> 2
Arith. >> 2
Argument x
<< 3
Log. >> 2
Arith. >> 2

50. Limits of the Machine

51. Numeric Ranges Unsigned Values Two’s Complement Values Other Values
UMin = 0
000…0
UMax = 2w – 1
111…1
Two’s Complement Values
TMin = –2w–1
100…0
TMax = 2w–1 – 1
011…1
Other Values
Minus 1
111…1
Values for W = 16

52. Values for Different Word Sizes
Observations
|TMin | = TMax + 1
Asymmetric range
UMax = 2 * TMax + 1
C Programming
 #include <limits.h>
K&R App. B11
Declares constants, e.g.,
 ULONG_MAX
 LONG_MAX
 LONG_MIN
Values platform-specific

53. Casting Signed to Unsigned
C Allows Conversions from Signed to Unsigned
Resulting Value
No change in bit representation
Nonnegative values unchanged
ux = 15213
Negative values change into (large) positive values
uy = 50323
short int x = ;
unsigned short int ux = (unsigned short) x;
short int y = ;
unsigned short int uy = (unsigned short) y;

54. Signed vs. Unsigned in C Constants Casting
By default are considered to be signed integers
Unsigned if have “U” as suffix
0U, U
Casting
Explicit casting between signed & unsigned same as U2T and T2U
int tx, ty;
unsigned ux, uy;
tx = (int) ux;
uy = (unsigned) ty;
Implicit casting also occurs via assignments and procedure calls
tx = ux;
uy = ty;

55. Why Should I Use Unsigned?
Don’t Use Just Because Number Nonzero
C compilers on some machines generate less efficient code
unsigned i;
for (i = 1; i < cnt; i++)
a[i] += a[i-1];
Easy to make mistakes
for (i = cnt-2; i >= 0; i--)
a[i] += a[i+1];
Do Use When Performing Modular Arithmetic
Multiprecision arithmetic
Other esoteric stuff
Do Use When Need Extra Bit’s Worth of Range
Working right up to limit of word size

56. Multiplication Computing Exact Product of w-bit numbers x, y Ranges
Either signed or unsigned
Ranges
Unsigned:
Result requires up to 2w bits
Two’s complement:
Result requires to 2w–1 bits
Maintaining Exact Results
Would need to keep expanding word size with each product computed
Done in software by “arbitrary precision” arithmetic packages

57. Unsigned Multiplication in C
• • •
Operands: w bits * v
• • •
True Product: 2*w bits
u · v
• • •
• • •
UMultw(u , v)
• • •
Discard w bits: w bits
Standard Multiplication Function
Ignores high order w bits
Implements Modular Arithmetic
UMultw(u , v) = u · v mod 2w

58. Unsigned vs. Signed Multiplication
Unsigned Multiplication
unsigned ux = (unsigned) x;
unsigned uy = (unsigned) y;
unsigned up = ux * uy
Truncates product to w-bit number up = UMultw(ux, uy)
Modular arithmetic: up = ux  uy mod 2w
Two’s Complement Multiplication
int x, y;
int p = x * y;
Compute exact product of two w-bit numbers x, y
Truncate result to w-bit number p = TMultw(x, y)

59. Power-of-2 Multiply with Shift
Operation
u << k gives u * 2k
Both signed and unsigned
Examples
u << 3 == u * 8
u << 5 - u << 3 == u * 24
Most machines shift and add much faster than multiply
Compiler generates this code automatically k u
• • •
Operands: w bits * 2k
••• 1
•••
True Product: w+k bits
u · 2k
• • •
•••
UMultw(u , 2k)
•••
•••
Discard k bits: w bits
TMultw(u , 2k)

60. Unsigned Power-of-2 Divide with Shift
Quotient of Unsigned by Power of 2
u >> k gives  u / 2k 
Uses logical shift k u
Binary Point
•••
•••
Operands: / 2k
••• 1
•••
Division:
u / 2k .
•••
•••
•••
Result:
 u / 2k 
•••
•••

61. Signed Power-of-2 Divide with Shift
Quotient of Signed by Power of 2
x >> k gives  x / 2k 
Uses arithmetic shift
Rounds wrong direction when u < 0 1
••• x 2k /
x / 2k
Division:
Operands: k
RoundDown(x / 2k)
Result: .
Binary Point

62. Correct Power-of-2 Divide
Quotient of Negative Number by Power of 2
Want  x / 2k  (Round Toward 0)
Compute as  (x+2k-1)/ 2k 
In C: (x + (1<<k)-1) >> k
Biases dividend toward 0
Case 1: No rounding k
Dividend: u 1
•••
•••
+2k +–1
••• 1
••• 1 1
Binary Point 1
••• 1
••• 1 1
Divisor: / 2k
••• 1
•••
 u / 2k  . 1
••• 1 1 1
••• 1
••• 1 1
Biasing has no effect

63. Correct Power-of-2 Divide (Cont.)
Case 2: Rounding k
Dividend: x 1
•••
•••
+2k +–1
••• 1
••• 1 1 1
•••
•••
Incremented by 1
Binary Point
Divisor: / 2k
••• 1
•••
 x / 2k  . 1
••• 1 1 1
•••
•••
Biasing adds 1 to final result
Incremented by 1

64. Floating Point

65. Fractions: Fixed-Point
How can we represent fractions?
Use a “binary point” to separate positive from negative powers of two -- just like “decimal point.”
2’s comp addition and subtraction still work.
if binary points are aligned
(40.625)
( -1.25) [note, it is in 2s compl.]
(39.375)
2-1 = 0.5
2-2 = 0.25
2-3 = 0.125
No new operations -- same as integer arithmetic.

66. Very Large and Very Small: Floating-Point
Large values: x requires 79 bits
Small values: x requires >110 bits
Use equivalent of “scientific notation”: F x 2E
Need to represent F (fraction), E (exponent), and sign.
IEEE 754 Floating-Point Standard (32-bits): 1b 8b
23b S
Exponent
Fraction

67. Floating Point Example
Single-precision IEEE floating point number:
Sign is 1 – number is negative.
Exponent field is = 126 (decimal).
Fraction is … = 0.5 (decimal).
Value = -1.5 x 2( ) = -1.5 x 2-1 =
sign
exponent
fraction

68. Floating Point in C C Guarantees Two Levels Conversions
float single precision
double double precision
Conversions
Casting between int, float, and double changes numeric values
Double or float to int
Truncates fractional part
Like rounding toward zero
Not defined when out of range
Generally saturates to TMin or TMax
int to double
Exact conversion, as long as int has ≤ 53 bit word size
int to float
Will round according to rounding mode