4

I noticed a SSE instruction existed for floating point AND which got me wondering. You can do the same thing with scalars in fp/integer union.

The idea struck me that, if you bitwise OR the components of an array of floats, you can determine if any of them are negative quickly by looking at the sign bit of the result.

What other uses exist for bitwise operations on floating point values?

phuclv
  • 37,963
  • 15
  • 156
  • 475
Thomas
  • 6,032
  • 6
  • 41
  • 79
  • The contents of an SSE register can be anything you like. So you can fill them with integers, and perform bitwise operations on them in parallel. For example, image processing might find this useful. – TonyK Mar 22 '15 at 15:18
  • 3
    Absolute value, negate, sign-transfer, mux, probably a bunch of others.. – harold Mar 22 '15 at 15:28
  • 1
    rounding. http://blog.frama-c.com/index.php?post/2013/05/03/nearbyintf2 – Pascal Cuoq Mar 22 '15 at 15:57

2 Answers2

6

A lot. For example when you only need to do bitwise operations on a floating-point only instruction set like AVX, then those become very handy.

Another application: making constants. You can see a lot of examples in table 13.10 and 13.11 in Agner Fog's optimization guide for x86 platforms. Some examples:

pcmpeqd xmm0, xmm0
psrld   xmm0, 30   ; 3 (32-bit)

pcmpeqd xmm0, xmm0 ; -1

pcmpeqw xmm0, xmm0 ; 1.5f
pslld   xmm0, 24
psrld   xmm0, 2

pcmpeqw xmm0, xmm0 ; -2.0f
pslld   xmm0, 30

You can also use that for checking if the floating-point value is a power of 2 or not.

Some other applications like Harold said: Taking absolute value and minus absolute value, copy sign, muxing... I'll demonstrate in a single data for easier understanding

// Absolute:
abs = x & ~(1U << 31);
// Muxing
v = (x & mask) | (y & ~mask); // v = mask ? x : y; with mask = 0 or -1
// Copy sign
y = (y & ~(1U << 31)) | (x & (1U << 31));
phuclv
  • 37,963
  • 15
  • 156
  • 475
3

It can be used to extend the precision of floating point using so-called "double double" arithmetic, particularly when you don't have access to a fused-multiply add (FMA) instruction.

If you have two floats in which the last half of the significand is zero, then their product is exact. So a common trick is to zero out part of the float, subtract that from the original number, and you have two numbers which sum to the original value, but each use only half the significand. By appropriately arranging the order of operations, you can get two floats which sum to the exact product: see, for example, Dekker (1971).

I did some rough speed tests here using Julia: the floating point AND is at least 50% faster than shifting to the integer register, using integer AND, and shifting back.

phuclv
  • 37,963
  • 15
  • 156
  • 475
Simon Byrne
  • 7,694
  • 1
  • 26
  • 50
  • 1
    You have some [crossing domains penalty](https://stackoverflow.com/q/4996384/995714) when [moving data between floating-point and integer execution units](https://stackoverflow.com/q/16294198/995714) – phuclv Jun 30 '18 at 13:25