update fix

Author: BiteTheDDDDt

be/src/util/simd/bits.h

@@ -283,16 +283,24 @@ inline size_t find_zero(const std::vector<uint8_t>& vec, size_t start) {
 
 inline bool contain_one(const uint8_t* __restrict data, size_t size) {
     size_t i = 0;
-#if defined(__SSE2__)
+#if defined(__AVX2__)
+    {
+        const __m256i zero = _mm256_setzero_si256();
+        for (; i + 31 < size; i += 32) {
+            __m256i chunk = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(data + i));
+            if (_mm256_movemask_epi8(_mm256_cmpeq_epi8(chunk, zero)) != 0xFFFFFFFF) {
+                return true;
+            }
+        }
+    }
+#elif defined(__SSE2__)
     {
         const __m128i zero = _mm_setzero_si128();
-        __m128i acc = zero;
         for (; i + 15 < size; i += 16) {
-            acc = _mm_or_si128(acc, _mm_loadu_si128(reinterpret_cast<const __m128i*>(data + i)));
-        }
-
-        if (_mm_movemask_epi8(_mm_cmpeq_epi8(acc, zero)) != 0xFFFF) {
-            return true;
+            __m128i chunk = _mm_loadu_si128(reinterpret_cast<const __m128i*>(data + i));
+            if (_mm_movemask_epi8(_mm_cmpeq_epi8(chunk, zero)) != 0xFFFF) {
+                return true;
+            }
         }
     }
 #endif

be/src/vec/common/hash_table/hash_key_type.h

@@ -94,12 +94,12 @@ inline HashKeyType get_hash_key_type_fixed(const std::vector<vectorized::DataTyp
         }
     }
 
-    size_t bitmap_size = has_null ? vectorized::get_bitmap_size(data_types.size()) : 0;
+    size_t bitmap_size = has_null ? 1 : 0;
     return get_hash_key_type_with_fixed(bitmap_size + key_byte_size);
 }
 
 inline HashKeyType get_hash_key_type(const std::vector<vectorized::DataTypePtr>& data_types) {
-    if (data_types.size() > 1) {
+    if (data_types.size() > 1 && data_types.size() <= vectorized::BITSIZE) {
         return get_hash_key_type_fixed(data_types);
     }
     if (data_types.empty()) {

be/src/vec/common/hash_table/hash_map_context.h

@@ -291,10 +291,6 @@ struct MethodSerialized : public MethodBase<TData> {
     }
 };
 
-inline size_t get_bitmap_size(size_t key_number) {
-    return (key_number + BITSIZE - 1) / BITSIZE;
-}
-
 template <typename TData>
 struct MethodStringNoCache : public MethodBase<TData> {
     using Base = MethodBase<TData>;
@@ -562,7 +558,7 @@ struct MethodKeysFixed : public MethodBase<TData> {
     template <typename T>
     void pack_fixeds(size_t row_numbers, const ColumnRawPtrs& key_columns,
                      const ColumnRawPtrs& nullmap_columns, DorisVector<T>& result) {
-        size_t bitmap_size = get_bitmap_size(nullmap_columns.size());
+        size_t bitmap_size = nullmap_columns.empty() ? 0 : 1;
         if (bitmap_size) {
             // set size to 0 at first, then use resize to call default constructor on index included from [0, row_numbers) to reset all memory
             // only need to reset the memory used to bitmap
@@ -590,13 +586,9 @@ struct MethodKeysFixed : public MethodBase<TData> {
                     bit_offsets.emplace_back(j % BITSIZE);
                 }
             }
-            for (size_t j = 0, bucket = 0; j < nullmap_datas.size(); j += BITSIZE, bucket++) {
-                int column_batch = std::min(BITSIZE, (int)(nullmap_datas.size() - j));
-                constexpr_int_match<1, BITSIZE, PackNullmapsReducer>::run(
-                        column_batch, nullmap_datas.data() + j, bit_offsets.data() + j, row_numbers,
-                        sizeof(T), reinterpret_cast<uint8_t*>(result_data + bucket));
-            }
-
+            constexpr_int_match<1, BITSIZE, PackNullmapsReducer>::run(
+                    int(nullmap_datas.size()), nullmap_datas.data(), bit_offsets.data(), row_numbers,
+                    sizeof(T), reinterpret_cast<uint8_t*>(result_data));
             offset += bitmap_size;
         }
 
@@ -657,6 +649,7 @@ struct MethodKeysFixed : public MethodBase<TData> {
     void init_serialized_keys(const ColumnRawPtrs& key_columns, uint32_t num_rows,
                               const uint8_t* null_map = nullptr, bool is_join = false,
                               bool is_build = false, uint32_t bucket_size = 0) override {
+        CHECK(key_columns.size() <= BITSIZE);
         ColumnRawPtrs actual_columns;
         ColumnRawPtrs null_maps;
         actual_columns.reserve(key_columns.size());
@@ -694,14 +687,7 @@ struct MethodKeysFixed : public MethodBase<TData> {
 
     void insert_keys_into_columns(std::vector<typename Base::Key>& input_keys,
                                   MutableColumns& key_columns, const uint32_t num_rows) override {
-        // In any hash key value, column values to be read start just after the bitmap, if it exists.
         size_t pos = 0;
-        for (size_t i = 0; i < key_columns.size(); ++i) {
-            if (key_columns[i]->is_nullable()) {
-                pos = get_bitmap_size(key_columns.size());
-                break;
-            }
-        }
 
         for (size_t i = 0; i < key_columns.size(); ++i) {
             size_t size = key_sizes[i];
@@ -720,11 +706,8 @@ struct MethodKeysFixed : public MethodBase<TData> {
 
                 // The current column is nullable. Check if the value of the
                 // corresponding key is nullable. Update the null map accordingly.
-                size_t bucket = i / BITSIZE;
-                size_t offset = i % BITSIZE;
                 for (size_t j = 0; j < num_rows; j++) {
-                    nullmap[j] =
-                            (reinterpret_cast<const UInt8*>(&input_keys[j])[bucket] >> offset) & 1;
+                    nullmap[j] = (*reinterpret_cast<const UInt8*>(&input_keys[j]) >> i) & 1;
                 }
             } else {
                 // key_columns is a mutable element. However, when accessed through get_raw_data().data,