Is switch case faster if using smaller numbers?

Question

I am wondering if I may optimize something if I change the "huge" numbers by some offsets (or something similar) in the switch-case statements. So I have done a test :

#include <iostream>
#include <iomanip>
#include <chrono>

int main() {

    uint32_t f = 0x12345688;
    std::chrono::time_point<std::chrono::system_clock> start, end;

    int i = -1;

    start = std::chrono::system_clock::now();
    switch (f)
    {
        case 0x1234500 : i = 0; break;
        case 0x1234522 : i = 2; break;
        case 0x1234555 : i = 5; break;
        case 0x1234588 : i = 8; break;
        default : break;
    }
    end = std::chrono::system_clock::now();
    std::chrono::duration<double> elapsed_seconds = end-start;
    std::cout << "elapsed time: " << elapsed_seconds.count() << "s\n";

    int j = -1;
    start = std::chrono::system_clock::now();
    switch (f & 0xf)
    {
        case (0x1234500 & 0xf) : j = 0; break;
        case (0x1234522 & 0xf) : j = 2; break;
        case (0x1234555 & 0xf) : j = 5; break;
        case (0x1234588 & 0xf) : j = 8; break;
        default : break;
    }
    end = std::chrono::system_clock::now();
    elapsed_seconds = end-start;
    std::cout << "elapsed time: " << elapsed_seconds.count() << "s\n";

    return 0;
}

and it seems that always the second switch-case is faster.

Is there a reason why the small numbers in the cases is making the statement faster (the "gaps" between the cases are the same)?

Answer 1

This benchmarking method is nonsense, because the compiler can statically determine the value of i between the two cases. Your actual code will probably end up something like this:

start = std::chrono::system_clock::now();
switch (f)
{
    case 0x1234500 : i = 0; break;
    case 0x1234522 : i = 2; break;
    case 0x1234555 : i = 5; break;
    case 0x1234588 : i = 8; break;
    default : break;
}
end = std::chrono::system_clock::now();
std::chrono::duration<double> elapsed_seconds = end-start;
std::cout << "elapsed time: " << elapsed_seconds.count() << "s\n";

// i = -1;  this line isn't needed, the value isn't used, lets optimize it away

start = std::chrono::system_clock::now();
// Oh great, we already know the value of i
// Because nothing in the previos code could have affected f
// i will get the same value as it did above, and we removed i = -1
// So lets optimize away this pointless code here
end = std::chrono::system_clock::now();
elapsed_seconds = end-start;

You could attempt to declare i as volatile but that may prevent the compiler from other doing optimizations too, so it might not make a valid benchmark test either.

The i = -1; between tests is meaningless, since the compiler can deduct that this value isn't used. So that code will just get removed as well.

The best way might be to read the constant 0x12345688 from a file or user input, so that the compiler can't assume anything about it. You need to do this twice, for both test cases.

Generally: when doing benchmarking like this, always disassemble the code, to verify that your test isn't nonsense.

Answer 2

The most important thing for performance is that the numbers are consecutive. This is because the compiler can use the value to index the memory address which specifies where the switch should jump to handle the case in question. Big gaps makes the indexing impossible, since it would jump very far and the compiler would have to insert huge chunks of empty code to fill unused space.

Small numbers can make it marginally faster - you may only save one instruction because the compiler may subtract and then be able to use indexing still.

All of the above is compiler-dependent. A stupid compiler may not use indexing at all.