Question

I need to take an 8 bit number on a 64 bit cpu and shift it to the right 8 times. Each time I shift the number I need to shift the same 8 bit number in behind it so that I end up with the same 8 bit number repeating 8 times. This would end up being shift, add 8, shift add 8… etc. which ends up being 40+ cycles (correct me if I’m wrong).

Is there a way to do this operation (of shift and copy) in 1 cycle so that I end up with the same value in the end?

long _value = 0;
byte _number = 7;
for (int i = 0; i < 8; i++) {
    _value = (_value << 8) + _number;
}

EDIT: I’m trying to compare a stream of chars to detect keywords. I can’t use string.contains because the string value may be across the boundary of the buffer. Also, the application has to run on embedded ARM cpus as well as desktop and server CPUs. Memory usage and cpu cycles are very important.

Answer 1

Another idea would be to precompute all for all values of byte a lookup table.

var lu = new long[256];
// init
var n = 7;
var v = lu[n];

Update

Some benchmark results (in ms per 100000000 iterations):

• Loop: 272
• Unrolled: 207
• Unsafe: 351
• Lookup: 250
• HenkH: 216

The unrolled version is:

long _value = 0;
byte _number = 7;

_value = (_value + _number) << 8;
_value = (_value + _number) << 8;
_value = (_value + _number) << 8;
_value = (_value + _number) << 8;
_value = (_value + _number) << 8;
_value = (_value + _number) << 8;
_value = (_value + _number) << 8;
_value = (_value + _number) << 8;

The unsafe version is:

long _value = 0;
byte _number = 7;

byte* p = (byte*)&_value;

*p++ = _number;
*p++ = _number;
*p++ = _number;
*p++ = _number;
*p++ = _number;
*p++ = _number;
*p++ = _number;
*p++ = _number;

Sadly not performing 🙁

The lookup is just a read to an array.

All compiled for x64/release.