Fixed bug in avx2-64bit logic and cleaned up some special case handling

Author: sterrettm2

src/avx2-64bit-qsort.hpp

@@ -70,7 +70,7 @@ struct avx2_vector<int64_t> {
     } // TODO: this should broadcast bits as is?
     static opmask_t knot_opmask(opmask_t x)
     {
-        auto allTrue = _mm256_set1_epi64x(0xFFFF'FFFF);
+        auto allTrue = _mm256_set1_epi64x(0xFFFF'FFFF'FFFF'FFFF);
         return _mm256_xor_si256(x, allTrue);
     }
     static opmask_t get_partial_loadmask(uint64_t num_to_read)
@@ -249,7 +249,7 @@ struct avx2_vector<uint64_t> {
     }
     static opmask_t knot_opmask(opmask_t x)
     {
-        auto allTrue = _mm256_set1_epi64x(0xFFFF'FFFF);
+        auto allTrue = _mm256_set1_epi64x(0xFFFF'FFFF'FFFF'FFFF);
         return _mm256_xor_si256(x, allTrue);
     }
     static opmask_t get_partial_loadmask(uint64_t num_to_read)
@@ -439,7 +439,7 @@ struct avx2_vector<double> {
     }
     static opmask_t knot_opmask(opmask_t x)
     {
-        auto allTrue = _mm256_set1_epi64x(0xFFFF'FFFF);
+        auto allTrue = _mm256_set1_epi64x(0xFFFF'FFFF'FFFF'FFFF);
         return _mm256_xor_si256(x, allTrue);
     }
     static opmask_t get_partial_loadmask(uint64_t num_to_read)

src/xss-common-qsort.h

@@ -502,7 +502,7 @@ qsort_(type_t *arr, arrsize_t left, arrsize_t right, arrsize_t max_iters)
     auto pivot_result = get_pivot_smart<vtype, type_t>(arr, left, right);
     type_t pivot = pivot_result.pivot;
 
-    if (pivot_result.alreadySorted){
+    if (pivot_result.result == pivot_result_t::Sorted){
         return;
     }
 
@@ -513,7 +513,7 @@ qsort_(type_t *arr, arrsize_t left, arrsize_t right, arrsize_t max_iters)
             = partition_avx512_unrolled<vtype, vtype::partition_unroll_factor>(
                     arr, left, right + 1, pivot, &smallest, &biggest);
 
-    if (pivot_result.only2Values){
+    if (pivot_result.result == pivot_result_t::Only2Values){
         return;
     }
 

src/xss-pivot-selection.hpp

@@ -3,20 +3,17 @@
 
 #include "xss-network-qsort.hpp"
 
+enum class pivot_result_t : int { Normal, Sorted, Only2Values };
+
 template <typename type_t>
 struct pivot_results{
-    bool alreadySorted = false;
-    bool only2Values = false;
-    type_t pivot = 0;
 
-    pivot_results(type_t _pivot){
-        pivot = _pivot;
-        alreadySorted = false;
-    }
+    pivot_result_t result = pivot_result_t::Normal;
+    type_t pivot = 0;
 
-    pivot_results(type_t _pivot, bool _alreadySorted){
+    pivot_results(type_t _pivot, pivot_result_t _result = pivot_result_t::Normal){
         pivot = _pivot;
-        alreadySorted = _alreadySorted;
+        result = _result;
     }
 };
 
@@ -197,7 +194,7 @@ X86_SIMD_SORT_INLINE pivot_results<type_t> get_pivot_near_constant(type_t *arr,
     if (index == right + 1){
         // The array is completely constant
         // Setting the second flag to true skips partitioning, as the array is constant and thus sorted
-        return pivot_results<type_t>(commonValue, true);
+        return pivot_results<type_t>(commonValue, pivot_result_t::Sorted);
     }
 
     // Secondly, search for a second value not equal to either of the previous two
@@ -224,9 +221,7 @@ X86_SIMD_SORT_INLINE pivot_results<type_t> get_pivot_near_constant(type_t *arr,
         // We can also skip recursing, as it is guaranteed both partitions are constant after partitioning with the larger value
         // TODO this logic now assumes we use greater than or equal to specifically when partitioning, might be worth noting that somewhere
         type_t pivot = std::max(value1, commonValue, comparison_func<vtype>);
-        auto result = pivot_results<type_t>(pivot, false);
-        result.only2Values = true;
-        return result;
+        return pivot_results<type_t>(pivot, pivot_result_t::Only2Values);
     }
 
     // The array has at least 3 distinct values. Use the middle one as the pivot