- 158 Views
- Uploaded on

Download Presentation
## PowerPoint Slideshow about 'Bits and Bytes' - remedy

**An Image/Link below is provided (as is) to download presentation**

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript

Recall boolean logical operators in Java…

- boolean logical operators: &, |, ^
- not: !

Also conditional operators: &&, ||

- Difference between & and &&.
- Differences between | and ||.
- How can we demonstrate this?

Bitwise integer operators

- HLL such as Java and C/C++ support many bitwise integer operators.
- Java:
- bitwise: &, ^, |, -, ~
- shift: <<, >>, >>>

(Note: C/C++ supports all of the above except >>>.)

Bitwise integer operators

- Note: In Java and C/C++ as in Assembler, the bitwise operators can be applied to any of the integer data types (char, short, int, and long).
- Note: All of the following examples employ 8-bit (byte) or 16-bit (short) integers but the ideas can and are extended to other integer data sizes.
- Note: All of the following examples represent numbers in hex and binary for convenience. These rules apply to decimal numbers as well.

~ (1’s complement)

- Given 0x3a, what is ~0x3a?
- Given 0x0022, what is ~0x0022?

- (2’s complement)

- Given 0x3a, what is -0x3a?
- Given 0x0022, what is -0x0022?

Shift operators

- Left shift: A << B
- Signed right shift: A >> B (sign extension)
- Unsigned right shift: A >>> B (zero extension)

A = value to be shifted

B = shift distance

Shift operators

Left shift: A << B

Shift operators

Signed right shift: A >> B (sign extension)

Shift operators

Unsigned right shift: A >>> B (zero extension)

Examples

10 >> 1 5 0000 1010 >> 1 = 0000 0101

27 >> 3 3 0001 1011 >> 3 = 0000 0011

-50 >> 2 -13 1100 1110 >> 2 = 1111 0011

What is 1111 0011?

0000 1100 + 1 = 0000 1101 = 13

So 1111 0011 = -13

Preserves sign.

Examples

-50 >>> 2 51 1100 1110 >>> 2 = 0011 0011

0xff >>> 4 15 1111 1111 >>> 4 = 0000 1111

Does not preserve sign.

Problem 1

- How can we determine if an int is odd or even?

Problem 2

- Using bitwise operators, write a program in Java that converts an int from its current endian-ness to the other.

Problem 3

- Say class sizes are limited to 32 students. Therefore, I can use the bits in an int to indicate whether or not students took a particular quiz:

int quiz1 = 0; // What does this indicate?

// How do I indicate that student #7 took the quiz?

Problem 3

- Say class sizes are limited to 32 students. Therefore, I can use the bits in an int to indicate whether or not students took a particular quiz:

int quiz1 = 0; // indicate that no one took the quiz

quiz1 |= 1 << 7; // indicate that student #7 took the quiz

// How do I indicate that student #4 took the quiz?

Problem 3

- Say class sizes are limited to 32 students. Therefore, I can use the bits in an int to indicate whether or not students took a particular quiz:

int quiz1 = 0; // indicate that no one took the quiz

quiz1 |= 1 << 7; // indicate that student #7 took the quiz

quiz1 |= 1 << 4; // indicate that student #4 took the quiz

// Oops! Student #7 didn’t take the quiz. Turn it off.

Problem 3

int quiz1 = 0; // indicate that no one took the quiz

quiz1 |= 1 << 7; // indicate that student #7 took the quiz

quiz1 |= 1 << 4; // indicate that student #4 took the quiz

quiz1 &= ~(1 << 7); // Oops! Student #7 didn’t take the quiz. Turn it off.

Problem 3Say class sizes are limited to 32 students. Therefore, I can use the bits in an int to indicate whether or not students took a particular quiz:

int quiz1 = 0; // indicate that no one took the quiz

quiz1 |= 1 << 7; // indicate that student #7 took the quiz

quiz1 |= 1 << 4; // indicate that student #4 took the quiz

quiz1 &= ~(1 << 7); // Oops! Student #7 didn’t take the quiz. Turn it off.

int quiz2 = 0; // let’s give another quiz!

… // indicate students that took quiz 2

// How can we determine if student #4 took both?

