slidehash_benchmark.cc

#include <stdint.h>
#include <stdint.h>
#include <limits.h>

#include "zbuild.h"

extern "C" {
#include "deflate.h"
}

#include <benchmark/benchmark.h>

#define MAX_RANDOM_INTS 32768
static uint16_t *l0 = NULL;
static uint16_t *l1 = NULL;
static deflate_state *s_g = NULL;


#if 1
/* slide_hash */
extern "C" void slide_hash_c(deflate_state *s);
#endif
#ifdef X86_SSSE3
extern "C" void slide_hash_sse2(deflate_state *s);
#endif
#ifdef X86_AVX2
extern "C" void slide_hash_avx2(deflate_state *s);
#endif
#ifdef X86_AVX512_SLIDEHASH
extern "C" void slide_hash_avx512(deflate_state *s);
#endif

static void slide_hash_c_bench(benchmark::State& state) {

    s_g->w_size = state.range(0);

    for (auto _ : state) {
        slide_hash_c(s_g);
        benchmark::DoNotOptimize(s_g);
    }
}
BENCHMARK(slide_hash_c_bench)->RangeMultiplier(2)->Range(1024, MAX_RANDOM_INTS);
#ifdef X86_SSSE3_ADLER32
static void slide_hash_sse2_bench(benchmark::State& state) {
    s_g->w_size = state.range(0);

    for (auto _ : state) {
        slide_hash_sse2(s_g);
        benchmark::DoNotOptimize(s_g);
    }
}
BENCHMARK(slide_hash_sse2_bench)->RangeMultiplier(2)->Range(1024, MAX_RANDOM_INTS);
#endif
#ifdef X86_AVX2_ADLER32
static void slide_hash_avx2_bench(benchmark::State& state) {
    s_g->w_size = state.range(0);

    for (auto _ : state) {
        slide_hash_avx2(s_g);
        benchmark::DoNotOptimize(s_g);
    }
}
BENCHMARK(slide_hash_avx2_bench)->RangeMultiplier(2)->Range(1024, MAX_RANDOM_INTS);
#endif

int main(int argc, char** argv)
{
    int32_t random_ints_size = MAX_RANDOM_INTS * sizeof(uint16_t);
    l0 = (uint16_t *)malloc(HASH_SIZE * sizeof(uint16_t));
    l1 = (uint16_t *)malloc(random_ints_size);

    for (int32_t i = 0; i < MAX_RANDOM_INTS; i++) {
        l1[i] = rand();
    }

    for (int32_t i = 0; i < HASH_SIZE; i++) {
        l0[i] = rand();
    }

    deflate_state *s = (deflate_state*)malloc(sizeof(deflate_state));
    s->head = l0;
    s->prev = l1;
    s_g = s;

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