update fix

format

update

format

Author: BiteTheDDDDt

be/src/pipeline/exec/hashjoin_build_sink.h

@@ -192,7 +192,7 @@ struct ProcessHashTableBuild {
                bool* has_null_key) {
         if (null_map) {
             // first row is mocked and is null
-            if (simd::contain_one(null_map->data() + 1, _rows - 1)) {
+            if (simd::contain_non_zero(null_map->data() + 1, _rows - 1)) {
                 *has_null_key = true;
             }
             if (short_circuit_for_null && *has_null_key) {

be/src/pipeline/exec/join/process_hash_table_probe_impl.h

@@ -114,8 +114,8 @@ void ProcessHashTableProbe<JoinOpType>::build_side_output_column(vectorized::Mut
             _build_column_has_null[i] = false;
             if (_right_output_slot_flags[i] && column.is_nullable()) {
                 const auto& nullable = assert_cast<const vectorized::ColumnNullable&>(column);
-                _build_column_has_null[i] = !simd::contain_byte(
-                        nullable.get_null_map_data().data() + 1, nullable.size() - 1, 1);
+                _build_column_has_null[i] = !simd::contain_non_zero(
+                        nullable.get_null_map_data().data() + 1, nullable.size() - 1);
             }
         }
     }
@@ -192,7 +192,7 @@ typename HashTableType::State ProcessHashTableProbe<JoinOpType>::_init_probe_sid
         hash_table_ctx.arena.clear();
         // In order to make the null keys equal when using single null eq, all null keys need to be set to default value.
         if (_parent->_probe_columns.size() == 1 && null_map) {
-            if (simd::contain_one(null_map, probe_rows)) {
+            if (simd::contain_non_zero(null_map, probe_rows)) {
                 _parent->_probe_columns[0]->assume_mutable()->replace_column_null_data(null_map);
             }
         }
@@ -368,8 +368,7 @@ Status ProcessHashTableProbe<JoinOpType>::finalize_block_with_filter(
         }
         const auto& column_filter =
                 assert_cast<const vectorized::ColumnUInt8*>(filter_ptr.get())->get_data();
-        bool need_filter =
-                simd::count_zero_num((int8_t*)column_filter.data(), column_filter.size()) != 0;
+        bool need_filter = simd::contain_zero(column_filter.data(), column_filter.size());
         if (need_filter) {
             row_indexs.filter(column_filter);
         }

be/src/pipeline/exec/nested_loop_join_probe_operator.h

@@ -97,9 +97,7 @@ class NestedLoopJoinProbeLocalState final
                     }
                     if (!_cur_probe_row_visited_flags[i]) {
                         _cur_probe_row_visited_flags[i] =
-                                simd::contain_byte<uint8_t>(filter.data() + offset, end - offset, 1)
-                                        ? 1
-                                        : 0;
+                                simd::contain_non_zero(filter.data() + offset, end - offset);
                     }
                     end = offset;
                 }

be/src/util/simd/bits.h

@@ -261,14 +261,6 @@ static size_t find_byte(const T* data, size_t start, size_t end, T byte) {
     return (T*)p - data;
 }
 
-template <typename T>
-bool contain_byte(const T* __restrict data, const size_t length, const signed char byte) {
-    if (length == 0) {
-        return false;
-    }
-    return nullptr != std::memchr(reinterpret_cast<const void*>(data), byte, length);
-}
-
 inline size_t find_one(const std::vector<uint8_t>& vec, size_t start) {
     return find_byte<uint8_t>(vec, start, 1);
 }
@@ -281,26 +273,69 @@ inline size_t find_zero(const std::vector<uint8_t>& vec, size_t start) {
     return find_byte<uint8_t>(vec, start, 0);
 }
 
-inline bool contain_one(const uint8_t* __restrict data, size_t size) {
+namespace detail {
+// Checker for contain_non_zero: detect if any non-zero value exists
+struct ContainNonZeroChecker {
+    static inline bool check_simd_result(uint32_t mask) {
+#if defined(__AVX2__)
+        return mask != 0xFFFFFFFF;
+#else
+        return mask != 0xFFFF;
+#endif
+    }
+
+    static inline bool check_tail(uint8_t byte) { return byte != 0; }
+};
+
+// Checker for contain_zero: detect if any zero value exists
+struct ContainZeroChecker {
+    static inline bool check_simd_result(uint32_t mask) { return mask != 0; }
+
+    static inline bool check_tail(uint8_t byte) { return byte == 0; }
+};
+
+template <typename Checker>
+inline bool contain_value(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));
+            uint32_t mask = _mm256_movemask_epi8(_mm256_cmpeq_epi8(chunk, zero));
+            if (Checker::check_simd_result(mask)) {
+                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));
+            uint32_t mask = _mm_movemask_epi8(_mm_cmpeq_epi8(chunk, zero));
+            if (Checker::check_simd_result(mask)) {
+                return true;
+            }
         }
     }
 #endif