Problem 3Say class sizes are limited to 32 students. Therefore, I can use the bits in an int to indicate whether or not students took a particular quiz:

int quiz1 = 0; // indicate that no one took the quiz

quiz1 |= 1 << 7; // indicate that student #7 took the quiz

quiz1 |= 1 << 4; // indicate that student #4 took the quiz

quiz1 &= ~(1 << 7); // Oops! Student #7 didn’t take the quiz. Turn it off.

int quiz2 = 0; // let’s give another quiz!

… // indicate students that took quiz 2

// determine if student #4 took both

final int s7 = 1<<7;

if ( (quiz1&s7) != 0 && (quiz2&s7) != 0 ) {

… //student 7 took both

}

Problem 3Say class sizes are limited to 32 students. Therefore, I can use the bits in an int to indicate whether or not students took a particular quiz:

int quiz1 = 0; // indicate that no one took the quiz

quiz1 |= 1 << 7; // indicate that student #7 took the quiz

quiz1 |= 1 << 4; // indicate that student #4 took the quiz

quiz1 &= ~(1 << 7); // Oops! Student #7 didn’t take the quiz. Turn it off.

int quiz2 = 0; // let’s give another quiz!

… // indicate students that took quiz 2

// How can we print out all students that took either quiz 1 or quiz 2

// (but not both)?

Problem 3Say class sizes are limited to 32 students. Therefore, I can use the bits in an int to indicate whether or not students took a particular quiz:

int quiz1 = 0; // indicate that no one took the quiz

quiz1 |= 1 << 7; // indicate that student #7 took the quiz

quiz1 |= 1 << 4; // indicate that student #4 took the quiz

quiz1 &= ~(1 << 7); // Oops! Student #7 didn’t take the quiz. Turn it off.

int quiz2 = 0; // let’s give another quiz!

… // indicate students that took quiz 2

// determine whether a student took either quiz 1 or quiz 2 (but not both)

int oneOrTheOther = quiz1 ^ quiz2;

// How do we print the students out?

Problem 3Say class sizes are limited to 32 students. Therefore, I can use the bits in an int to indicate whether or not students took a particular quiz:

int quiz1 = 0; // indicate that no one took the quiz

quiz1 |= 1 << 7; // indicate that student #7 took the quiz

quiz1 |= 1 << 4; // indicate that student #4 took the quiz

quiz1 &= ~(1 << 7); // Oops! Student #7 didn’t take the quiz. Turn it off.

int quiz2 = 0; // let’s give another quiz!

… // indicate students that took quiz 2

// determine whether a student took either quiz 1 or quiz 2 (but not both)

int oneOrTheOther = quiz1 ^ quiz2;

// print out the students

if ( (oneOrTheOther & 1) != 0 ) System.out.println( “one” );

oneOrTheOther >>>= oneOrTheOther;

if ( (oneOrTheOther & 1) != 0 ) System.out.println( “two” );

…

AND

- Operation:

DEST ← DEST AND SRC;

- Flags Affected:
- The OF and CF flags are cleared.
- the SF, ZF, and PF flags are set according to the result.
- The state of the AF flag is undefined.

NEG (2’s)

- Operation:

IF DEST = 0

THEN CF ← 0

ELSE CF ← 1;

FI;

DEST ← – (DEST)

- Flags Affected:
- The CF flag set to 0 if the source operand is 0; otherwise it is set to 1.
- The OF, SF, ZF, AF, and PF flags are set according to the result.

OR

- Operation:

DEST ← DEST OR SRC;

- Flags Affected:
- The OF and CF flags are cleared.
- The SF, ZF, and PF flags are set according to the result.
- The state of the AF flag is undefined.

XOR

- Operation:

DEST ← DEST XOR SRC;

- Flags Affected:
- The OF and CF flags are cleared.
- The SF, ZF, and PF flags are set according to the result.
- The state of the AF flag is undefined.

Rotate instructions notes

- (Recall CL is the CL register (recall ECX, CX, CH, CL).)

“The count operand is an unsigned integer that can be an immediate or a value in the CL register. The processor restricts the count to a number between 0 and 31 by masking all the bits in the count operand except the 5 least significant bits.”

- from IA-32 Intel Architecture Software Developer’s Manual Volume 2B: Instruction Set Reference, N-Z

