better benchmark

adler32_benchmark.cc

#include <stdint.h>
#include <stdio.h>
#include <stdint.h>

#include <benchmark/benchmark.h>

#include "zbuild.h"
#include "zutil.h"

extern "C" void cpu_check_features();
/* adler32 */
extern "C" uint32_t adler32_c(uint32_t adler, const unsigned char* buf, size_t len);
#ifdef ARM_NEON_ADLER32
extern "C" uint32_t adler32_neon(uint32_t adler, const unsigned char* buf, size_t len);
#endif
#ifdef X86_SSSE3_ADLER32
extern "C" uint32_t adler32_ssse3(uint32_t adler, const unsigned char* buf, size_t len);
#endif
#ifdef X86_AVX2_ADLER32
extern "C" uint32_t adler32_avx2(uint32_t adler, const unsigned char* buf, size_t len);
#endif
#ifdef X86_AVX512_ADLER32
extern "C" uint32_t adler32_avx512(uint32_t adler, const unsigned char* buf, size_t len);
#endif
#ifdef X86_AVX512VNNI_ADLER32
extern "C" uint32_t adler32_avx512_vnni(uint32_t adler, const unsigned char* buf, size_t len);
#endif

#define MAX_RANDOM_INTS (1024 * 1024)

static uint32_t *random_ints = NULL;

typedef uint32_t (*adler32_func)(uint32_t adler, const unsigned char *buf, size_t len);

static inline void adler32_bench(benchmark::State& state, adler32_func adler32) {
    int32_t j = 0;
    uint32_t hash = 0;

    for (auto _ : state) {
        hash = adler32(hash, (const unsigned char *)random_ints, state.range(0) * sizeof(uint32_t));
    }

    benchmark::DoNotOptimize(hash);
}

static void adler32_c_bench(benchmark::State& state) {
    adler32_bench(state, adler32_c);
}
BENCHMARK(adler32_c_bench)->Range(1, MAX_RANDOM_INTS);
#ifdef ARM_NEON_ADLER32
static void adler32_neon_bench(benchmark::State& state) {
    adler32_bench(state, adler32_neon);
}
BENCHMARK(adler32_neon_bench)->Range(1, MAX_RANDOM_INTS);
#endif
#ifdef X86_SSSE3_ADLER32
static void adler32_ssse3_bench(benchmark::State& state) {
    adler32_bench(state, adler32_ssse3);
}
BENCHMARK(adler32_ssse3_bench)->Range(1, MAX_RANDOM_INTS);
#endif
#ifdef X86_AVX2_ADLER32
static void adler32_avx2_bench(benchmark::State& state) {
    adler32_bench(state, adler32_avx2);
}
BENCHMARK(adler32_avx2_bench)->Range(1, MAX_RANDOM_INTS);
#endif

#ifdef X86_AVX512_ADLER32
static void adler32_avx512_bench(benchmark::State& state) {
    adler32_bench(state, adler32_avx512);
}
BENCHMARK(adler32_avx512_bench)->Range(1, MAX_RANDOM_INTS);
#endif

#ifdef X86_AVX512VNNI_ADLER32
static void adler32_avx512vnni_bench(benchmark::State& state) {
    adler32_bench(state, adler32_avx512_vnni);
}
BENCHMARK(adler32_avx512vnni_bench)->Range(1, MAX_RANDOM_INTS);
#endif

int main(int argc, char** argv) {
    int32_t random_ints_size = MAX_RANDOM_INTS * sizeof(uint32_t);
    random_ints = (uint32_t *)malloc(random_ints_size);
    for (int32_t i = 0; i < MAX_RANDOM_INTS; i++) {
        random_ints[i] = rand();
    }

    cpu_check_features();

    ::benchmark::Initialize(&argc, argv);
    ::benchmark::RunSpecifiedBenchmarks();

    free(random_ints);
}