Add ipp index sort to benchmarks

Author: Raghuveer Devulapalli

benchmarks/bench-argsort.hpp

@@ -45,8 +45,30 @@ static void simdargsort(benchmark::State &state, Args &&...args)
     }
 }
 
+template <typename T, class... Args>
+static void simd_ordern_argsort(benchmark::State &state, Args &&...args)
+{
+    // get args
+    auto args_tuple = std::make_tuple(std::move(args)...);
+    size_t arrsize = std::get<0>(args_tuple);
+    std::string arrtype = std::get<1>(args_tuple);
+    // set up array
+    std::vector<T> arr = get_array<T>(arrtype, arrsize);
+    std::vector<int32_t> arg(arrsize);
+    std::iota(arg.begin(), arg.end(), 0);
+    // benchmark
+    for (auto _ : state) {
+        std::vector<T> arr_bkp = arr;
+        x86simdsort::keyvalue_qsort(arr_bkp.data(), arg.data(), arrsize);
+        state.PauseTiming();
+        std::iota(arg.begin(), arg.end(), 0);
+        state.ResumeTiming();
+    }
+}
+
 #define BENCH_BOTH(type) \
     BENCH_SORT(simdargsort, type) \
+    BENCH_SORT(simd_ordern_argsort, type) \
     BENCH_SORT(scalarargsort, type)
 
 BENCH_BOTH(int64_t)

benchmarks/bench-ipp.cpp

@@ -35,9 +35,51 @@ static void ippsort(benchmark::State &state, Args &&...args)
     }
 }
 
-BENCH_SORT(ippsort, uint64_t)
-BENCH_SORT(ippsort, int64_t)
-BENCH_SORT(ippsort, uint32_t)
-BENCH_SORT(ippsort, int32_t)
+template <typename T, class... Args>
+static void ippargsort(benchmark::State &state, Args &&...args)
+{
+    auto args_tuple = std::make_tuple(std::move(args)...);
+    size_t arrsize = std::get<0>(args_tuple);
+    /* IPP set up */
+    int bufsize = 10;
+    if constexpr (std::is_same_v<T, float>) {
+        ippsSortRadixIndexGetBufferSize(arrsize, ipp32f, &bufsize);
+    }
+    else if constexpr (std::is_same_v<T, double>) {
+        ippsSortRadixIndexGetBufferSize(arrsize, ipp64f, &bufsize);
+    }
+    else if constexpr (std::is_same_v<T, int32_t>) {
+        ippsSortRadixIndexGetBufferSize(arrsize, ipp32s, &bufsize);
+    }
+    unsigned char *temp = new unsigned char[bufsize];
+
+    // set up array
+    std::string arrtype = std::get<1>(args_tuple);
+    std::vector<T> arr = get_array<T>(arrtype, arrsize);
+    std::vector<T> arr_bkp = arr;
+    std::vector<int32_t> arg(arrsize);
+    std::iota(arg.begin(), arg.end(), 0);
+
+    // benchmark
+    for (auto _ : state) {
+        if constexpr (std::is_same_v<T, float>) {
+            ippsSortRadixIndexAscend_32f(arr.data(), 4, arg.data(), arrsize, temp);
+        }
+        else if constexpr (std::is_same_v<T, double>) {
+            ippsSortRadixIndexAscend_64f(arr.data(), 8, arg.data(), arrsize, temp);
+        }
+        else if constexpr (std::is_same_v<T, int32_t>) {
+            ippsSortRadixIndexAscend_32s(arr.data(), 4, arg.data(), arrsize, temp);
+        }
+        state.PauseTiming();
+        arr = arr_bkp;
+        std::iota(arg.begin(), arg.end(), 0);
+        state.ResumeTiming();
+    }
+}
+
 BENCH_SORT(ippsort, double)
 BENCH_SORT(ippsort, float)
+BENCH_SORT(ippargsort, double)
+BENCH_SORT(ippargsort, float)
+BENCH_SORT(ippargsort, int32_t)

benchmarks/bench.h

@@ -27,6 +27,8 @@
             func, type, random_1m, 1000000, std::string("random")); \
     MY_BENCHMARK_CAPTURE( \
             func, type, random_10m, 10000000, std::string("random")); \
+    MY_BENCHMARK_CAPTURE( \
+            func, type, random_100m, 100000000, std::string("random")); \
     MY_BENCHMARK_CAPTURE( \
             func, type, smallrange_128, 128, std::string("smallrange")); \
     MY_BENCHMARK_CAPTURE( \

run-bench.py

@@ -26,6 +26,9 @@
     if "ippsort" in args.benchcompare:
         baseline = "ippsort.*" + filterb
         contender = "simdsort.*" + filterb
+    elif "ippargsort" in args.benchcompare:
+        baseline = "ippargsort.*" + filterb
+        contender = "simd_ordern_argsort.*" + filterb
     elif "vqsort" in args.benchcompare:
         baseline = "vqsort.*" + filterb
         contender = "simdsort.*" + filterb

scripts/bench-compare.sh

@@ -11,7 +11,7 @@ if [ ! -d .bench/google-benchmark ]; then
 fi
 compare=$(realpath .bench/google-benchmark/tools/compare.py)
 
-meson setup -Dbuild_benchmarks=true --warnlevel 0 --buildtype release builddir-${branch}
+meson setup -Dbuild_benchmarks=true -Dbuild_ippbench=true --warnlevel 0 --buildtype release builddir-${branch}
 cd builddir-${branch}
 ninja
 $compare filters ./benchexe $1 $2 --benchmark_repetitions=$3