驾驭 CPU 与编译器：Apache Doris 实现极致性能的底层逻辑｜Deep Dive

// 核心逻辑示意
template <typename T>
class ColumnVector final : public IColumn {
private:
     PaddedPODArray 保证了内存对齐，通常按 64 字节对齐以适配 Cache Line
    PaddedPODArray<T> data; 
public:
     向量化计算入口，不再处理单行，而是处理整个 data 数组
    void filter(const Filter& filt) override {
         ...
    }
}

// SIMD 子串匹配
const uint8_t* _search(const uint8_t* haystack, const uint8_t* haystack_end) const {
    ......
    while (haystack < haystack_end && haystack_end - haystack >= needle_size) {
#if defined(__SSE4_1__) || defined(__aarch64__)
        if ((haystack + 1 + n) <= haystack_end && page_safe(haystack)) {
            /// find first and second characters
            const auto v_haystack_block_first =
                    _mm_loadu_si128(reinterpret_cast<const __m128i*>(haystack));
            const auto v_haystack_block_second =
                    _mm_loadu_si128(reinterpret_cast<const __m128i*>(haystack + 1));

            const auto v_against_pattern_first =
                    _mm_cmpeq_epi8(v_haystack_block_first, first_pattern);
            const auto v_against_pattern_second =
                    _mm_cmpeq_epi8(v_haystack_block_second, second_pattern);

            const auto mask = _mm_movemask_epi8(
                    _mm_and_si128(v_against_pattern_first, v_against_pattern_second));
            /// first and second characters not present in 16 octets starting at `haystack`
            if (mask == 0) {
                haystack += n;
                continue;
            }
    ......
}

class VirtualBase {
    virtual int foo(int x);
};
class VirtualDerived :public VirtualBase {
    int foo(int x) override;
};
class NonVirtual {
    int bar(int x);
};

static void BM_VirtualCall(benchmark::State& state) {
    VirtualBase* obj = new VirtualDerived();
    for (auto _ : state) {
        result = obj->foo(42);
    }
}
static void BM_NonVirtualCall(benchmark::State& state) {
    NonVirtualBase obj;
    for (auto _ : state) {
        result = obj.bar(42);
    }
}
static void BM_DirectCall(benchmark::State& state) {
    VirtualDerived obj;
    for (auto _ : state) {
        result = obj.foo(42);
    }
}

template <PrimitiveType PType>
struct AddDaysImpl {
    ......
    static inline ReturnNativeType execute(const InputNativeType& t, IntervalNativeType delta) {
        // PType 已经固定，不需要运行期判断
        return date_time_add<TimeUnit::DAY, PType, IntervalNativeType>(t, delta);
        // compare to 
        // if (t.is_date) {
        //     return date_time_add<TimeUnit::DAY, DATEV2, IntervalNativeType>(t, delta);
        // } else {
        //     return date_time_add<TimeUnit::DAY, DATETIMEV2, IntervalNativeType>(t, delta);
        // }
    }
    // 不同模板实例参数不同，函数匹配时直接命中对应实例
    static DataTypes get_variadic_argument_types() {
        return {std ::make_shared<typename PrimitiveTypeTraits<PType>::DataType>(),
                std ::make_shared<typename PrimitiveTypeTraits<IntervalPType>::DataType>()};
    }
}

using FunctionAddDays = FunctionDateOrDateTimeComputation<AddDaysImpl<TYPE_DATEV2>>;
using FunctionDatetimeAddDays = FunctionDateOrDateTimeComputation<AddDaysImpl<TYPE_DATETIMEV2>>;

factory.register_function<FunctionDatetimeAddDays>();
factory.register_function<FunctionAddDays>();

class Arena : private boost::noncopyable {
    struct Chunk :private Allocator<false> {
        ......
    }
public:
    char* alloc(size_t size) {
        _init_head_if_needed();
        if (UNLIKELY(head->pos + size > head->end)) {
            _add_chunk(size);
        }
        // 直接 bump pointer，开销无限小
        char* res = head->pos;
        head->pos += size;
        return res;
    }
    // 一次性统一回收
    void clear(bool delete_head = false) {
        ......
    }
};