Fixed problems on 32-bit systems

Author: sterrettm2

src/avx2-32bit-half.hpp

@@ -100,6 +100,13 @@ struct avx2_half_vector<int32_t> {
         return _mm256_mask_i64gather_epi32(
                 src, (const int *)base, index, mask, scale);
     }
+    template <int scale>
+    static reg_t
+    mask_i64gather(reg_t src, opmask_t mask, __m128i index, void const *base)
+    {
+        return _mm_mask_i32gather_epi32(
+                src, (const int *)base, index, mask, scale);
+    }
     static reg_t i64gather(type_t *arr, arrsize_t *ind)
     {
         return set(arr[ind[3]], arr[ind[2]], arr[ind[1]], arr[ind[0]]);
@@ -237,6 +244,13 @@ struct avx2_half_vector<uint32_t> {
         return _mm256_mask_i64gather_epi32(
                 src, (const int *)base, index, mask, scale);
     }
+    template <int scale>
+    static reg_t
+    mask_i64gather(reg_t src, opmask_t mask, __m128i index, void const *base)
+    {
+        return _mm_mask_i32gather_epi32(
+                src, (const int *)base, index, mask, scale);
+    }
     static reg_t i64gather(type_t *arr, arrsize_t *ind)
     {
         return set(arr[ind[3]], arr[ind[2]], arr[ind[1]], arr[ind[0]]);
@@ -406,6 +420,13 @@ struct avx2_half_vector<float> {
         return _mm256_mask_i64gather_ps(
                 src, (const float *)base, index, _mm_castsi128_ps(mask), scale);
     }
+    template <int scale>
+    static reg_t
+    mask_i64gather(reg_t src, opmask_t mask, __m128i index, void const *base)
+    {
+        return _mm_mask_i32gather_ps(
+                src, (const float *)base, index, _mm_castsi128_ps(mask), scale);
+    }
     static reg_t i64gather(type_t *arr, arrsize_t *ind)
     {
         return set(arr[ind[3]], arr[ind[2]], arr[ind[1]], arr[ind[0]]);

src/avx2-64bit-qsort.hpp

@@ -106,6 +106,13 @@ struct avx2_vector<int64_t> {
         return _mm256_mask_i64gather_epi64(
                 src, (const long long int *)base, index, mask, scale);
     }
+    template <int scale>
+    static reg_t
+    mask_i64gather(reg_t src, opmask_t mask, __m128i index, void const *base)
+    {
+        return _mm256_mask_i32gather_epi64(
+                src, (const long long int *)base, index, mask, scale);
+    }
     static reg_t i64gather(type_t *arr, arrsize_t *ind)
     {
         return set(arr[ind[3]], arr[ind[2]], arr[ind[1]], arr[ind[0]]);
@@ -252,6 +259,13 @@ struct avx2_vector<uint64_t> {
         return _mm256_mask_i64gather_epi64(
                 src, (const long long int *)base, index, mask, scale);
     }
+    template <int scale>
+    static reg_t
+    mask_i64gather(reg_t src, opmask_t mask, __m128i index, void const *base)
+    {
+        return _mm256_mask_i32gather_epi64(
+                src, (const long long int *)base, index, mask, scale);
+    }
     static reg_t i64gather(type_t *arr, arrsize_t *ind)
     {
         return set(arr[ind[3]], arr[ind[2]], arr[ind[1]], arr[ind[0]]);
@@ -444,6 +458,17 @@ struct avx2_vector<double> {
                                         scale);
         ;
     }
+    template <int scale>
+    static reg_t
+    mask_i64gather(reg_t src, opmask_t mask, __m128i index, void const *base)
+    {
+        return _mm256_mask_i32gather_pd(src,
+                                        (const type_t *)base,
+                                        index,
+                                        _mm256_castsi256_pd(mask),
+                                        scale);
+        ;
+    }
     static reg_t i64gather(type_t *arr, arrsize_t *ind)
     {
         return set(arr[ind[3]], arr[ind[2]], arr[ind[1]], arr[ind[0]]);

src/xss-network-keyvaluesort.hpp

@@ -22,11 +22,24 @@ struct index_64bit_vector_type<4> {
 template <typename keyType, typename valueType>
 typename valueType::opmask_t extend_mask(typename keyType::opmask_t mask)
 {
+    using inT = typename keyType::opmask_t;
+    using outT = typename valueType::opmask_t;
+    
     if constexpr (keyType::vec_type == simd_type::AVX512) { return mask; }
     else if constexpr (keyType::vec_type == simd_type::AVX2) {
-        if constexpr (sizeof(mask) == 32) { return mask; }
-        else {
+        if constexpr (sizeof(inT) == sizeof(outT)) { return mask; }
+        else if constexpr (sizeof(inT) == 32 && sizeof(outT) == 16){
+            // We need to convert a mask made of 64 bit integers to 32 bit integers
+            // This does this by taking advantage of the fact that the only bit that matters
+            // is the very topmost bit, which becomes the sign bit when cast to floating point
+            
+            // TODO try and figure out if there is a better way to do this
+            return _mm_castps_si128(_mm256_cvtpd_ps(_mm256_castsi256_pd(mask)));
+        }
+        else if constexpr (sizeof(inT) == 16 && sizeof(outT) == 32){
             return _mm256_cvtepi32_epi64(mask);
+        }else{
+            static_assert(sizeof(inT) == -1, "should not reach here");
         }
     }
     else {