jin-soo kim ([email protected]) systems software &...

Integers

Jin-Soo Kim([email protected])

Systems Software &Architecture Lab.

Seoul National University

Fall 2019

4190.308: Computer Architecture | Fall 2019 | Jin-Soo Kim ([email protected]) 2


A computer is a machine.


▪ By John von Neumann, 1945

CPU

Processingunit

Memory

Storageunit

Byte addressable arrayCode + data (user program, OS)Stack to support procedures

Address

Data

Instruction

Data movementArithmetic & logical opsControl transfer


▪ Analog vs. digital?

▪ Compact Disc (CD)

• 44.1 KHz, 16-bit, 2-channel

▪ MP3

• A digital audio encoding with lossy data compression


Source: http://www.soundsetal.com/blog-how-do-vinyl-records-work/http://www.explainthatstuff.com/cdplayers.html


A/D D/A

CPU

Memory

Analog(sensors)

Analog

Digital

...


▪ Information = Bits + Context

• Computers manipulate representations of things

• Things are represented as binary digits

• What can you represent with N bits?

– 2N things

– Numbers, characters, pixels, positions, source code, executable files, machine instructions, …

– Depends on what operations you do on them

01010011 01001110 01010101 01000001 01000010 01000011 01001000 01001001

‘S’ ‘N’ ‘U’ ‘A’ ‘R’ ‘C’ ‘H’ ‘I’(char)

1096109651 1229472594(int)

1.08216479583800794… x 1045(double)


▪ Why not base 10 representation?

• Easy to store with bistable elements

• Straightforward implementation of arithmetic functions

• Reliably transmitted on noisy and inaccurate wires

▪ Electronic implementation

0.0V

0.5V

2.8V

3.3V

0 1 0


▪ Binary: 000000002 to 111111112

▪ Octal: 0008 to 3778• An integer constant that begins with 0 is an octal number in C

▪ Decimal: 010 to 25510• First digit must not be 0 in C

▪ Hexadecimal: 0016 to FF16• Base 16 number representation

• Use characters ‘0’ to ‘9’ and ‘A’ to ‘F’

• Write FA1D37B16 in C as 0xFA1D37B or 0xfa1d37b

0 0 00001 1 00012 2 00103 3 00114 4 01005 5 01016 6 01107 7 01118 8 10009 9 1001A 10 1010B 11 1011C 12 1100D 13 1101E 14 1110F 15 1111

Representing Integers

Chap. 2.4


▪ Encoding unsigned integers

▪ What is the range for unsigned values with w bits?

▪ Using 64 bits: 0 to +18,446,774,073,709,551,615

𝑩 = [𝒃𝒘−𝟏, 𝒃𝒘−𝟐, . . . , 𝒃𝟎]

𝑫(𝑩) =

𝒊=𝟎

𝒘−𝟏

𝒃𝒊 ⋅ 𝟐𝒊

x = 0001 0000 0101 11102

D(x) = 212 + 26 + 24 + 23 + 22 + 21

= 4096 + 64 + 16 + 8 + 4 + 2= 4190


▪ Encoding positive numbers

• Same as unsigned numbers

▪ Encoding negative numbers

• Sign-magnitude representation

• Ones’ complement representation

• Two’s complement representation


▪ Two zeros

• [000…00], [100..00]

▪ Used for floating-point numbers 0000 0001

0010

0011

0100

0101

0110

011110001001

1010

1011

1100

1101

1110

1111

0 12

3

45

67

-4

0-1-2

-3

-5-6

-7

bw-1 bw-2 … … … … b1 b0

Sign bit

𝑺(𝑩) = (−𝟏)𝒃𝒘−𝟏 ⋅

𝒊=𝟎

𝒘−𝟐


Magnitude


▪ Easy to find –n

▪ Two zeros

• [000..00], [111..11]

▪ No longer used

0000 0001

0010

0011

0100

0101

0110

011110001001

1010

1011

1100

1101

1110

1111

0 12

3

45

67-7-6

-5-4

-3

-2-1

0

bw-1 bw-2 … … … … b1 b0

Sign bit

𝑶(𝑩) = −𝒃𝒘−𝟏(𝟐𝒘−𝟏 − 𝟏) +

𝒊=𝟎

𝒘−𝟐



▪ Unique zero

▪ Easy for hardware

• leading 0 ≥ 0

• leading 1 < 0

▪ Used by almost all modern machines

0000 0001

0010

0011

0100

0101

0110

011110001001

1010

1011

1100

1101

1110

1111

0 12

3

45

67-8-7

-6-5

-4

