opt for pack_fixeds

update

fix

Author: BiteTheDDDDt

be/src/pipeline/exec/hashjoin_build_sink.h

@@ -192,11 +192,8 @@ struct ProcessHashTableBuild {
                bool* has_null_key) {
         if (null_map) {
             // first row is mocked and is null
-            // TODO: Need to test the for loop. break may better
-            for (uint32_t i = 1; i < _rows; i++) {
-                if ((*null_map)[i]) {
-                    *has_null_key = true;
-                }
+            if (simd::contain_one(null_map->data() + 1, _rows - 1)) {
+                *has_null_key = true;
             }
             if (short_circuit_for_null && *has_null_key) {
                 return Status::OK();
@@ -208,7 +205,7 @@ struct ProcessHashTableBuild {
                 _rows, _batch_size, *has_null_key, hash_table_ctx.direct_mapping_range());
 
         // In order to make the null keys equal when using single null eq, all null keys need to be set to default value.
-        if (_build_raw_ptrs.size() == 1 && null_map) {
+        if (_build_raw_ptrs.size() == 1 && null_map && *has_null_key) {
             _build_raw_ptrs[0]->assume_mutable()->replace_column_null_data(null_map->data());
         }
 

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

@@ -192,7 +192,9 @@ 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) {
-            _parent->_probe_columns[0]->assume_mutable()->replace_column_null_data(null_map);
+            if (simd::contain_one(null_map, probe_rows)) {
+                _parent->_probe_columns[0]->assume_mutable()->replace_column_null_data(null_map);
+            }
         }
 
         hash_table_ctx.init_serialized_keys(_parent->_probe_columns, probe_rows, null_map, true,

be/src/util/simd/bits.h

@@ -281,5 +281,27 @@ 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) {
+    size_t i = 0;
+#if 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;
+        }
+    }
+#endif
+    uint8_t tail_acc = 0;
+    for (; i < size; ++i) {
+        tail_acc |= data[i];
+    }
+    return tail_acc != 0;
+}
+
 } // namespace doris::simd
 #include "common/compile_check_end.h"

be/src/vec/columns/column_decimal.cpp

@@ -523,10 +523,6 @@ void ColumnDecimal<T>::compare_internal(size_t rhs_row_id, const IColumn& rhs,
 template <PrimitiveType T>
 void ColumnDecimal<T>::replace_column_null_data(const uint8_t* __restrict null_map) {
     auto s = size();
-    size_t null_count = s - simd::count_zero_num((const int8_t*)null_map, s);
-    if (0 == null_count) {
-        return;
-    }
     for (size_t i = 0; i < s; ++i) {
         data[i] = null_map[i] ? value_type() : data[i];
     }

be/src/vec/columns/column_vector.cpp

@@ -525,10 +525,6 @@ MutableColumnPtr ColumnVector<T>::permute(const IColumn::Permutation& perm, size
 template <PrimitiveType T>
 void ColumnVector<T>::replace_column_null_data(const uint8_t* __restrict null_map) {
     auto s = size();
-    size_t null_count = s - simd::count_zero_num((const int8_t*)null_map, s);
-    if (0 == null_count) {
-        return;
-    }
     for (size_t i = 0; i < s; ++i) {
         data[i] = null_map[i] ? default_value() : data[i];
     }

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

@@ -22,6 +22,7 @@
 #include <utility>
 
 #include "common/compiler_util.h"
+#include "util/simd/bits.h"
 #include "vec/columns/column_array.h"
 #include "vec/columns/column_nullable.h"
 #include "vec/common/arena.h"
@@ -502,42 +503,50 @@ struct MethodKeysFixed : public MethodBase<TData> {
         result.clear();
         result.resize(row_numbers);
 
+        auto* __restrict result_data = reinterpret_cast<char*>(result.data());
+
         size_t offset = 0;
+        std::vector<bool> has_null_column(nullmap_columns.size(), false);
         if (bitmap_size > 0) {
             for (size_t j = 0; j < nullmap_columns.size(); j++) {
                 if (!nullmap_columns[j]) {
                     continue;
                 }
-                size_t bucket = j / BITSIZE;
-                size_t local_offset = j % BITSIZE;
-                const auto& data =
+                const auto* __restrict data =
                         assert_cast<const ColumnUInt8&>(*nullmap_columns[j]).get_data().data();
+
+                if (!simd::contain_one(data, row_numbers)) {
+                    continue;
+                }
+                has_null_column[j] = true;
+
+                size_t bucket = j / BITSIZE;
+                size_t local_offset = j - bucket * BITSIZE;
+                const auto mask = uint8_t(1 << local_offset);
+                auto* __restrict current = result_data + bucket;
                 for (size_t i = 0; i < row_numbers; ++i) {
-                    *((char*)(&result[i]) + bucket) |= data[i] << local_offset;
+                    *(current) |= data[i] * mask;
+                    current += sizeof(T);
                 }
             }
             offset += bitmap_size;
         }
 
         for (size_t j = 0; j < key_columns.size(); ++j) {
-            const char* data = key_columns[j]->get_raw_data().data;
+            const char* __restrict data = key_columns[j]->get_raw_data().data;
 
             auto foo = [&]<typename Fixed>(Fixed zero) {
                 CHECK_EQ(sizeof(Fixed), key_sizes[j]);
-                if (!nullmap_columns.empty() && nullmap_columns[j]) {
-                    const auto& nullmap =
+                if (has_null_column.size() && has_null_column[j]) {
+                    const auto* nullmap =
                             assert_cast<const ColumnUInt8&>(*nullmap_columns[j]).get_data().data();
-                    for (size_t i = 0; i < row_numbers; ++i) {
-                        // make sure null cell is filled by 0x0
-                        memcpy_fixed<Fixed, true>(
-                                (char*)(&result[i]) + offset,
-                                nullmap[i] ? (char*)&zero : data + i * sizeof(Fixed));
-                    }
-                } else {
-                    for (size_t i = 0; i < row_numbers; ++i) {
-                        memcpy_fixed<Fixed, true>((char*)(&result[i]) + offset,
-                                                  data + i * sizeof(Fixed));
-                    }
+                    // make sure null cell is filled by 0x0
+                    key_columns[j]->assume_mutable()->replace_column_null_data(nullmap);
+                }
+                auto* __restrict current = result_data + offset;
+                for (size_t i = 0; i < row_numbers; ++i) {
+                    memcpy_fixed<Fixed, true>(current, data + i * sizeof(Fixed));
+                    current += sizeof(T);
                 }
             };
 

be/src/vec/core/column_with_type_and_name.cpp

@@ -27,6 +27,7 @@
 #include <sstream>
 #include <string>
 
+#include "util/simd/bits.h"
 #include "vec/columns/column.h"
 #include "vec/columns/column_const.h"
 #include "vec/columns/column_nothing.h"
@@ -128,7 +129,9 @@ 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();
-                mutable_nested_col->replace_column_null_data(null_map.data());
+                if (simd::contain_one(null_map.data(), null_map.size())) {
+                    mutable_nested_col->replace_column_null_data(null_map.data());
+                }
 
                 return {std::move(mutable_nested_col), nested_type, ""};
             }