Refactor test suite and add tests for partial sort

Author: mosullivan93

tests/meson.build

@@ -11,7 +11,7 @@ endif
 
 if cpp.has_argument('-march=icelake-client')
   libtests += static_library('tests_qsort',
-    files('test_qsort.cpp', ),
+    files('test_qsort.cpp', 'test_qsort_partial.cpp', 'test_qsort_partialrange.cpp', ),
     dependencies: gtest_dep,
     include_directories : [src, utils],
     cpp_args : ['-O3', '-march=icelake-client'],

tests/test-qsort-common.h

@@ -0,0 +1,12 @@
+#ifndef AVX512_TEST_COMMON
+#define AVX512_TEST_COMMON
+
+#include "avx512-16bit-qsort.hpp"
+#include "avx512-32bit-qsort.hpp"
+#include "avx512-64bit-qsort.hpp"
+#include "cpuinfo.h"
+#include "rand_array.h"
+#include <gtest/gtest.h>
+#include <vector>
+
+#endif

tests/test_qsort.cpp renamed to tests/test_qsort.hpp

@@ -3,13 +3,7 @@
  * * SPDX-License-Identifier: BSD-3-Clause
  * *******************************************/
 
-#include "avx512-16bit-qsort.hpp"
-#include "avx512-32bit-qsort.hpp"
-#include "avx512-64bit-qsort.hpp"
-#include "cpuinfo.h"
-#include "rand_array.h"
-#include <gtest/gtest.h>
-#include <vector>
+#include "test-qsort-common.h"
 
 template <typename T>
 class avx512_sort : public ::testing::Test {
@@ -46,13 +40,3 @@ TYPED_TEST_P(avx512_sort, test_arrsizes)
 }
 
 REGISTER_TYPED_TEST_SUITE_P(avx512_sort, test_arrsizes);
-
-using Types = testing::Types<uint16_t,
-                             int16_t,
-                             float,
-                             double,
-                             uint32_t,
-                             int32_t,
-                             uint64_t,
-                             int64_t>;
-INSTANTIATE_TYPED_TEST_SUITE_P(TestPrefix, avx512_sort, Types);

tests/test_qsort_partial.hpp

@@ -0,0 +1,42 @@
+#include "test-qsort-common.h"
+
+template <typename T>
+class avx512_sort_partial : public ::testing::Test {
+};
+TYPED_TEST_SUITE_P(avx512_sort_partial);
+
+TYPED_TEST_P(avx512_sort_partial, test_arrsizes)
+{
+    if (cpu_has_avx512bw()) {
+        if ((sizeof(TypeParam) == 2) && (!cpu_has_avx512_vbmi2())) {
+            GTEST_SKIP() << "Skipping this test, it requires avx512_vbmi2";
+        }
+        std::vector<int64_t> arrsizes;
+        for (int64_t ii = 0; ii < 1024; ++ii) {
+            arrsizes.push_back(ii);
+        }
+        std::vector<TypeParam> arr;
+        std::vector<TypeParam> sortedarr;
+        std::vector<TypeParam> psortedarr;
+        for (size_t ii = 0; ii < arrsizes.size(); ++ii) {
+            /* Random array */
+            arr = get_uniform_rand_array<TypeParam>(arrsizes[ii]);
+            sortedarr = arr;
+            /* Sort with std::sort for comparison */
+            std::sort(sortedarr.begin(), sortedarr.end());
+            for (size_t k = 0; k < arr.size(); ++k) {
+                psortedarr = arr;
+                avx512_qsort_partial<TypeParam>(k+1, psortedarr.data(), psortedarr.size());
+                ASSERT_EQ(sortedarr[k], psortedarr[k]);
+                psortedarr.clear();
+            }
+            arr.clear();
+            sortedarr.clear();
+        }
+    }
+    else {
+        GTEST_SKIP() << "Skipping this test, it requires avx512bw";
+    }
+}
+
+REGISTER_TYPED_TEST_SUITE_P(avx512_sort_partial, test_arrsizes);

tests/test_qsort_partialrange.hpp

@@ -0,0 +1,53 @@
+#include "test-qsort-common.h"
+
+template <typename T>
+class avx512_sort_partialrange : public ::testing::Test {
+};
+TYPED_TEST_SUITE_P(avx512_sort_partialrange);
+
+TYPED_TEST_P(avx512_sort_partialrange, test_arrsizes)
+{
+    int64_t arrsize = 1024;
+    int64_t nranges = 500;
+
+    if (cpu_has_avx512bw()) {
+        if ((sizeof(TypeParam) == 2) && (!cpu_has_avx512_vbmi2())) {
+            GTEST_SKIP() << "Skipping this test, it requires avx512_vbmi2";
+        }
+        std::vector<TypeParam> arr;
+        std::vector<TypeParam> sortedarr;
+        std::vector<TypeParam> prsortedarr;
+        /* Random array */
+        arr = get_uniform_rand_array<TypeParam>(arrsize);
+        sortedarr = arr;
+        /* Sort with std::sort for comparison */
+        std::sort(sortedarr.begin(), sortedarr.end());
+
+        int64_t lb, ub;
+        std::vector<int64_t> inds;
+        for (size_t ii = 0; ii < nranges; ++ii) {
+            prsortedarr = arr;
+
+            /* Pick a random start and end for the range */
+            inds = get_uniform_rand_array<int64_t>(2, arrsize, 1);
+            std::sort(inds.begin(), inds.end());
+            lb = inds[0], ub = inds[1];
+
+            /* Sort the range and verify all the required elements match the presorted set */
+            avx512_qsort_partialrange<TypeParam>(lb, ub, prsortedarr.data(), prsortedarr.size());
+            for (size_t k = (lb-1); k < ub; ++k) {
+                ASSERT_EQ(sortedarr[k], prsortedarr[k]);
+            }
+
+            prsortedarr.clear();
+        }
+
+        arr.clear();
+        sortedarr.clear();
+    }
+    else {
+        GTEST_SKIP() << "Skipping this test, it requires avx512bw";
+    }
+}
+
+REGISTER_TYPED_TEST_SUITE_P(avx512_sort_partialrange, test_arrsizes);

tests/test_sort.cpp

@@ -0,0 +1,15 @@
+#include "test_qsort.hpp"
+#include "test_qsort_partial.hpp"
+#include "test_qsort_partialrange.hpp"
+
+using Types = testing::Types<uint16_t,
+                             int16_t,
+                             float,
+                             double,
+                             uint32_t,
+                             int32_t,
+                             uint64_t,
+                             int64_t>;
+INSTANTIATE_TYPED_TEST_SUITE_P(TestPrefix, avx512_sort, Types);
+INSTANTIATE_TYPED_TEST_SUITE_P(TestPrefix, avx512_sort_partial, Types);
+INSTANTIATE_TYPED_TEST_SUITE_P(TestPrefix, avx512_sort_partialrange, Types);