使用按位运算符的效率

Question

The requirement is like following:

/* length must be >= 18 */

int calcActualLength(int length) {
    int remainder = (length - 18) % 8;
    if (remainder == 0)
        return length;
    return length + 8 - remainder;
}

using bit-wise operator, I could refactor the 1st line

int remainder = (length - 2) & 7;

Can it be further optimized?

Answer 1

((length+5)&~7)+2

int calcActualLength(int length) {
    int remainder = (length - 18) % 8;
    if (remainder == 0)
        return length;
    return length + 8 - remainder;
}
==>
int HELPER_calcActualLength(int length) {
    int remainder = length % 8;
    if (remainder == 0)
        return length;
    return length + 8 - remainder;
}
int calcActualLength(int length) {
    return 18 + HELPER_calcActualLength(length - 18);
}

And HELPER_calcActualLength() equals to ROUNDUP_8() in the semantics when the argument >= 0

And more simpler ROUNDUP_8() can be:

#define ROUNDUP_8(x) (((x)+7)&~7)

int calcActualLength(int length) {
    return 18 + ROUNDUP_8(length - 18);
}
==>    2 + ROUNDUP_8(length - 18 + 16);
==>    2 + ROUNDUP_8(length - 2);
==>    2 + (((length - 2)+7)&~7)
==>    ((length+5)&~7)+2

Answer 2

Original code produces the following 64-bit assembly when compiling with gcc -O3 :

        movl    %edi, %eax
        leal    -18(%rax), %ecx
        movl    %ecx, %edx
        sarl    $31, %edx
        shrl    $29, %edx
        addl    %edx, %ecx
        andl    $7, %ecx
        subl    %edx, %ecx
        je      .L2
        addl    $8, %eax
        subl    %ecx, %eax
.L2:
        rep

As suggested in the comments to your question, changing the argument to unsigned int allows for greater optimisations and results in the following assembly:

        leal    -18(%rdi), %edx
        movl    %edi, %eax
        andl    $7, %edx
        je      .L3
        leal    8(%rdi), %eax
        subl    %edx, %eax
.L3:
        rep

Rounding up to a multiple of 8 can be performed by adding 7 and masking with ~7 . It works like this: if the last three bits are not all zero, then adding 7 carries into the 4-th bit, otherwise no carry occurs. So your function could be simplified to:

return (((length - 18) + 7) & ~7) + 18;

or simpler:

return ((length - 11) & ~7) + 18;

GCC compiles the last line to simply:

        leal    -11(%rdi), %eax
        andl    $-8, %eax
        addl    $18, %eax

Note that the lea (Load Effective Address) instruciton is often "abused" for its ability to compute simple linear combinations like reg1 + size*reg2 + offset