Function neon_absmax

csrc/cpu_ops.cpp:169–217

// NEON-optimized absmax computation for a block of float32, bf16, or fp16.
template <typename T> static inline float neon_absmax(const T* data, long long n) {
    float32x4_t vmax = vdupq_n_f32(0.0f);
    long long i = 0;
    for (; i + 16 <= n; i += 16) {
        float32x4_t v0, v1, v2, v3;
        if constexpr (std::is_same<T, float>::value) {
            const float* p = reinterpret_cast<const float*>(data + i);
            v0 = vld1q_f32(p);
            v1 = vld1q_f32(p + 4);
            v2 = vld1q_f32(p + 8);
            v3 = vld1q_f32(p + 12);
        } else if constexpr (std::is_same<T, bf16_t>::value) {
            v0 = neon_bf16x4_to_f32(data + i);
            v1 = neon_bf16x4_to_f32(data + i + 4);
            v2 = neon_bf16x4_to_f32(data + i + 8);
            v3 = neon_bf16x4_to_f32(data + i + 12);
        } else {
            v0 = neon_fp16x4_to_f32(data + i);
            v1 = neon_fp16x4_to_f32(data + i + 4);
            v2 = neon_fp16x4_to_f32(data + i + 8);
            v3 = neon_fp16x4_to_f32(data + i + 12);
        }
        vmax = vmaxq_f32(
            vmax, vmaxq_f32(vmaxq_f32(vabsq_f32(v0), vabsq_f32(v1)), vmaxq_f32(vabsq_f32(v2), vabsq_f32(v3)))
        );
    }
    for (; i + 4 <= n; i += 4) {
        float32x4_t v;
        if constexpr (std::is_same<T, float>::value)
            v = vld1q_f32(reinterpret_cast<const float*>(data + i));
        else if constexpr (std::is_same<T, bf16_t>::value)
            v = neon_bf16x4_to_f32(data + i);
        else
            v = neon_fp16x4_to_f32(data + i);
        vmax = vmaxq_f32(vmax, vabsq_f32(v));
    }
    float result = vmaxvq_f32(vmax);
    for (; i < n; ++i) {
        float val;
        if constexpr (std::is_same<T, float>::value)
            val = data[i];
        else if constexpr (std::is_same<T, bf16_t>::value)
            val = bf16_to_float(data[i].v);
        else
            val = fp16_to_float(data[i].v);
        result = std::max(result, std::fabs(val));
    }
    return result;
}

// NEON-optimized norm_to_lut_index for 4 float values at a time
// Maps [-1, 1] → [0, 65535]