-    uint8_t tail_acc = 0;
     for (; i < size; ++i) {
-        tail_acc |= data[i];
+        if (Checker::check_tail(data[i])) {
+            return true;
+        }
     }
-    return tail_acc != 0;
+    return false;
+}
+} // namespace detail
+
+// Check if there is any non-zero value in the data
+inline bool contain_non_zero(const uint8_t* __restrict data, size_t size) {
+    return detail::contain_value<detail::ContainNonZeroChecker>(data, size);
+}
+
+inline bool contain_zero(const uint8_t* __restrict data, size_t size) {
+    return detail::contain_value<detail::ContainZeroChecker>(data, size);
 }
 
 } // namespace doris::simd

be/src/vec/columns/column_nullable.cpp

@@ -280,7 +280,7 @@ size_t ColumnNullable::serialize_impl(char* pos, const size_t row) const {
 }
 
 void ColumnNullable::serialize(StringRef* keys, size_t num_rows) const {
-    const bool has_null = simd::contain_byte(get_null_map_data().data(), num_rows, 1);
+    const bool has_null = simd::contain_non_zero(get_null_map_data().data(), num_rows);
     const auto* __restrict null_map =
             assert_cast<const ColumnUInt8&>(get_null_map_column()).get_data().data();
     _nested_column->serialize_with_nullable(keys, num_rows, has_null, null_map);
@@ -598,11 +598,11 @@ void ColumnNullable::sort_column(const ColumnSorter* sorter, EqualFlags& flags,
 }
 
 bool ColumnNullable::only_null() const {
-    return !simd::contain_byte(get_null_map_data().data(), size(), 0);
+    return !simd::contain_zero(get_null_map_data().data(), size());
 }
 
 bool ColumnNullable::has_null(size_t begin, size_t end) const {
-    return simd::contain_byte(get_null_map_data().data() + begin, end - begin, 1);
+    return simd::contain_non_zero(get_null_map_data().data() + begin, end - begin);
 }
 
 bool ColumnNullable::has_null() const {

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
@@ -584,19 +580,15 @@ struct MethodKeysFixed : public MethodBase<TData> {
                 const uint8_t* __restrict data =
                         assert_cast<const ColumnUInt8&>(*nullmap_columns[j]).get_data().data();
 
-                has_null_column[j] = simd::contain_one(data, row_numbers);
+                has_null_column[j] = simd::contain_non_zero(data, row_numbers);
                 if (has_null_column[j]) {
                     nullmap_datas.emplace_back(data);
                     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,

be/src/vec/core/column_with_type_and_name.cpp

@@ -129,7 +129,7 @@ ColumnWithTypeAndName ColumnWithTypeAndName::unnest_nullable(
                 const auto& null_map = source_column->get_null_map_data();
                 // only need to mutate nested column, avoid to copy nullmap
                 auto mutable_nested_col = (*std::move(nested_column)).mutate();
-                if (simd::contain_one(null_map.data(), null_map.size())) {
+                if (simd::contain_non_zero(null_map.data(), null_map.size())) {
                     mutable_nested_col->replace_column_null_data(null_map.data());
                 }
 

be/src/vec/data_types/serde/data_type_map_serde.cpp

@@ -352,8 +352,8 @@ Status DataTypeMapSerDe::write_column_to_arrow(const IColumn& column, const Null
         if ((null_map && (*null_map)[r])) {
             RETURN_IF_ERROR(checkArrowStatus(builder.AppendNull(), column.get_name(),
                                              array_builder->type()->name()));
-        } else if (simd::contain_byte(keys_nullmap_data + offsets[r - 1],
-                                      offsets[r] - offsets[r - 1], 1)) {
+        } else if (simd::contain_non_zero(keys_nullmap_data + offsets[r - 1],
+                                          offsets[r] - offsets[r - 1])) {
             // arrow do not support key is null, so we ignore the null key-value
             MutableColumnPtr key_mutable_data = nested_keys_column.clone_empty();
             MutableColumnPtr value_mutable_data = nested_values_column.clone_empty();

be/src/vec/functions/function_jsonb.cpp

@@ -727,8 +727,7 @@ class FunctionJsonbExtractPath : public IFunction {
                 VectorizedUtils::update_null_map(*result_null_map, *path_null_map, path_const);
             }
 
-            if (0 == simd::count_zero_num(reinterpret_cast<const int8_t*>(result_null_map->data()),
-                                          input_rows_count)) {
+            if (!simd::contain_zero(result_null_map->data(), input_rows_count)) {
                 return create_all_null_result();
             }
         }