Div vs And

benchmark.cpp

#include <random>
#include <vector>

std::vector<int> generateRandomVector(int size)
{
    std::vector<int> vec(size);
    std::generate(begin(vec), end(vec), rand);
    return vec;    
}

static void DivByConstant(benchmark::State& state) {
  int value = 1301081;
  int divisor = 1024;
  for (auto _ : state) {
    int remainder = value % divisor;
    benchmark::DoNotOptimize(remainder);
  }
}

BENCHMARK(DivByConstant);

static void DivByUnsignedConstant(benchmark::State& state) {
  int value = 1301081;
  unsigned int divisor = 1024;
  for (auto _ : state) {
    int remainder = value % divisor;
    benchmark::DoNotOptimize(remainder);
  }
}

BENCHMARK(DivByUnsignedConstant);

static void BitwiseAnd(benchmark::State& state) {
  int value = 1301081;
  unsigned int divisor = 0x3FF;
  for (auto _ : state) {
    int remainder = value & divisor;
    benchmark::DoNotOptimize(remainder);
  }
}

BENCHMARK(BitwiseAnd);

static const auto values = generateRandomVector(1'000'000);
static const auto divisors = generateRandomVector(1'000'000);

static void BitwiseAndRandom(benchmark::State& state) {
  int divisor = 0x3FF;
  for (auto _ : state) {    
    auto value = values[state.iterations()];
    int remainder = value & divisor;
    benchmark::DoNotOptimize(remainder);
  }
}

BENCHMARK(BitwiseAndRandom);

static void DivByConstantRandom(benchmark::State& state) {
  int divisor = 1024;
  for (auto _ : state) {    
    auto value = values[state.iterations()];
    int remainder = value % divisor;
    benchmark::DoNotOptimize(remainder);
  }
}
BENCHMARK(DivByConstantRandom);

static void BitwiseAndRandomDivisor(benchmark::State& state) {
  for (auto _ : state) {          
    auto value = values[state.iterations()];
    auto divisor = divisors[state.iterations()];
    int remainder = value & divisor;
    benchmark::DoNotOptimize(remainder);
  }
}
BENCHMARK(BitwiseAndRandomDivisor);

static void DivByConstantRandomDivisor(benchmark::State& state) {
  for (auto _ : state) {    
    auto value = values[state.iterations()];
    auto divisor = divisors[state.iterations()];
    int remainder = value % divisor;
    benchmark::DoNotOptimize(remainder);
  }
}
BENCHMARK(DivByConstantRandomDivisor);