-3-2

-1

bw-1 bw-2 … … … … b1 b0

Sign bit

𝑶(𝑩) = −𝒃𝒘−𝟏 ⋅ 𝟐𝒘−𝟏 +

𝒊=𝟎

𝒘−𝟐


Asymmetric range:

−𝟐𝒏−𝟏 ~ 𝟐𝒏−𝟏 − 𝟏


▪ Following holds for two’s complement

▪ Complement

• Observation: ~ x + x == 1111…112 == – 1

▪ Increment~ x + x == – 1~ x + x + (– x + 1) == – 1 + (– x + 1)~ x + 1 == – x

~ x + 1 == – x


▪ Signed: w bits → w+k bits

• Given w-bit signed integer x

• Convert it to w+k-bit integer with same value

▪ Replicate the sign bit to the left

• +2: 0000 0010 → 0000 0000 0000 0010

• -2: 1111 1110 → 1111 1111 1111 1110

▪ In RISC-V instruction set

• lb: sign-extend loaded byte

• lbu: zero-extend loaded byte

• • •X

X’ • • • • • •

• • •

w

wk

Sign bit

Manipulating Integers

Chap. 2.4, 3.1 – 3.4, 3.6


▪ Operations &, |, ~, ^ available in C

• Apply to any “integral” data type– (unsigned) 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

0x69 ^ 0x55 → 0x3C 011010012 & 010101012 → 001111002


▪ &&, ||, !

• 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

if (p && *p) … // avoids null pointer access


▪ 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 MSB on right

– Useful with two’s complement integer

representation

▪ Undefined if y < 0 or y word size

01100010Argument x

00010000<< 3

00011000Log. >> 2

00011000Arith. >> 2

10100010Argument x

00010000<< 3

00101000Log. >> 2

11101000Arith. >> 2

0001000000010000

0001100000011000

0001100000011000

00010000

00101000

11101000

00010000

00101000

11101000


▪ Example: 7 + 6

▪ Overflow if result out of range

• Adding +ve and –ve operands: No overflow

• Adding two +ve operands: Overflow if result sign is 1

• Adding two –ve operands: Overflow if result sign is 0


▪ Signed addition in C

• Ignores carry output

• The low-order w bits are identical to unsigned addition

Mode x y x + y Truncated x + y

Unsigned

Two’s comp.

4 [100]

-4 [100]

3 [011]

3 [011]

7 [0111]

-1 [1111]

7 [111]

-1 [111]

Unsigned

Two’s comp.

4 [100]

-4 [100]

7 [111]

-1 [111]

11 [1011]

-5 [1011]

3 [011]

3 [011]

Unsigned

Two’s comp.

3 [011]

3 [011]

3 [011]

3 [011]

6 [0110]

6 [0110]

6 [110]

-2 [110]

Examples for 3-bit integer


▪ Add negation of second operand

▪ Example: 7 – 6 = 7 + (–6)

▪ Overflow if result out of range

• Subtracting two +ve or two –ve operands: No overflow

• Subtracting +ve from –ve operand: Overflow if result sign is 0

• Subtracting –ve from +ve operand: Overflow if result sign is 1

+7: 0000 0000 … 0000 0111-6: 1111 1111 … 1111 1010

+1: 0000 0000 … 0000 0001


▪ Graphics and media processing operates on vectors of 8-bit/16-bit data

• Use 64-bit adder,

with partitioned carry chain

• Operate on 8x8-bit, 4x16-bit,

or 2x32-bit vectors

• SIMD (Single-Instruction,

Multiple-Data)

▪ Saturating operations

• On overflow, result is largest representable value

• e.g., clipping in audio, saturation in video

Source: https://software.intel.com/en-us/blogs/2012/01/31/vectorization-find-out-what-it-is-find-out-more


100010011000

0000 0000 1000 1001000

×

▪ Long-multiplication approach

Length of product is the sum of operand lengths

multiplicand

multiplier

product


64th

Initially 0


▪ Perform steps in parallel: add / shift

▪ One cycle per partial-product addition

• That’s ok, if frequency of multiplication is low

Multiplier


▪ 310 x 510 = 000000112 x 000001012

00000011

0000010100000000

MC

MPP


▪ MP0 = 1: Add MC to P, shift right P and MP by 1 bit

00000011

0000010100000011

MC

MPP


▪ MP0 = 0: Shift right P and MP by 1 bit

00000011

1000001000000001

MC

MPP


▪ MP0 = 1: Add MC to P, shift right P and MP by 1 bit

00000011

1100000100000011

MC

MPP


