Update benchmarks to use x86simdsort shared library

Author: Raghuveer Devulapalli

benchmarks/bench-argsort.cpp

@@ -0,0 +1,61 @@
+#include "bench-qsort-common.h"
+
+template <typename T>
+std::vector<int64_t> stdargsort(const std::vector<T> &array)
+{
+    std::vector<int64_t> indices(array.size());
+    std::iota(indices.begin(), indices.end(), 0);
+    std::sort(indices.begin(),
+              indices.end(),
+              [&array](int64_t left, int64_t right) -> bool {
+                  // sort indices according to corresponding array element
+                  return array[left] < array[right];
+              });
+
+    return indices;
+}
+
+template <typename T, class... Args>
+static void scalarargsort(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<T> arr_bkp = arr;
+    std::vector<int64_t> inx;
+    // benchmark
+    for (auto _ : state) {
+        inx = stdargsort(arr);
+    }
+}
+
+template <typename T, class... Args>
+static void simdargsort(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<T> arr_bkp = arr;
+    std::vector<int64_t> inx;
+    // benchmark
+    for (auto _ : state) {
+        inx = x86simdsort::argsort(arr.data(), arrsize);
+    }
+}
+
+#define BENCH_BOTH(type) \
+    BENCH_SORT(simdargsort, type) \
+    BENCH_SORT(scalarargsort, type)
+
+BENCH_BOTH(int64_t)
+BENCH_BOTH(uint64_t)
+BENCH_BOTH(double)
+BENCH_BOTH(int32_t)
+BENCH_BOTH(uint32_t)
+BENCH_BOTH(float)

benchmarks/bench-argsort.hpp

@@ -0,0 +1,62 @@
+#include "bench-qsort-common.h"
+
+template <typename T, class... Args>
+static void simdpartialsort(benchmark::State &state, Args &&...args)
+{
+    // Perform setup here
+    auto args_tuple = std::make_tuple(std::move(args)...);
+    int64_t ARRSIZE = std::get<0>(args_tuple);
+    int64_t k = std::get<1>(args_tuple);
+    std::vector<T> arr;
+    std::vector<T> arr_bkp;
+
+    /* Initialize elements */
+    arr = get_uniform_rand_array<T>(ARRSIZE);
+    arr_bkp = arr;
+
+    /* call simdpartialsort */
+    for (auto _ : state) {
+        x86simdsort::partial_qsort<T>(arr.data(), k, ARRSIZE);
+
+        state.PauseTiming();
+        arr = arr_bkp;
+        state.ResumeTiming();
+    }
+}
+
+template <typename T, class... Args>
+static void scalarpartialsort(benchmark::State &state, Args &&...args)
+{
+    // Perform setup here
+    auto args_tuple = std::make_tuple(std::move(args)...);
+    int64_t ARRSIZE = std::get<0>(args_tuple);
+    int64_t k = std::get<1>(args_tuple);
+    std::vector<T> arr;
+    std::vector<T> arr_bkp;
+
+    /* Initialize elements */
+    arr = get_uniform_rand_array<T>(ARRSIZE);
+    arr_bkp = arr;
+
+    /* call std::partial_sort */
+    for (auto _ : state) {
+        std::partial_sort(arr.begin(), arr.begin() + k, arr.end());
+
+        state.PauseTiming();
+        arr = arr_bkp;
+        state.ResumeTiming();
+    }
+}
+
+#define BENCH_BOTH_PARTIAL(type) \
+    BENCH_PARTIAL(simdpartialsort, type) \
+    BENCH_PARTIAL(scalarpartialsort, type)
+
+BENCH_BOTH_PARTIAL(uint64_t)
+BENCH_BOTH_PARTIAL(int64_t)
+BENCH_BOTH_PARTIAL(uint32_t)
+BENCH_BOTH_PARTIAL(int32_t)
+BENCH_BOTH_PARTIAL(uint16_t)
+BENCH_BOTH_PARTIAL(int16_t)
+BENCH_BOTH_PARTIAL(float)
+BENCH_BOTH_PARTIAL(double)

benchmarks/bench-partial-qsort.cpp

@@ -0,0 +1,62 @@
+#include "bench-qsort-common.h"
+
+template <typename T, class... Args>
+static void simdqselect(benchmark::State &state, Args &&...args)
+{
+    // Perform setup here
+    auto args_tuple = std::make_tuple(std::move(args)...);
+    int64_t ARRSIZE = std::get<0>(args_tuple);
+    int64_t k = std::get<1>(args_tuple);
+    std::vector<T> arr;
+    std::vector<T> arr_bkp;
+
+    /* Initialize elements */
+    arr = get_uniform_rand_array<T>(ARRSIZE);
+    arr_bkp = arr;
+
+    /* call avx512 quickselect */
+    for (auto _ : state) {
+        x86simdsort::qselect<T>(arr.data(), k, ARRSIZE);
+
+        state.PauseTiming();
+        arr = arr_bkp;
+        state.ResumeTiming();
+    }
+}
+
+template <typename T, class... Args>
+static void scalarqselect(benchmark::State &state, Args &&...args)
+{
+    // Perform setup here
+    auto args_tuple = std::make_tuple(std::move(args)...);
+    int64_t ARRSIZE = std::get<0>(args_tuple);
+    int64_t k = std::get<1>(args_tuple);
+    std::vector<T> arr;
+    std::vector<T> arr_bkp;
+
+    /* Initialize elements */
+    arr = get_uniform_rand_array<T>(ARRSIZE);
+    arr_bkp = arr;
+
+    /* call std::nth_element */
+    for (auto _ : state) {
+        std::nth_element(arr.begin(), arr.begin() + k, arr.end());
+
+        state.PauseTiming();
+        arr = arr_bkp;
+        state.ResumeTiming();
+    }
+}
+
+#define BENCH_BOTH_QSELECT(type) \
+    BENCH_PARTIAL(simdqselect, type) \
+    BENCH_PARTIAL(scalarqselect, type)
+
+BENCH_BOTH_QSELECT(uint64_t)
+BENCH_BOTH_QSELECT(int64_t)
+BENCH_BOTH_QSELECT(uint32_t)
+BENCH_BOTH_QSELECT(int32_t)
+BENCH_BOTH_QSELECT(uint16_t)
+BENCH_BOTH_QSELECT(int16_t)
+BENCH_BOTH_QSELECT(float)
+BENCH_BOTH_QSELECT(double)