bitSet and bitClear macros do not work for 64 bit ints (solution provided)

[RobTillaart]

The current macros in Arduino.h for setting and clearing a bit work only for numbers 32 bits and smaller. If one wants to set a bit in a uint64_t the macro fails. The cause is the 1UL in the macros which is essentially 32 bit,

Solution:
The macros below allow setting a bit for 64bit integers too, but use the 64 bit version of 1 only if size of value is 4 bits or less.

#define bitSet64(value, bit) ((value) |= (sizeof(value)<5?1UL:1ULL) <<(bit))
#define bitClear64(value, bit) ((value) &= ~(sizeof(value)<5?1UL:1ULL) <<(bit))
#define bitWrite64(value, bit, bitvalue) (bitvalue ? bitSet64(value, bit) : bitClear64(value, bit))

It is better to test the sizeof(value) that to test bit as bit often can be a variable so its value cannot be checked compile time.

[matthijskooijman]

Is there a reason not to just always use 1ULL? Seems like that should work with 32-bit numbers and smaller as well? Or does that cause compiler warnings?

[RobTillaart]

I did not test the performance but I expected it will create an 64 bit "1" for which the shift might be slower.
I will do some tests.

What I also was thinking about was something like
#define bitSet64(value, bit) ((value) |= (bit>31? 0x100000000 << (bit-32) : (1UL << bit ))
to speed up shifting larger number of bits.

[RobTillaart]

#define bitSet64(value, bit) ((value) |= (sizeof(value)<5?1UL:1ULL) <<(bit))
#define bitSet65(value, bit) ((value) |= (bit>31)? (4294967296ULL << (bit-32)) : (1UL << bit ) )
#define bitSet66(value, bit) ((value) |= (1ULL << bit ))

[No warnings in 1.5.4]

Some numbers in micros() - for 1000 calls in a loop

uint8_t a;
uint16_t b;
uint32_t x;
uint64_t llx;

bitset(a, 1) : 784
bitset(b, 1) : 1064
bitset(x, 1) : 1600
bitset64(x, 1) : 1600
bitset(x, 31) : 1596
bitset64(x, 31) : 1596
bitset(llx, 1) : 2604
bitset(llx, 31) : 2604
bitset64(llx, 31) : 2604

bitset65(llx, 63) : 2612

bitset66(a, 1) : 800
bitset66(b, 1) : 1064
bitset66(x, 1) : 1592
bitset66(llx, 1) : 2656

for i-0..32 (!!!other numbers above are 1000 loops)
bitset66(a, i) : 1128
bitset66(b, i) : 1144
bitset66(x, i) : 1168
bitset66(llx, i) : 1208

for i=0..63
bitset66(a, i) : 1736
bitset66(b, i) : 1752
bitset66(x, i) : 1808
bitset66(llx, i) : 1872

Conclusion so far is that
if BIT is a constant the datatype of VALUE dominates the time.. (the |= assignement) -
( shift is optimized compile time)
if BIT is a variable the datatype of VALUE is far less an issue.
(shift cannot be optimized compile time)

So Mathijs you're right,

#define bitSet(value, bit) ((value) |= (1ULL << bit ))

will support 64 bit without being significant slower for 32 bits or smaller.

That raises the question: can we optimize the shift when BIT is a variable?

Yes we can,

for i=0..63 #define bitSet(value, bit) ((value) |= (1ULL << bit ))
bitset66(a, i) : 1736
bitset66(b, i) : 1752
bitset66(x, i) : 1808
bitset66(llx, i) : 1872 (29 usec on average)

for i=0..63 (never shift more than 16)

#define bitSet70(value, bit) ((value) |= (bit>31)? ((bit>47)?( (1ULL << 63) >> (63-bit)):( (1ULL << 47) >> (47-bit))) : (bit>15) ? (1UL<<31) >>(31-bit) : (1UL << bit ) )

bitset70(a, i) : 1188
bitset70(b, i) : 1208
bitset70(x, i) : 1256
bitset70(llx, i) : 1348 (21usec on average)

on average ~30% faster!

think expanding the macro to max 8 bit shifts will even be faster, but the macro becomes unreadable already.

(enough tested for today ;)

[RobTillaart]

Came across this open issue - has been open for too long so I close it.