Adding 2 fastest sorts to benchmark

Author: saatviks

CMakeLists.txt

@@ -2,16 +2,18 @@ cmake_minimum_required(VERSION 3.5)
 project(UltraSort)
 
 set( CMAKE_EXPORT_COMPILE_COMMANDS ON )
-set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD 14)
 
 add_subdirectory(third_party/googletest)
 
 include_directories(${CMAKE_SOURCE_DIR}/src/include)
 include_directories(${CMAKE_SOURCE_DIR}/test/include)
 include_directories(third_party/googletest/googletest/include)
 include_directories(third_party/googletest/googlemock/include)
+include_directories(third_party/ips4o)
+include_directories(third_party/pdqsort)
 
-set(CMAKE_CXX_FLAGS "-g -O0 -Wall -march=native -DDEBUG=0")
+set(CMAKE_CXX_FLAGS "-g -O3 -Wall -march=native -DDEBUG=0")
 
 file(GLOB_RECURSE SOURCE_FILES
         "src/*.cpp" "test/*.cpp")

test/avx256/simd_sort_test.cpp

@@ -4,19 +4,23 @@
 #include "avx256/simd_sort.h"
 #include <algorithm>
 #include <iterator>
+#include "ips4o.hpp"
+#include "pdqsort.h"
+
+// TODO: Separate tests from benchmarks
 
 TEST(SIMDSortTests, SIMDSort32BitIntegerTest) {
   int N = 65536;
-  int lo = -1000;
-  int hi = 1000;
+  int lo = -10000;
+  int hi = 10000;
   int *rand_arr;
   int *soln_arr;
   double start, end;
 
   // Initialization
   TestUtil::RandGen(rand_arr, N, lo, hi);
 
-  // C++11 std::stable_sort
+  // C++ std::stable_sort
   aligned_init<int>(soln_arr, N);
   std::copy(rand_arr, rand_arr + N, soln_arr);
   start = currentSeconds();
@@ -25,7 +29,7 @@ TEST(SIMDSortTests, SIMDSort32BitIntegerTest) {
   printf("[std::stable_sort] %d elements: %.8f seconds\n", N, end - start);
   delete soln_arr;
 
-  // C++11 std::sort
+  // C++ std::sort
   aligned_init<int>(soln_arr, N);
   std::copy(rand_arr, rand_arr + N, soln_arr);
   start = currentSeconds();
@@ -34,13 +38,33 @@ TEST(SIMDSortTests, SIMDSort32BitIntegerTest) {
   printf("[std::sort] %d elements: %.8f seconds\n", N, end - start);
   delete soln_arr;
 
+  // C++ ips4o::sort
+  aligned_init<int>(soln_arr, N);
+  std::copy(rand_arr, rand_arr + N, soln_arr);
+  start = currentSeconds();
+  ips4o::sort(soln_arr, soln_arr + N);
+  end = currentSeconds();
+  printf("[ips4o::sort] %d elements: %.8f seconds\n", N, end - start);
+  delete soln_arr;
+
+  // C++ pqd::sort
+  aligned_init<int>(soln_arr, N);
+  std::copy(rand_arr, rand_arr + N, soln_arr);
+  start = currentSeconds();
+  pdqsort(soln_arr, soln_arr + N);
+  end = currentSeconds();
+  printf("[pdqsort] %d elements: %.8f seconds\n", N, end - start);
+  delete soln_arr;
+
+  // AVX256 Sort
   aligned_init<int>(soln_arr, N);
   std::copy(rand_arr, rand_arr + N, soln_arr);
   std::vector<int> check_arr(rand_arr, rand_arr + N);
   start = currentSeconds();
   SIMDSorter::SIMDSort32(N, soln_arr);
   end = currentSeconds();
   std::sort(check_arr.begin(), check_arr.end());
+  // First perform a correctness check
   for(int i = 0; i < N; i++) {
     EXPECT_EQ(check_arr[i], soln_arr[i]);
   }
@@ -60,7 +84,7 @@ TEST(SIMDSortTests, SIMDSort64BitIntegerTest) {
   // Initialization
   TestUtil::RandGen<int64_t>(rand_arr, N, lo, hi);
 
-  // C++11 std::stable_sort
+  // C++ std::stable_sort
   aligned_init<int64_t>(soln_arr, N);
   std::copy(rand_arr, rand_arr + N, soln_arr);
   start = currentSeconds();
@@ -69,7 +93,7 @@ TEST(SIMDSortTests, SIMDSort64BitIntegerTest) {
   printf("[std::stable_sort] %d elements: %.8f seconds\n", N, end - start);
   delete soln_arr;
 
-  // C++11 std::sort
+  // C++ std::sort
   aligned_init<int64_t>(soln_arr, N);
   std::copy(rand_arr, rand_arr + N, soln_arr);
   start = currentSeconds();
@@ -78,6 +102,25 @@ TEST(SIMDSortTests, SIMDSort64BitIntegerTest) {
   printf("[std::sort] %d elements: %.8f seconds\n", N, end - start);
   delete soln_arr;
 
+  // C++ ips4o::sort
+  aligned_init<int64_t>(soln_arr, N);
+  std::copy(rand_arr, rand_arr + N, soln_arr);
+  start = currentSeconds();
+  ips4o::sort(soln_arr, soln_arr + N);
+  end = currentSeconds();
+  printf("[ips4o::sort] %d elements: %.8f seconds\n", N, end - start);
+  delete soln_arr;
+
+  // C++ pqd::sort
+  aligned_init<int64_t>(soln_arr, N);
+  std::copy(rand_arr, rand_arr + N, soln_arr);
+  start = currentSeconds();
+  pdqsort(soln_arr, soln_arr + N);
+  end = currentSeconds();
+  printf("[pdqsort] %d elements: %.8f seconds\n", N, end - start);
+  delete soln_arr;
+
+  // AVX256 sort
   aligned_init<int64_t>(soln_arr, N);
   std::copy(rand_arr, rand_arr + N, soln_arr);
   std::vector<int64_t> check_arr(rand_arr, rand_arr + N);
@@ -94,17 +137,17 @@ TEST(SIMDSortTests, SIMDSort64BitIntegerTest) {
 }
 
 TEST(SIMDSortTests, SIMDSort32BitKeyValueIntegerTest) {
-  int N = 65536;
-  int lo = -10000;
-  int hi = 10000;
+  int N = 64;
+  int lo = -10;
+  int hi = 10;
   std::pair<int,int> *rand_arr;
   std::pair<int,int> *soln_arr;
   double start, end;
 
   // Initialization
   TestUtil::RandPairGen(rand_arr, N, lo, hi);
 
-  // C++11 std::stable_sort
+  // C++ std::stable_sort
   aligned_init<std::pair<int,int>>(soln_arr, N);
   std::copy(rand_arr, rand_arr + N, soln_arr);
   start = currentSeconds();
@@ -115,7 +158,7 @@ TEST(SIMDSortTests, SIMDSort32BitKeyValueIntegerTest) {
   printf("[std::stable_sort] %d elements: %.8f seconds\n", N, end - start);
   delete soln_arr;
 
-  // C++11 std::sort
+  // C++ std::sort
   aligned_init<std::pair<int,int>>(soln_arr, N);
   std::copy(rand_arr, rand_arr + N, soln_arr);
   start = currentSeconds();
@@ -126,6 +169,8 @@ TEST(SIMDSortTests, SIMDSort32BitKeyValueIntegerTest) {
   printf("[std::sort] %d elements: %.8f seconds\n", N, end - start);
   delete soln_arr;
 
+  // TODO: Add ips4o and pdqsort benchmarks
+  // AVX256 sort
   aligned_init<std::pair<int,int>>(soln_arr, N);
   std::copy(rand_arr, rand_arr + N, soln_arr);
   std::vector<std::pair<int,int>> check_arr(rand_arr, rand_arr + N);

third_party/ips4o/LICENSE

@@ -0,0 +1,27 @@
+BSD 2-Clause License
+
+Copyright © 2017, Michael Axtmann <[email protected]>
+Copyright © 2017, Daniel Ferizovic <[email protected]>
+Copyright © 2017, Sascha Witt <[email protected]>
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

third_party/ips4o/README.md

@@ -0,0 +1,35 @@
+# In-place Parallel Super Scalar Samplesort (IPS⁴o)
+
+This is the implementation of the algorithm presented in the [eponymous paper](https://arxiv.org/abs/1705.02257),
+which contains an in-depth description of its inner workings, as well as an extensive experimental performance evaluation.
+Here's the abstract:
+
+> We present a sorting algorithm that works in-place, executes in parallel, is
+> cache-efficient, avoids branch-mispredictions, and performs work O(n log n) for
+> arbitrary inputs with high probability. The main algorithmic contributions are
+> new ways to make distribution-based algorithms in-place: On the practical side,
+> by using coarse-grained block-based permutations, and on the theoretical side,
+> we show how to eliminate the recursion stack. Extensive experiments show that
+> our algorithm IPS⁴o scales well on a variety of multi-core machines. We
+> outperform our closest in-place competitor by a factor of up to 3. Even as
+> a sequential algorithm, we are up to 1.5 times faster than the closest
+> sequential competitor, BlockQuicksort.
+
+## Usage
+
+```C++
+#include "ips4o.hpp"
+
+// sort sequentially
+ips4o::sort(begin, end[, comparator])
+
+// sort in parallel (uses OpenMP if available, std::thread otherwise)
+ips4o::parallel::sort(begin, end[, comparator])
+```
+
+Make sure to compile with C++14 support. Currently, the code does not compile on Windows.
+
+For the parallel algorithm, you need to enable either OpenMP (`-fopenmp`) or C++ threads (e.g., `-pthread`).
+You also need a CPU that supports 16-byte compare-and-exchange instructions.
+If you get undefined references to `__atomic_fetch_add_16`, either set your CPU correctly (e.g., `-march=native`),
+  enable the instructions explicitly (`-mcx16`), or try linking against GCC's libatomic (`-latomic`).

third_party/ips4o/ips4o.hpp

@@ -0,0 +1,38 @@
+/******************************************************************************
+ * ips4o.hpp
+ *
+ * In-place Parallel Super Scalar Samplesort (IPS⁴o)
+ *
+ ******************************************************************************
+ * BSD 2-Clause License
+ *
+ * Copyright © 2017, Michael Axtmann <[email protected]>
+ * Copyright © 2017, Daniel Ferizovic <[email protected]>
+ * Copyright © 2017, Sascha Witt <[email protected]>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *****************************************************************************/
+
+#pragma once
+
+#include "ips4o/ips4o.hpp"

third_party/ips4o/ips4o/base_case.hpp

@@ -0,0 +1,82 @@
+/******************************************************************************
+ * ips4o/base_case.hpp
+ *
+ * In-place Parallel Super Scalar Samplesort (IPS⁴o)
+ *
+ ******************************************************************************
+ * BSD 2-Clause License
+ *
+ * Copyright © 2017, Michael Axtmann <[email protected]>
+ * Copyright © 2017, Daniel Ferizovic <[email protected]>
+ * Copyright © 2017, Sascha Witt <[email protected]>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *****************************************************************************/
+
+#pragma once
+
+#include <algorithm>
+#include <cstddef>
+#include <utility>
+
+#include "ips4o_fwd.hpp"
+#include "utils.hpp"
+
+namespace ips4o {
+namespace detail {
+
+/**
+ * Insertion sort.
+ */
+template <class It, class Comp>
+void insertionSort(const It begin, const It end, Comp comp) {
+    IPS4O_ASSUME_NOT(begin >= end);
+
+    for (It it = begin + 1; it < end; ++it) {
+        auto val = std::move(*it);
+        if (comp(val, *begin)) {
+            std::move_backward(begin, it, it + 1);
+            *begin = std::move(val);
+        } else {
+            auto cur = it;
+            for (auto next = it - 1; comp(val, *next); --next) {
+                *cur = std::move(*next);
+                cur = next;
+            }
+            *cur = std::move(val);
+        }
+    }
+}
+
+/**
+ * Wrapper for base case sorter, for easier swapping.
+ */
+template <class It, class Comp>
+inline void baseCaseSort(It begin, It end, Comp&& comp) {
+    if (begin == end) return;
+    detail::insertionSort(std::move(begin), std::move(end), std::forward<Comp>(comp));
+}
+
+
+}  // namespace detail
+}  // namespace ips4o