▪ MP0 = 0 (5 times): Shift right P and MP by 1 bit (5 times)

00000011

1110000000000001

MC

MPP


▪ Final product available in P + MP

00000011

0000111100000000

MC

MPP


▪ Uses multiple adders

• Cost/performance tradeoff

▪ Can be pipelined

• Several multiplication performed in parallel


▪ Signed multiplication in C

• Ignores high order w bits

• The low-order w bits are identical to unsigned multiplication

Mode x y x · y Truncated x · y

Unsigned

Two’s comp.

5 [101]

-3 [101]

3 [011]

3 [011]

15 [001111]

-9 [110111]

7 [111]

-1 [111]

Unsigned

Two’s comp.

4 [100]

-4 [100]

7 [111]

-1 [111]

28 [011100]

4 [000100]

4 [100]

-4 [100]

Unsigned

Two’s comp.

3 [011]

3 [011]

3 [011]

3 [011]

9 [001001]

9 [001001]

1 [001]

1 [001]

Examples for 3-bit integer


▪ Check for 0 divisor

▪ If divisor ≤ dividend bits:

1 bit in quotient, subtract

▪ Otherwise: 0 bit in quotient,

bring down next dividend bit

▪ Restoring division

• Do the subtract, and if remainder

goes < 0, add divisor back

10011000 1001010

-100010101 1010

-100010

n-bit operands yield n-bitquotient and remainder

quotient

dividend

remainder

divisor


Initially dividend

Initially divisor in left half


▪ One cycle per partial-remainder subtraction

▪ Looks a lot like a multiplier!• Same hardware can be used for both

Quotient


▪ 1510 / 410 = 000011112 / 000001002

00000100

00000000 00001111

D

R


▪ R – D < 0: Shift left R and Q by 1 bit, Q0 = 0

00000100

00000000 0001111 0

D

R Q


▪ R – D < 0: Shift left R and Q by 1 bit, Q0 = 0 (6 times)

00000100

00000111 1 0000000

D

R Q


▪ R – D >= 0: R = R – D, shift left R and Q by 1 bit, Q0 = 1

00000100

00000111 0000001

D

R Q


▪ R – D >= 0: R = R – D, shift left Q by 1 bit, Q0 = 1

00000100

00000011 00000011

D

R Q


▪ Signed division

• Divide using absolute values

• Adjust sign of quotient and remainder

as required

– (e.g.) 7 / 2: Q = 3, R = 1

(-7) / 2: Q = -3, R = -1

7 / (-2): Q = -3, R = 1

(-7) / (-2): Q = 3, R = -1

▪ Faster division

• Can’t use parallel hardware as in multiplier – Subtraction is conditional on sign of

remainder

• Faster dividers (e.g. SRT division) generate multiple quotient bits per step, but still

require multiple steps

𝑫𝒊𝒗𝒊𝒅𝒆𝒏𝒅 = 𝑸𝒖𝒐𝒕𝒊𝒆𝒏𝒕 × 𝑫𝒊𝒗𝒊𝒔𝒐𝒓 + 𝑹𝒆𝒎𝒂𝒊𝒏𝒅𝒆𝒓

−𝒙

𝒚==

(−𝒙)

𝒚


▪ Power-of-2 multiplication with left shift

• u << k gives u * 2k

– e.g. u << 3 == u * 8, (u << 5) – (u << 3) == u * 24

• Both signed and unsigned

• Faster than multiply

▪ Power-of-2 division with right shift

• u >> k gives u / 2k

• Only for unsigned integers

– e.g. 1010 / 410 = 210, 000010102 >> 2 = 000000102 = 210

-1010 / 410 = -210, 111101102 >> 2 = 111111012 = -310

• For negative numbers, should be computed as (u + (1 << k) – 1) >> k

– e.g. 111101102 + 000000112 = 111110012, 111110012 >> 2 = 111111102 = -210

0 0 1 0 0 0•••

x

2k/

x / 2k

•••

k1 ••• •••

1 •••1 1••• .

Binary Point

0 0 0 1 1 1•••+2k –1 •••

•••

1 ••• •••

1

Incremented by 1

Incremented by 1


▪ Two’s complement for representing negative numbers

▪ Sign extension preserves the value

▪ Same hardware can be used for both signed and unsigned addition. This

is also true for multiplication. But their overflow conditions are different.

▪ Remember?

▪ Using shift right for power-of-2 division requires correction for negative

numbers

int x = 50000;printf (“%s\n”, (x*x >= 0)? “Yes” : “No”);

jin-soo kim ([email protected]) systems software &...

Documents