quantize_row_q8_k_avx2.c File Reference

AVX2 entrypoint for exact Q8_K row quantization. More...

#include "ckernel_quant.h"

Go to the source code of this file.

Functions
void	quantize_row_q8_k_avx2 (const float *x, void *vy, int k)
void	quantize_row_q8_k_ref (const float *x, void *vy, int k)

Detailed Description

AVX2 entrypoint for exact Q8_K row quantization.

The previous AVX2 entrypoint delegated to the SSE implementation. On this CPU the scalar reference compiles into a faster loop than both the SSE body and a hand-written AVX2 pack path, while preserving byte-exact Q8_K output.

Definition in file quantize_row_q8_k_avx2.c.

Function Documentation

quantize_row_q8_k_avx2()

void quantize_row_q8_k_avx2	(	const float *	x,
		void *	vy,
		int	k
	)

Definition at line 14 of file quantize_row_q8_k_avx2.c.

                                                             {
    quantize_row_q8_k_ref(x, vy, k);
}

References quantize_row_q8_k_ref().

Referenced by quantize_row_q8_k().

quantize_row_q8_k_ref()

void quantize_row_q8_k_ref	(	const float *	x,
		void *	vy,
		int	k
	)

Definition at line 61 of file gemm_kernels_q4k_q8k.c.

                                                            {
    if (!x || !vy || k <= 0) {
        return;
    }
    assert(k % QK_K == 0);
    const int nb = k / QK_K;
    block_q8_K *y = (block_q8_K *)vy;
 
    for (int i = 0; i < nb; ++i) {
        float max = 0.0f;
        float amax = 0.0f;
        for (int j = 0; j < QK_K; ++j) {
            float ax = fabsf(x[j]);
            if (ax > amax) {
                amax = ax;
                max = x[j];
            }
        }
        if (!amax) {
            y[i].d = 0.0f;
            memset(y[i].qs, 0, sizeof(y[i].qs));
            memset(y[i].bsums, 0, sizeof(y[i].bsums));
            x += QK_K;
            continue;
        }
 
        const float iscale = -127.0f / max;
        for (int j = 0; j < QK_K; ++j) {
            /* llama.cpp rounds the multiply before adding nearest_int's magic
             * constant. Contracting both operations changes Q8_K tie cases. */
            float scaled = iscale * x[j];
            int v = ck_nearest_int(scaled);
            if (v > 127) {
                v = 127;
            }
            if (v < -128) {
                v = -128;
            }
            y[i].qs[j] = (int8_t)v;
        }
 
        for (int j = 0; j < QK_K / 16; ++j) {
            int sum = 0;
            const int8_t *qs = &y[i].qs[j * 16];
            for (int ii = 0; ii < 16; ++ii) {
                sum += qs[ii];
            }
            y[i].bsums[j] = (int16_t)sum;
        }
 
        y[i].d = 1.0f / iscale;
        x += QK_K;
    }
}

Referenced by quantize_row_q8_k_avx2().