Rotate instruction notes

- Flags Affected:
- The CF flag contains the value of the bit shifted into it.
- The OF flag is affected only for singlebit rotates (see reference); it is undefined for multi-bit rotates.
- The SF, ZF, AF, and PF flags are not affected.

Shifts

Notes:

- SAL and SHL are exactly the same.
- SAR preserves the sign.
- SHR always shift in a zero to the sign bit so neg will become pos.

Shifts

Notes:

- SAR preserves the sign.
- SHR always shift in a zero to the sign bit so neg will become pos.

Shift instructions notes

- Flags Affected:
- The CF flag contains the value of the last bit shifted out of the destination operand; it is undefined for SHL and SHR instructions where the count is greater than or equal to the size (in bits) of the destination operand.
- The OF flag is affected only for 1-bit shifts (see reference); otherwise, it is undefined.
- The SF, ZF, and PF flags are set according to the result.
- If the count is 0, the flags are not affected.
- For a non-zero count, the AF flag is undefined.

Some interesting algorithms

- We can zero something by xor’ing it with itself.

Some interesting algorithms

- How does one swap a and b using a temporary variable?
- One can perform memory-less swap using xor

x = x ^ y;

y = x ^ y;

x = x ^ y;

Note: A^B == B^A. So:

x ^= y;

y ^= x;

x ^= y;

Does Java actually have such an operator?

Some interesting algorithms

- How does one swap a and b using a temporary variable?
- One can perform memory-less swap using xor

x = x ^ y;

y = x ^ y;

x = x ^ y;

Note: A^B == B^A. So:

x ^= y;

y ^= x;

x ^= y;

Try: x = 1011

y = 0110

Does Java actually have such an operator?

Operator precedence

- The closer to the top of the table an operator appears, the higher its precedence.
- Operators with higher precedence are evaluated before operators with relatively lower precedence.
- Operators on the same line have equal precedence. When operators of equal precedence appear in the same expression, a rule must govern which is evaluated first. All binary operators except for the assignment operators are evaluated from left to right; assignment operators are evaluated right to left.
- http://download.oracle.com/javase/tutorial/java/nutsandbolts/operators.html

Some interesting algorithms

- We can implement modulo 0xff (or 0xf, 0xff, 0xfff, 0xffff, …) counters via:

inc eax

and eax, 0FFh

Some interesting algorithms

- We can multiply by powers of 2 by shifting to the left.
- More generally, some multiplies can be replaced by shifts and adds. (These may be more efficient.)

i*2 == i<<1

i*3 == (i<<1) + i;

i*10 == (i<<3) + (i<<1)

- We can divide by powers of 2 by shifting to the right.

Timing operations in Java

//use the following below to compare the following (do not worry about overflow):

// i+i and the equivalent in terms of multiplication

// i+i and the equivalent in terms of bit shift

// i/2 and the equivalent in terms of bit shift

// i*i*i and the equivalent in terms of Math.pow()

class MyTime {

public static void main ( String[] args ) {

long start = System.currentTimeMillis();

for (int i=0; i<2000000000; i++) { //repeat 2 billion times

//insert operation(s) to be repeated here

}

long stop = System.currentTimeMillis();

System.out.println( "elapsed time=" + (stop-start)/1000.0 + "s" );

}

}

See also nanoTime().

Multiplication sans multiply

- What if we don’t (our processor doesn’t) have a multiply instruction?
- (Or, how might multiply be implemented in microcode?)

Recall: Multiplication (binary)

It’s interesting to note that binary multiplication is a sequence of shifts and adds of the first term (depending on the bits in the second term.

110100 is missing here because the corresponding bit in the second terms is 0.

Recall: Multiplication (binary)

Algorithm for r = a x b:

r = 0

t = a

loop over n bits:

shift b one bit k to right

if k was set then r += t

shift t one bit to the left

go to loop

110100 is missing here because the corresponding bit in the second terms is 0.

Advanced instructions

- BSWAP - byte swap
- BT - bit test
- XCHG - exchange register/memory with register
- Atomic!
- BTS - bit test and set
- Not atomic!
- LOCK
- makes the next instruction atomic

Download Presentation

Connecting to Server..