From 37975f405f86e90f6430b1567f7e7ba4aedf61ce Mon Sep 17 00:00:00 2001 From: SignalRT Date: Thu, 22 Jun 2023 23:31:10 +0200 Subject: [PATCH] Libraries with MacOS Metal Support Add metal libraries and ggml-metal.metal helper --- LLama/LLamaSharp.Runtime.targets | 4 + LLama/runtimes/ggml-metal.metal | 1585 ++++++++++++++++++++++++++++++ LLama/runtimes/libllama.dylib | Bin 483403 -> 539531 bytes 3 files changed, 1589 insertions(+) create mode 100644 LLama/runtimes/ggml-metal.metal diff --git a/LLama/LLamaSharp.Runtime.targets b/LLama/LLamaSharp.Runtime.targets index 2c166bb3..8910f155 100644 --- a/LLama/LLamaSharp.Runtime.targets +++ b/LLama/LLamaSharp.Runtime.targets @@ -31,5 +31,9 @@ PreserveNewest libllama.dylib + + PreserveNewest + ggml-metal.metal + \ No newline at end of file diff --git a/LLama/runtimes/ggml-metal.metal b/LLama/runtimes/ggml-metal.metal new file mode 100644 index 00000000..d1e49222 --- /dev/null +++ b/LLama/runtimes/ggml-metal.metal @@ -0,0 +1,1585 @@ +#include + +using namespace metal; + +#define MAX(x, y) ((x) > (y) ? (x) : (y)) + +#define QK4_0 32 +#define QR4_0 2 +typedef struct { + half d; // delta + uint8_t qs[QK4_0 / 2]; // nibbles / quants +} block_q4_0; + +#define QK4_1 32 +typedef struct { + half d; // delta + half m; // min + uint8_t qs[QK4_1 / 2]; // nibbles / quants +} block_q4_1; + +static void dequantize_row_q4_0(device const block_q4_0 * x, device float * y, int k) { + const int qk = QK4_0; + + assert(k % qk == 0); + + const int nb = k / qk; + + for (int i = 0; i < nb; i++) { + const half d = x[i].d; + + for (int j = 0; j < qk/2; ++j) { + const int x0 = (x[i].qs[j] & 0x0F) - 8; + const int x1 = (x[i].qs[j] >> 4) - 8; + + y[i*qk + j + 0 ] = x0*d; + y[i*qk + j + qk/2] = x1*d; + } + } +} + +static void dequantize_row_q4_1(device const block_q4_1 * x, device float * y, int k) { + const int qk = QK4_1; + + assert(k % qk == 0); + + const int nb = k / qk; + + for (int i = 0; i < nb; i++) { + const half d = x[i].d; + const half m = x[i].m; + + for (int j = 0; j < qk/2; ++j) { + const int x0 = (x[i].qs[j] & 0x0F); + const int x1 = (x[i].qs[j] >> 4); + + y[i*qk + j + 0 ] = x0*d + m; + y[i*qk + j + qk/2] = x1*d + m; + } + } +} + +kernel void kernel_add( + device const float * src0, + device const float * src1, + device float * dst, + uint tpig[[thread_position_in_grid]]) { + dst[tpig] = src0[tpig] + src1[tpig]; +} + +kernel void kernel_mul( + device const float * src0, + device const float * src1, + device float * dst, + uint tpig[[thread_position_in_grid]]) { + dst[tpig] = src0[tpig] * src1[tpig]; +} + +// assumption: src1 is a row +// broadcast src1 into src0 +kernel void kernel_mul_row( + device const float * src0, + device const float * src1, + device float * dst, + constant int64_t & ne00, + uint tpig[[thread_position_in_grid]]) { + dst[tpig] = src0[tpig] * src1[tpig % ne00]; +} + +kernel void kernel_scale( + device const float * src0, + device float * dst, + constant float & scale, + uint tpig[[thread_position_in_grid]]) { + dst[tpig] = src0[tpig] * scale; +} + +kernel void kernel_silu( + device const float * src0, + device float * dst, + uint tpig[[thread_position_in_grid]]) { + float x = src0[tpig]; + dst[tpig] = x / (1.0f + exp(-x)); +} + +kernel void kernel_relu( + device const float * src0, + device float * dst, + uint tpig[[thread_position_in_grid]]) { + dst[tpig] = max(0.0f, src0[tpig]); +} + +constant float GELU_COEF_A = 0.044715f; +constant float SQRT_2_OVER_PI = 0.79788456080286535587989211986876f; + +kernel void kernel_gelu( + device const float * src0, + device float * dst, + uint tpig[[thread_position_in_grid]]) { + float x = src0[tpig]; + dst[tpig] = 0.5f*x*(1.0f + tanh(SQRT_2_OVER_PI*x*(1.0f + GELU_COEF_A*x*x))); +} + +kernel void kernel_soft_max( + device const float * src0, + device float * dst, + constant int64_t & ne00, + constant int64_t & ne01, + constant int64_t & ne02, + threadgroup float * buf [[threadgroup(0)]], + uint3 tgpig[[threadgroup_position_in_grid]], + uint3 tpitg[[thread_position_in_threadgroup]], + uint3 ntg[[threads_per_threadgroup]]) { + const int64_t i03 = tgpig[2]; + const int64_t i02 = tgpig[1]; + const int64_t i01 = tgpig[0]; + + device const float * psrc0 = src0 + i03*ne02*ne01*ne00 + i02*ne01*ne00 + i01*ne00; + device float * pdst = dst + i03*ne02*ne01*ne00 + i02*ne01*ne00 + i01*ne00; + + // parallel max + buf[tpitg[0]] = -INFINITY; + for (int i00 = tpitg[0]; i00 < ne00; i00 += ntg[0]) { + buf[tpitg[0]] = MAX(buf[tpitg[0]], psrc0[i00]); + } + + // reduce + threadgroup_barrier(mem_flags::mem_threadgroup); + for (uint i = ntg[0]/2; i > 0; i /= 2) { + if (tpitg[0] < i) { + buf[tpitg[0]] = MAX(buf[tpitg[0]], buf[tpitg[0] + i]); + } + threadgroup_barrier(mem_flags::mem_threadgroup); + } + + // broadcast + if (tpitg[0] == 0) { + buf[0] = buf[0]; + } + + threadgroup_barrier(mem_flags::mem_threadgroup); + + const float max = buf[0]; + + // parallel sum + buf[tpitg[0]] = 0.0f; + for (int i00 = tpitg[0]; i00 < ne00; i00 += ntg[0]) { + buf[tpitg[0]] += exp(psrc0[i00] - max); + } + + // reduce + threadgroup_barrier(mem_flags::mem_threadgroup); + for (uint i = ntg[0]/2; i > 0; i /= 2) { + if (tpitg[0] < i) { + buf[tpitg[0]] += buf[tpitg[0] + i]; + } + threadgroup_barrier(mem_flags::mem_threadgroup); + } + + // broadcast + if (tpitg[0] == 0) { + buf[0] = buf[0]; + } + + threadgroup_barrier(mem_flags::mem_threadgroup); + + const float sum = buf[0]; + + for (int i00 = tpitg[0]; i00 < ne00; i00 += ntg[0]) { + pdst[i00] = exp(psrc0[i00] - max) / sum; + } +} + +kernel void kernel_diag_mask_inf( + device const float * src0, + device float * dst, + constant int64_t & ne00, + constant int64_t & ne01, + constant int & n_past, + uint3 tpig[[thread_position_in_grid]]) { + const int64_t i02 = tpig[2]; + const int64_t i01 = tpig[1]; + const int64_t i00 = tpig[0]; + + if (i00 > n_past + i01) { + dst[i02*ne01*ne00 + i01*ne00 + i00] = -INFINITY; + } else { + dst[i02*ne01*ne00 + i01*ne00 + i00] = src0[i02*ne01*ne00 + i01*ne00 + i00]; + } +} + +kernel void kernel_get_rows_f16( + device const void * src0, + device const int * src1, + device float * dst, + constant int64_t & ne00, + constant uint64_t & nb01, + constant uint64_t & nb1, + uint tpig[[thread_position_in_grid]]) { + const int i = tpig; + const int r = ((device int32_t *) src1)[i]; + + for (int j = 0; j < ne00; j++) { + dst[i*nb1 + j] = ((device half *) ((device char *) src0 + r*nb01))[j]; + } +} + +kernel void kernel_get_rows_q4_0( + device const void * src0, + device const int * src1, + device float * dst, + constant int64_t & ne00, + constant uint64_t & nb01, + constant uint64_t & nb1, + uint tpig[[thread_position_in_grid]]) { + const int i = tpig; + const int r = ((device int32_t *) src1)[i]; + + dequantize_row_q4_0( + (device const block_q4_0 *) ((device char *) src0 + r*nb01), + (device float *) ((device char *) dst + i*nb1), ne00); +} + +kernel void kernel_get_rows_q4_1( + device const void * src0, + device const int * src1, + device float * dst, + constant int64_t & ne00, + constant uint64_t & nb01, + constant uint64_t & nb1, + uint tpig[[thread_position_in_grid]]) { + const int i = tpig; + const int r = ((device int32_t *) src1)[i]; + + dequantize_row_q4_1( + (device const block_q4_1 *) ((device char *) src0 + r*nb01), + (device float *) ((device char *) dst + i*nb1), ne00); +} + +kernel void kernel_norm( + device const void * src0, + device float * dst, + constant int64_t & ne00, + constant uint64_t & nb01, + constant float & eps, + threadgroup float * sum [[threadgroup(0)]], + uint tgpig[[threadgroup_position_in_grid]], + uint tpitg[[thread_position_in_threadgroup]], + uint ntg[[threads_per_threadgroup]]) { + device const float * x = (device const float *) ((device const char *) src0 + tgpig*nb01); + // MEAN + // parallel sum + sum[tpitg] = 0.0f; + for (int i00 = tpitg; i00 < ne00; i00 += ntg) { + sum[tpitg] += x[i00]; + } + // reduce + threadgroup_barrier(mem_flags::mem_threadgroup); + for (uint i = ntg/2; i > 0; i /= 2) { + if (tpitg < i) { + sum[tpitg] += sum[tpitg + i]; + } + threadgroup_barrier(mem_flags::mem_threadgroup); + } + // broadcast + if (tpitg == 0) { + sum[0] /= ne00; + } + threadgroup_barrier(mem_flags::mem_threadgroup); + const float mean = sum[0]; + + // recenter + device float * y = dst + tgpig*ne00; + for (int i00 = tpitg; i00 < ne00; i00 += ntg) { + y[i00] = x[i00] - mean; + } + + // VARIANCE + // parallel sum + sum[tpitg] = 0.0f; + for (int i00 = tpitg; i00 < ne00; i00 += ntg) { + sum[tpitg] += y[i00] * y[i00]; + } + // reduce + threadgroup_barrier(mem_flags::mem_threadgroup); + for (uint i = ntg/2; i > 0; i /= 2) { + if (tpitg < i) { + sum[tpitg] += sum[tpitg + i]; + } + threadgroup_barrier(mem_flags::mem_threadgroup); + } + // broadcast + if (tpitg == 0) { + sum[0] /= ne00; + } + threadgroup_barrier(mem_flags::mem_threadgroup); + const float variance = sum[0]; + + const float scale = 1.0f/sqrt(variance + eps); + for (int i00 = tpitg; i00 < ne00; i00 += ntg) { + y[i00] = y[i00] * scale; + } +} + + +kernel void kernel_rms_norm( + device const void * src0, + device float * dst, + constant int64_t & ne00, + constant uint64_t & nb01, + constant float & eps, + threadgroup float * sum [[threadgroup(0)]], + uint tgpig[[threadgroup_position_in_grid]], + uint tpitg[[thread_position_in_threadgroup]], + uint ntg[[threads_per_threadgroup]]) { + device const float * x = (device const float *) ((device const char *) src0 + tgpig*nb01); + + // parallel sum + sum[tpitg] = 0.0f; + for (int i00 = tpitg; i00 < ne00; i00 += ntg) { + sum[tpitg] += x[i00] * x[i00]; + } + + // reduce + threadgroup_barrier(mem_flags::mem_threadgroup); + for (uint i = ntg/2; i > 0; i /= 2) { + if (tpitg < i) { + sum[tpitg] += sum[tpitg + i]; + } + threadgroup_barrier(mem_flags::mem_threadgroup); + } + + // broadcast + if (tpitg == 0) { + sum[0] /= ne00; + } + + threadgroup_barrier(mem_flags::mem_threadgroup); + + const float mean = sum[0]; + const float scale = 1.0f/sqrt(mean + eps); + + device float * y = dst + tgpig*ne00; + for (int i00 = tpitg; i00 < ne00; i00 += ntg) { + y[i00] = x[i00] * scale; + } +} + +kernel void kernel_mul_mat_q4_0_f32( + device const void * src0, + device const float * src1, + device float * dst, + constant int64_t & ne00, + constant int64_t & ne10, + constant int64_t & ne0, + threadgroup float * sum [[threadgroup(0)]], + uint2 tgpig[[threadgroup_position_in_grid]], + uint2 tpitg[[thread_position_in_threadgroup]], + uint2 tptg[[threads_per_threadgroup]]) { + const int nb = ne00/QK4_0; + + const int64_t r0 = tgpig.x; + const int64_t r1 = tgpig.y; + + device const block_q4_0 * x = (device const block_q4_0 *) src0 + r0*nb; + device const float * y = (device const float *) src1 + r1*ne10; + + const int nth = tptg.x*tptg.y; + const int ith = tptg.y*tpitg.x + tpitg.y; + + const int ix = tpitg.y/4; // 0 or 1 + const int iy = tpitg.y - 4*ix; // 0...3 + + const int first = 4 * iy; + + float sumf = 0; + + for (int i = 2*tpitg.x + ix; i < nb; i += 2*tptg.x) { + + const float d = (float)x[i].d; + + device const uint8_t * xl = x[i].qs + first; + device const float * yl = y + i * QK4_0 + first; + + float2 acc = {0.0f, 0.0f}; + + for (int j = 0; j < 4; ++j) { + + acc[0] += yl[j] * (xl[j] & 0xF) + yl[j+16] * (xl[j] >> 4); + acc[1] += yl[j] + yl[j+16]; + + } + + sumf += d * (acc[0] - 8.f*acc[1]); + } + + sum[ith] = sumf; + + // + // Accumulate the sum from all threads in the threadgroup + // + threadgroup_barrier(mem_flags::mem_threadgroup); + if (ith%4 == 0) { + sum[ith] += sum[ith+1] + sum[ith+2] + sum[ith+3]; + } + threadgroup_barrier(mem_flags::mem_threadgroup); + if (ith%16 == 0) { + sum[ith] += sum[ith+4] + sum[ith+8] + sum[ith+12]; + } + threadgroup_barrier(mem_flags::mem_threadgroup); + if (ith == 0) { + for (uint i = 16; i < nth; i += 16) sum[0] += sum[i]; + dst[r1*ne0 + r0] = sum[0]; + } +} + +kernel void kernel_mul_mat_q4_1_f32( + device const void * src0, + device const float * src1, + device float * dst, + constant int64_t & ne00, + constant int64_t & ne10, + constant int64_t & ne0, + threadgroup float * sum [[threadgroup(0)]], + uint2 tgpig[[threadgroup_position_in_grid]], + uint2 tpitg[[thread_position_in_threadgroup]], + uint2 tptg[[threads_per_threadgroup]]) { + const int nb = ne00/QK4_1; + + const int64_t r0 = tgpig.x; + const int64_t r1 = tgpig.y; + + device const block_q4_1 * x = (device const block_q4_1 *) src0 + r0*nb; + device const float * y = (device const float *) src1 + r1*ne10; + + const uint nth = tptg.x*tptg.y; + const uint ith = tptg.y*tpitg.x + tpitg.y; + + const int ix = tpitg.y/4; // 0 or 1 + const int iy = tpitg.y - 4*ix; // 0...3 + + const int first = 4 * iy; + + float sumf = 0; + + for (int i = 2*tpitg.x + ix; i < nb; i += 2*tptg.x) { + + const float d = (float)x[i].d; + const float m = (float)x[i].m; + + device const uint8_t * xl = x[i].qs + first; + device const float * yl = y + i * QK4_1 + first; + + float2 acc = {0.0f, 0.0f}; + + for (int j = 0; j < 4; ++j) { + + acc[0] += yl[j+ 0] * (d * (xl[j] & 0xF) + m); + acc[1] += yl[j+16] * (d * (xl[j] >> 4) + m); + + } + + sumf += acc[0] + acc[1]; + } + + sum[ith] = sumf; + + // + // Accumulate the sum from all threads in the threadgroup + // + threadgroup_barrier(mem_flags::mem_threadgroup); + if (ith%4 == 0) { + sum[ith] += sum[ith+1] + sum[ith+2] + sum[ith+3]; + } + threadgroup_barrier(mem_flags::mem_threadgroup); + if (ith%16 == 0) { + sum[ith] += sum[ith+4] + sum[ith+8] + sum[ith+12]; + } + threadgroup_barrier(mem_flags::mem_threadgroup); + if (ith == 0) { + for (int i = 16; i < nth; i += 16) sum[0] += sum[i]; + dst[r1*ne0 + r0] = sum[0]; + } +} + +kernel void kernel_mul_mat_f16_f32( + device const char * src0, + device const char * src1, + device float * dst, + constant int64_t & ne00, + constant int64_t & ne01, + constant uint64_t & nb00, + constant uint64_t & nb01, + constant uint64_t & nb02, + constant int64_t & ne10, + constant int64_t & ne11, + constant uint64_t & nb10, + constant uint64_t & nb11, + constant uint64_t & nb12, + constant int64_t & ne0, + constant int64_t & ne1, + threadgroup float * sum [[threadgroup(0)]], + uint3 tgpig[[threadgroup_position_in_grid]], + uint3 tpig[[thread_position_in_grid]], + uint3 tpitg[[thread_position_in_threadgroup]], + uint3 tptg[[threads_per_threadgroup]]) { + + const int64_t r0 = tgpig.x; + const int64_t r1 = tgpig.y; + const int64_t im = tgpig.z; + + device const half * x = (device const half *) (src0 + r0*nb01 + im*nb02); + device const float * y = (device const float *) (src1 + r1*nb11 + im*nb12); + + sum[tpitg.x] = 0.0f; + + for (int i = tpitg.x; i < ne00; i += tptg.x) { + sum[tpitg.x] += (float) x[i] * (float) y[i]; + } + + // accumulate the sum from all threads in the threadgroup + threadgroup_barrier(mem_flags::mem_threadgroup); + for (uint i = tptg.x/2; i > 0; i /= 2) { + if (tpitg.x < i) { + sum[tpitg.x] += sum[tpitg.x + i]; + } + threadgroup_barrier(mem_flags::mem_threadgroup); + } + + if (tpitg.x == 0) { + dst[im*ne1*ne0 + r1*ne0 + r0] = sum[0]; + } +} + +kernel void kernel_alibi_f32( + device const float * src0, + device float * dst, + constant int64_t & ne00, + constant int64_t & ne01, + constant int64_t & ne02, + constant int64_t & ne03, + constant uint64_t & nb00, + constant uint64_t & nb01, + constant uint64_t & nb02, + constant uint64_t & nb03, + constant int64_t & ne0, + constant int64_t & ne1, + constant int64_t & ne2, + constant int64_t & ne3, + constant uint64_t & nb0, + constant uint64_t & nb1, + constant uint64_t & nb2, + constant uint64_t & nb3, + constant float & m0, + uint3 tgpig[[threadgroup_position_in_grid]], + uint3 tpitg[[thread_position_in_threadgroup]], + uint3 ntg[[threads_per_threadgroup]]) { + const int64_t i03 = tgpig[2]; + const int64_t i02 = tgpig[1]; + const int64_t i01 = tgpig[0]; + + const int64_t n = i03*ne02*ne01*ne00 + i02*ne01*ne00 + i01*ne00; + + const int64_t i3 = n / (ne2*ne1*ne0); + const int64_t i2 = (n - i3*ne2*ne1*ne0) / (ne1*ne0); + const int64_t i1 = (n - i3*ne2*ne1*ne0 - i2*ne1*ne0) / ne0; + const int64_t i0 = (n - i3*ne2*ne1*ne0 - i2*ne1*ne0 - i1*ne0); + + device float * dst_data = (device float *) ((device char *) dst + i3*nb3 + i2*nb2 + i1*nb1 + i0*nb0); + float m_k = pow(m0, i2 + 1); + for (int64_t i00 = tpitg.x; i00 < ne00; i00 += ntg.x) { + device const float * src = (device float *)((device char *) src0 + i03*nb03 + i02*nb02 + i01*nb01 + i00*nb00); + dst_data[i00] = src[0] + m_k * (i00 - ne00 + 1); + } +} + +kernel void kernel_rope( + device const void * src0, + device float * dst, + constant int64_t & ne00, + constant int64_t & ne01, + constant int64_t & ne02, + constant int64_t & ne03, + constant uint64_t & nb00, + constant uint64_t & nb01, + constant uint64_t & nb02, + constant uint64_t & nb03, + constant int64_t & ne0, + constant int64_t & ne1, + constant int64_t & ne2, + constant int64_t & ne3, + constant uint64_t & nb0, + constant uint64_t & nb1, + constant uint64_t & nb2, + constant uint64_t & nb3, + constant int & n_past, + constant int & n_dims, + constant int & mode, + uint3 tpig[[thread_position_in_grid]]) { + const int64_t i3 = tpig[2]; + const int64_t i2 = tpig[1]; + const int64_t i1 = tpig[0]; + + const bool is_neox = mode & 2; + const float theta_scale = pow(10000.0, -2.0f/n_dims); + + const int64_t p = ((mode & 1) == 0 ? n_past + i2 : i2); + + float theta = (float)p; + + if (!is_neox) { + for (int64_t i0 = 0; i0 < ne0; i0 += 2) { + const float cos_theta = cos(theta); + const float sin_theta = sin(theta); + + theta *= theta_scale; + + device const float * const src = (device float *)((device char *) src0 + i3*nb03 + i2*nb02 + i1*nb01 + i0*nb00); + device float * dst_data = (device float *)((device char *) dst + i3*nb3 + i2*nb2 + i1*nb1 + i0*nb0); + + const float x0 = src[0]; + const float x1 = src[1]; + + dst_data[0] = x0*cos_theta - x1*sin_theta; + dst_data[1] = x0*sin_theta + x1*cos_theta; + } + } else { + // TODO: implement + } +} + +kernel void kernel_cpy_f16_f16( + device const half * src0, + device half * dst, + constant int64_t & ne00, + constant int64_t & ne01, + constant int64_t & ne02, + constant int64_t & ne03, + constant uint64_t & nb00, + constant uint64_t & nb01, + constant uint64_t & nb02, + constant uint64_t & nb03, + constant int64_t & ne0, + constant int64_t & ne1, + constant int64_t & ne2, + constant int64_t & ne3, + constant uint64_t & nb0, + constant uint64_t & nb1, + constant uint64_t & nb2, + constant uint64_t & nb3, + uint3 tgpig[[threadgroup_position_in_grid]], + uint3 tpitg[[thread_position_in_threadgroup]], + uint3 ntg[[threads_per_threadgroup]]) { + const int64_t i03 = tgpig[2]; + const int64_t i02 = tgpig[1]; + const int64_t i01 = tgpig[0]; + + const int64_t n = i03*ne02*ne01*ne00 + i02*ne01*ne00 + i01*ne00; + + const int64_t i3 = n / (ne2*ne1*ne0); + const int64_t i2 = (n - i3*ne2*ne1*ne0) / (ne1*ne0); + const int64_t i1 = (n - i3*ne2*ne1*ne0 - i2*ne1*ne0) / ne0; + const int64_t i0 = (n - i3*ne2*ne1*ne0 - i2*ne1*ne0 - i1*ne0); + + device half * dst_data = (device half *) ((device char *) dst + i3*nb3 + i2*nb2 + i1*nb1 + i0*nb0); + + for (int64_t i00 = tpitg.x; i00 < ne00; i00 += ntg.x) { + device const half * src = (device half *)((device char *) src0 + i03*nb03 + i02*nb02 + i01*nb01 + i00*nb00); + dst_data[i00] = src[0]; + } +} + +kernel void kernel_cpy_f32_f16( + device const float * src0, + device half * dst, + constant int64_t & ne00, + constant int64_t & ne01, + constant int64_t & ne02, + constant int64_t & ne03, + constant uint64_t & nb00, + constant uint64_t & nb01, + constant uint64_t & nb02, + constant uint64_t & nb03, + constant int64_t & ne0, + constant int64_t & ne1, + constant int64_t & ne2, + constant int64_t & ne3, + constant uint64_t & nb0, + constant uint64_t & nb1, + constant uint64_t & nb2, + constant uint64_t & nb3, + uint3 tgpig[[threadgroup_position_in_grid]], + uint3 tpitg[[thread_position_in_threadgroup]], + uint3 ntg[[threads_per_threadgroup]]) { + const int64_t i03 = tgpig[2]; + const int64_t i02 = tgpig[1]; + const int64_t i01 = tgpig[0]; + + const int64_t n = i03*ne02*ne01*ne00 + i02*ne01*ne00 + i01*ne00; + + const int64_t i3 = n / (ne2*ne1*ne0); + const int64_t i2 = (n - i3*ne2*ne1*ne0) / (ne1*ne0); + const int64_t i1 = (n - i3*ne2*ne1*ne0 - i2*ne1*ne0) / ne0; + const int64_t i0 = (n - i3*ne2*ne1*ne0 - i2*ne1*ne0 - i1*ne0); + + device half * dst_data = (device half *) ((device char *) dst + i3*nb3 + i2*nb2 + i1*nb1 + i0*nb0); + + for (int64_t i00 = tpitg.x; i00 < ne00; i00 += ntg.x) { + device const float * src = (device float *)((device char *) src0 + i03*nb03 + i02*nb02 + i01*nb01 + i00*nb00); + + dst_data[i00] = src[0]; + } +} + +kernel void kernel_cpy_f32_f32( + device const float * src0, + device float * dst, + constant int64_t & ne00, + constant int64_t & ne01, + constant int64_t & ne02, + constant int64_t & ne03, + constant uint64_t & nb00, + constant uint64_t & nb01, + constant uint64_t & nb02, + constant uint64_t & nb03, + constant int64_t & ne0, + constant int64_t & ne1, + constant int64_t & ne2, + constant int64_t & ne3, + constant uint64_t & nb0, + constant uint64_t & nb1, + constant uint64_t & nb2, + constant uint64_t & nb3, + uint3 tgpig[[threadgroup_position_in_grid]], + uint3 tpitg[[thread_position_in_threadgroup]], + uint3 ntg[[threads_per_threadgroup]]) { + const int64_t i03 = tgpig[2]; + const int64_t i02 = tgpig[1]; + const int64_t i01 = tgpig[0]; + + const int64_t n = i03*ne02*ne01*ne00 + i02*ne01*ne00 + i01*ne00; + + const int64_t i3 = n / (ne2*ne1*ne0); + const int64_t i2 = (n - i3*ne2*ne1*ne0) / (ne1*ne0); + const int64_t i1 = (n - i3*ne2*ne1*ne0 - i2*ne1*ne0) / ne0; + const int64_t i0 = (n - i3*ne2*ne1*ne0 - i2*ne1*ne0 - i1*ne0); + + device float * dst_data = (device float *) ((device char *) dst + i3*nb3 + i2*nb2 + i1*nb1 + i0*nb0); + + for (int64_t i00 = tpitg.x; i00 < ne00; i00 += ntg.x) { + device const float * src = (device float *)((device char *) src0 + i03*nb03 + i02*nb02 + i01*nb01 + i00*nb00); + + dst_data[i00] = src[0]; + } +} + +//============================================ k-quants ====================================================== + +#define QK_K 256 + +typedef struct { + uint8_t scales[QK_K/16]; // scales and mins, quantized with 4 bits + uint8_t qs[QK_K/4]; // quants + half d; // super-block scale for quantized scales + half dmin; // super-block scale for quantized mins +} block_q2_k; +// 84 bytes / block + +typedef struct { + uint8_t hmask[QK_K/8]; // quants - high bit + uint8_t qs[QK_K/4]; // quants - low 2 bits + uint8_t scales[3*QK_K/64]; // scales, quantized with 6 bits + half d; // super-block scale +} block_q3_k; +// 110 bytes / block + +typedef struct { + half d; // super-block scale for quantized scales + half dmin; // super-block scale for quantized mins + uint8_t scales[3*QK_K/64]; // scales and mins, quantized with 6 bits + uint8_t qs[QK_K/2]; // 4--bit quants +} block_q4_k; +// 144 bytes / block + +typedef struct { + half d; // super-block scale for quantized scales + half dmin; // super-block scale for quantized mins + uint8_t scales[3*QK_K/64]; // scales and mins, quantized with 6 bits + uint8_t qh[QK_K/8]; // quants, high bit + uint8_t qs[QK_K/2]; // quants, low 4 bits +} block_q5_k; +// 176 bytes / block + +typedef struct { + uint8_t ql[QK_K/2]; // quants, lower 4 bits + uint8_t qh[QK_K/4]; // quants, upper 2 bits + int8_t scales[QK_K/16]; // scales, quantized with 8 bits + half d; // super-block scale +} block_q6_k; +// 210 bytes / block + +static inline uchar4 get_scale_min_k4(int j, device const uint8_t * q) { + uchar4 r; + if (j < 4) { + r[0] = q[j+0] & 63; + r[2] = q[j+1] & 63; + r[1] = q[j+4] & 63; + r[3] = q[j+5] & 63; + } else { + r[0] = (q[j+4] & 0xF) | ((q[j-4] >> 6) << 4); + r[2] = (q[j+5] & 0xF) | ((q[j-3] >> 6) << 4); + r[1] = (q[j+4] >> 4) | ((q[j-0] >> 6) << 4); + r[3] = (q[j+5] >> 4) | ((q[j+1] >> 6) << 4); + } + return r; +} + +//========================================== dequantization ============================= + +static void dequantize_row_q2_k(device const block_q2_k * x, device float * y, int k) { + assert(k % QK_K == 0); + const int nb = k / QK_K; + + for (int i = 0; i < nb; i++) { + + const float d = x[i].d; + const float min = x[i].dmin; + + device const uint8_t * q = x[i].qs; + + int is = 0; + float dl, ml; + for (int n = 0; n < QK_K; n += 128) { + int shift = 0; + for (int j = 0; j < 4; ++j) { + + uint8_t sc = x[i].scales[is++]; + dl = d * (sc & 0xF); ml = min * (sc >> 4); + for (int l = 0; l < 16; ++l) *y++ = dl * ((int8_t)((q[l] >> shift) & 3)) - ml; + + sc = x[i].scales[is++]; + dl = d * (sc & 0xF); ml = min * (sc >> 4); + for (int l = 0; l < 16; ++l) *y++ = dl * ((int8_t)((q[l+16] >> shift) & 3)) - ml; + + shift += 2; + } + q += 32; + } + + } +} + +static void dequantize_row_q3_k(device const block_q3_k * x, device float * y, int k) { + assert(k % QK_K == 0); + const int nb = k / QK_K; + + const uint16_t kmask1 = 0x0303; + const uint16_t kmask2 = 0x0f0f; + + uint16_t aux[8]; + thread const int8_t * scales = (thread const int8_t*)aux; + + for (int i = 0; i < nb; i++) { + + const float d_all = (float)(x[i].d); + + device const uint8_t * q = x[i].qs; + device const uint8_t * h = x[i].hmask; + uint8_t m = 1; + + device const uint16_t * a = (device const uint16_t *)x[i].scales; + aux[0] = (a[0] & kmask2) | (((a[4] >> 0) & kmask1) << 4); + aux[1] = (a[1] & kmask2) | (((a[5] >> 0) & kmask1) << 4); + aux[2] = (a[2] & kmask2) | (((a[4] >> 2) & kmask1) << 4); + aux[3] = (a[3] & kmask2) | (((a[5] >> 2) & kmask1) << 4); + aux[4] = ((a[0] >> 4) & kmask2) | (((a[4] >> 4) & kmask1) << 4); + aux[5] = ((a[1] >> 4) & kmask2) | (((a[5] >> 4) & kmask1) << 4); + aux[6] = ((a[2] >> 4) & kmask2) | (((a[4] >> 6) & kmask1) << 4); + aux[7] = ((a[3] >> 4) & kmask2) | (((a[5] >> 6) & kmask1) << 4); + + int is = 0; + float dl; + for (int n = 0; n < QK_K; n += 128) { + int shift = 0; + for (int j = 0; j < 4; ++j) { + + dl = d_all * (scales[is++] - 32); + for (int l = 0; l < 16; ++l) { + *y++ = dl * ((int8_t)((q[l+ 0] >> shift) & 3) - ((h[l+ 0] & m) ? 0 : 4)); + } + + dl = d_all * (scales[is++] - 32); + for (int l = 0; l < 16; ++l) { + *y++ = dl * ((int8_t)((q[l+16] >> shift) & 3) - ((h[l+16] & m) ? 0 : 4)); + } + + shift += 2; + m <<= 1; + } + q += 32; + } + + } + +} + +static void dequantize_row_q4_k(device const block_q4_k * x, device float * y, int k) { + assert(k % QK_K == 0); + const int nb = k / QK_K; + + + for (int i = 0; i < nb; i++) { + + const float d = x[i].d; + const float min = x[i].dmin; + + device const uint8_t * q = x[i].qs; + device const uint8_t * scales = x[i].scales; + + int is = 0; + for (int j = 0; j < QK_K; j += 64) { + const uchar4 sc = get_scale_min_k4(is, scales); + const float d1 = d * sc[0]; const float m1 = min * sc[1]; + const float d2 = d * sc[2]; const float m2 = min * sc[3]; + for (int l = 0; l < 32; ++l) *y++ = d1 * (q[l] & 0xF) - m1; + for (int l = 0; l < 32; ++l) *y++ = d2 * (q[l] >> 4) - m2; + q += 32; is += 2; + } + + } +} + +static void dequantize_row_q5_k(device const block_q5_k * x, device float * y, int k) { + assert(k % QK_K == 0); + const int nb = k / QK_K; + + for (int i = 0; i < nb; i++) { + + const float d = (float)(x[i].d); + const float min = (float)(x[i].dmin); + + device const uint8_t * ql = x[i].qs; + device const uint8_t * qh = x[i].qh; + + int is = 0; + uint8_t u1 = 1, u2 = 2; + for (int j = 0; j < QK_K; j += 64) { + const uchar4 sc = get_scale_min_k4(is, x[i].scales); + const float d1 = d * sc[0]; const float m1 = min * sc[1]; + const float d2 = d * sc[2]; const float m2 = min * sc[3]; + for (int l = 0; l < 32; ++l) *y++ = d1 * ((ql[l] & 0xF) + (qh[l] & u1 ? 16 : 0)) - m1; + for (int l = 0; l < 32; ++l) *y++ = d2 * ((ql[l] >> 4) + (qh[l] & u2 ? 16 : 0)) - m2; + ql += 32; is += 2; + u1 <<= 2; u2 <<= 2; + } + } + +} + +static void dequantize_row_q6_k(device const block_q6_k * x, device float * y, int k) { + assert(k % QK_K == 0); + const int nb = k / QK_K; + + for (int i = 0; i < nb; i++) { + + device const uint8_t * ql = x[i].ql; + device const uint8_t * qh = x[i].qh; + device const int8_t * sc = x[i].scales; + + const float d = x[i].d; + + for (int n = 0; n < QK_K; n += 128) { + for (int l = 0; l < 32; ++l) { + int is = l/16; + const int8_t q1 = (int8_t)((ql[l + 0] & 0xF) | (((qh[l] >> 0) & 3) << 4)) - 32; + const int8_t q2 = (int8_t)((ql[l + 32] & 0xF) | (((qh[l] >> 2) & 3) << 4)) - 32; + const int8_t q3 = (int8_t)((ql[l + 0] >> 4) | (((qh[l] >> 4) & 3) << 4)) - 32; + const int8_t q4 = (int8_t)((ql[l + 32] >> 4) | (((qh[l] >> 6) & 3) << 4)) - 32; + y[l + 0] = d * sc[is + 0] * q1; + y[l + 32] = d * sc[is + 2] * q2; + y[l + 64] = d * sc[is + 4] * q3; + y[l + 96] = d * sc[is + 6] * q4; + } + y += 128; + ql += 64; + qh += 32; + sc += 8; + } + } +} + +kernel void kernel_get_rows_q2_k( + device const void * src0, + device const int * src1, + device float * dst, + constant int64_t & ne00, + constant uint64_t & nb01, + constant uint64_t & nb1, + uint tpig[[thread_position_in_grid]]) { + const int i = tpig; + const int r = ((device int32_t *) src1)[i]; + + dequantize_row_q2_k( + (device const block_q2_k *) ((device char *) src0 + r*nb01), + (device float *) ((device char *) dst + i*nb1), ne00); +} + +kernel void kernel_get_rows_q3_k( + device const void * src0, + device const int * src1, + device float * dst, + constant int64_t & ne00, + constant uint64_t & nb01, + constant uint64_t & nb1, + uint tpig[[thread_position_in_grid]]) { + const int i = tpig; + const int r = ((device int32_t *) src1)[i]; + + dequantize_row_q3_k( + (device const block_q3_k *) ((device char *) src0 + r*nb01), + (device float *) ((device char *) dst + i*nb1), ne00); +} + +kernel void kernel_get_rows_q4_k( + device const void * src0, + device const int * src1, + device float * dst, + constant int64_t & ne00, + constant uint64_t & nb01, + constant uint64_t & nb1, + uint tpig[[thread_position_in_grid]]) { + const int i = tpig; + const int r = ((device int32_t *) src1)[i]; + + dequantize_row_q4_k( + (device const block_q4_k *) ((device char *) src0 + r*nb01), + (device float *) ((device char *) dst + i*nb1), ne00); +} + +kernel void kernel_get_rows_q5_k( + device const void * src0, + device const int * src1, + device float * dst, + constant int64_t & ne00, + constant uint64_t & nb01, + constant uint64_t & nb1, + uint tpig[[thread_position_in_grid]]) { + const int i = tpig; + const int r = ((device int32_t *) src1)[i]; + + dequantize_row_q5_k( + (device const block_q5_k *) ((device char *) src0 + r*nb01), + (device float *) ((device char *) dst + i*nb1), ne00); +} + +kernel void kernel_get_rows_q6_k( + device const void * src0, + device const int * src1, + device float * dst, + constant int64_t & ne00, + constant uint64_t & nb01, + constant uint64_t & nb1, + uint tpig[[thread_position_in_grid]]) { + const int i = tpig; + const int r = ((device int32_t *) src1)[i]; + + dequantize_row_q6_k( + (device const block_q6_k *) ((device char *) src0 + r*nb01), + (device float *) ((device char *) dst + i*nb1), ne00); +} + +//====================================== dot products ========================= + +kernel void kernel_mul_mat_q2_k_f32( + device const void * src0, + device const float * src1, + device float * dst, + constant int64_t & ne00, + constant int64_t & ne10, + constant int64_t & ne0, + threadgroup float * sum [[threadgroup(0)]], + uint2 tgpig[[threadgroup_position_in_grid]], + uint2 tpitg[[thread_position_in_threadgroup]], + uint2 tptg[[threads_per_threadgroup]]) { + + const int nb = ne00/QK_K; + + const int64_t r0 = tgpig.x; + const int64_t r1 = tgpig.y; + + device const block_q2_k * x = (device const block_q2_k *) src0 + r0*nb; + device const float * yy = (device const float *) src1 + r1*ne10; + + const int nth = tptg.x*tptg.y; + const int ith = tptg.y*tpitg.x + tpitg.y; + + const int tid = tpitg.y; // 0...16 + const int il = tid/4; // 0...3 + const int ir = tid%4; // 0...3 + const int ip = il/2; // 0 or 1 + const int shift1 = 4*(il%2);// 0 or 4 + const int shift2 = shift1+2;// 2 or 6 + const int n = 8; + const int is = 4*il + (n*ir)/16; + + const int y_offset = 64*il + n*ir; + const int q_offset = 32*ip + n*ir; + + sum[ith] = 0.0f; + + float sumf = 0; + for (int i = tpitg.x; i < nb; i += tptg.x) { + + device const uint8_t * q = x[i].qs + q_offset; + device const uint8_t * scales = x[i].scales + is; + + uint8_t d1 = scales[0] & 0xF; + uint8_t d2 = scales[2] & 0xF; + uint8_t m1 = scales[0] >> 4; + uint8_t m2 = scales[2] >> 4; + + device const float * y = yy + i*QK_K + y_offset; + + //float4 s = {0.f, 0.f, 0.f, 0.f}; + float2 s = {0.f, 0.f}; + float smin = 0; + for (int l = 0; l < n; ++l) { + s[0] += y[l+ 0] * ((q[l] >> shift1) & 3); + s[1] += y[l+32] * ((q[l] >> shift2) & 3); + smin += y[l+ 0] * m1 + y[l+32] * m2; + } + + const float dall = (float)x[i].d; + const float dmin = (float)x[i].dmin; + + sumf += dall * (s[0] * d1 + s[1] * d2) - dmin * smin; + + } + sum[ith] = sumf; + + //int mask1 = (ith%4 == 0); + //int mask2 = (ith%16 == 0); + + //threadgroup_barrier(mem_flags::mem_threadgroup); + //for (int i = 1; i < 4; ++i) sum[ith] += mask1 * sum[ith + i]; + //threadgroup_barrier(mem_flags::mem_threadgroup); + //for (int i = 4; i < 16; i += 4) sum[ith] += mask2 * sum[ith + i]; + //threadgroup_barrier(mem_flags::mem_threadgroup); + //if (ith == 0) { + // for (int i = 16; i < nth; i += 16) sum[0] += sum[i]; + // dst[r1*ne0 + r0] = sum[0]; + //} + + // + // Accumulate the sum from all threads in the threadgroup + // This version is slightly faster than the commented out one below, + // which I copy-pasted from ggerganov's q4_0 dot product for metal. + // + threadgroup_barrier(mem_flags::mem_threadgroup); + if (ith%4 == 0) { + for (int i = 1; i < 4; ++i) sum[ith] += sum[ith + i]; + } + threadgroup_barrier(mem_flags::mem_threadgroup); + if (ith%16 == 0) { + for (int i = 4; i < 16; i += 4) sum[ith] += sum[ith + i]; + } + threadgroup_barrier(mem_flags::mem_threadgroup); + if (ith == 0) { + for (int i = 16; i < nth; i += 16) sum[0] += sum[i]; + dst[r1*ne0 + r0] = sum[0]; + } +} + +kernel void kernel_mul_mat_q3_k_f32( + device const void * src0, + device const float * src1, + device float * dst, + constant int64_t & ne00, + constant int64_t & ne10, + constant int64_t & ne0, + constant int64_t & ne1, + threadgroup float * sum [[threadgroup(0)]], + uint2 tgpig[[threadgroup_position_in_grid]], + uint2 tpitg[[thread_position_in_threadgroup]], + uint2 tptg[[threads_per_threadgroup]]) { + + const uint16_t kmask1 = 0x0303; + const uint16_t kmask2 = 0x0f0f; + + const uint8_t m3 = 3; + const int8_t m4 = 4; + + const int nb = ne00/QK_K; + + const int64_t r0 = tgpig.x; + const int64_t r1 = tgpig.y; + + device const block_q3_k * x = (device const block_q3_k *) src0 + r0*nb; + device const float * yy = (device const float *) src1 + r1*ne10; + + const int nth = tptg.x*tptg.y; + const int ith = tptg.y*tpitg.x + tpitg.y; + + const int tid = tpitg.y; // expecting 16 + const int ip = tid/8; // 0 or 1 + const int il = tid/2 - 4*ip; // 0...3 + const int ir = tid%2; + const int n = 8; + const int l0 = n*ir; + + const uint8_t m = 1 << (4*ip + il); + + const int shift = 2*il; + + const uint16_t s_shift1 = 4*ip; + const uint16_t s_shift2 = s_shift1 + 2*(il/2); + const int ik = 4 + (il%2); + + const int q_offset = 32*ip + l0; + const int y_offset = 128*ip + 32*il + l0; + + //float sumf = 0; + float sumf1 = 0, sumf2 = 0; + for (int i = tpitg.x; i < nb; i += tptg.x) { + + const float d_all = (float)(x[i].d); + + device const uint8_t * q = x[i].qs + q_offset; + device const uint8_t * h = x[i].hmask + l0; + device const float * y = yy + i * QK_K + y_offset; + + device const uint16_t * a = (device const uint16_t *)x[i].scales; + const char2 scales = as_type((uint16_t)(((a[il] >> s_shift1) & kmask2) | (((a[ik] >> s_shift2) & kmask1) << 4))); + + float s = 0; + for (int l = 0; l < n; ++l) { + s += y[l+ 0] * ((int8_t)((q[l+ 0] >> shift) & m3) - ((h[l+ 0] & m) ? 0 : m4)); + } + float d = d_all * s; + sumf1 += d * scales[0]; + sumf2 += d; + //sumf += d_all * s * (scales[0] - 32); + + s = 0; + for (int l = 0; l < n; ++l) { + s += y[l+16] * ((int8_t)((q[l+16] >> shift) & m3) - ((h[l+16] & m) ? 0 : m4)); + } + d = d_all * s; + sumf1 += d * scales[1]; + sumf2 += d; + //sumf += d_all * s * (scales[1] - 32); + + } + + //sum[ith] = sumf; + sum[ith] = sumf1 - 32.f*sumf2; + + // + // Accumulate the sum from all threads in the threadgroup + // + threadgroup_barrier(mem_flags::mem_threadgroup); + if (ith%4 == 0) { + for (int i = 1; i < 4; ++i) sum[ith] += sum[ith + i]; + } + threadgroup_barrier(mem_flags::mem_threadgroup); + if (ith%16 == 0) { + for (int i = 4; i < 16; i += 4) sum[ith] += sum[ith + i]; + } + threadgroup_barrier(mem_flags::mem_threadgroup); + if (ith == 0) { + for (int i = 16; i < nth; i += 16) sum[0] += sum[i]; + dst[r1*ne0 + r0] = sum[0]; + } + +} + +kernel void kernel_mul_mat_q4_k_f32( + device const void * src0, + device const float * src1, + device float * dst, + constant int64_t & ne00, + constant int64_t & ne10, + constant int64_t & ne0, + threadgroup float * sum [[threadgroup(0)]], + uint2 tgpig[[threadgroup_position_in_grid]], + uint2 tpitg[[thread_position_in_threadgroup]], + uint2 tptg[[threads_per_threadgroup]]) { + + const uint16_t kmask1 = 0x3f3f; + const uint16_t kmask2 = 0x0f0f; + const uint16_t kmask3 = 0xc0c0; + + const int nb = ne00/QK_K; + + const int64_t r0 = tgpig.x; + const int64_t r1 = tgpig.y; + + device const block_q4_k * x = (device const block_q4_k *) src0 + r0*nb; + device const float * yy = (device const float *) src1 + r1*ne10; + + const int nth = tptg.x*tptg.y; + const int ith = tptg.y*tpitg.x + tpitg.y; + + const int tid = tpitg.y; // 0...16 + const int il = tid/4; // 0...3 + const int ir = tid - 4*il;// 0...3 + const int n = 4; + + const int im = il/2; // 0 or 1. 0 computes 0,32 + 128,160, 1 computes 64,96 + 192,224 + const int in = il%2; + + const int l0 = n*(2*ir + in); + const int q_offset = 32*im + l0; + const int y_offset = 64*im + l0; + + sum[ith] = 0.0f; + + uchar2 sc1, sc2, sc3, sc4; + + float sumf = 0; + for (int i = tpitg.x; i < nb; i += tptg.x) { + + device const uint8_t * q1 = (x + i)->qs + q_offset; + device const uint8_t * q2 = q1 + 64; + device const float * y1 = yy + i*QK_K + y_offset; + device const float * y2 = y1 + 128; + + const float dall = (float)((x + i)->d); + const float dmin = (float)((x + i)->dmin); + + device const uint16_t * a = (device const uint16_t *)(x + i)->scales; + sc1 = as_type((uint16_t)(a[im+0] & kmask1)); + sc2 = as_type((uint16_t)(a[im+2] & kmask1)); + sc3 = as_type((uint16_t)(((a[im+4] >> 0) & kmask2) | ((a[im+0] & kmask3) >> 2))); + sc4 = as_type((uint16_t)(((a[im+4] >> 4) & kmask2) | ((a[im+2] & kmask3) >> 2))); + + float4 s = {0.f, 0.f, 0.f, 0.f}; + float smin = 0; + for (int l = 0; l < n; ++l) { + + s[0] += y1[l] * (q1[l] & 0xF); s[1] += y1[l+32] * (q1[l] >> 4); + s[2] += y2[l] * (q2[l] & 0xF); s[3] += y2[l+32] * (q2[l] >> 4); + smin += y1[l] * sc2[0] + y1[l+32] * sc2[1] + y2[l] * sc4[0] + y2[l+32] * sc4[1]; + + } + sumf += dall * (s[0] * sc1[0] + s[1] * sc1[1] + s[2] * sc3[0] + s[3] * sc3[1]) - dmin * smin; + + } + + sum[ith] = sumf; + + // + // Accumulate the sum from all threads in the threadgroup + // This version is slightly faster than the commented out one below, + // which I copy-pasted from ggerganov's q4_0 dot product for metal. + // + threadgroup_barrier(mem_flags::mem_threadgroup); + if (ith%4 == 0) { + for (int i = 1; i < 4; ++i) sum[ith] += sum[ith + i]; + } + threadgroup_barrier(mem_flags::mem_threadgroup); + if (ith%16 == 0) { + for (int i = 4; i < 16; i += 4) sum[ith] += sum[ith + i]; + } + threadgroup_barrier(mem_flags::mem_threadgroup); + if (ith == 0) { + for (int i = 16; i < nth; i += 16) sum[0] += sum[i]; + dst[r1*ne0 + r0] = sum[0]; + } + + //// accumulate the sum from all threads in the threadgroup + //threadgroup_barrier(mem_flags::mem_threadgroup); + //for (uint i = nth/2; i > 0; i /= 2) { + // if (ith < i) { + // sum[ith] += sum[ith + i]; + // } + // threadgroup_barrier(mem_flags::mem_threadgroup); + //} + + //if (ith == 0) { + // dst[r1*ne0 + r0] = sum[0]; + //} +} + +kernel void kernel_mul_mat_q5_k_f32( + device const void * src0, + device const float * src1, + device float * dst, + constant int64_t & ne00, + constant int64_t & ne10, + constant int64_t & ne0, + threadgroup float * sum [[threadgroup(0)]], + uint2 tgpig[[threadgroup_position_in_grid]], + uint2 tpitg[[thread_position_in_threadgroup]], + uint2 tptg[[threads_per_threadgroup]]) { + + const uint16_t kmask1 = 0x3f3f; + const uint16_t kmask2 = 0x0f0f; + const uint16_t kmask3 = 0xc0c0; + + const int nb = ne00/QK_K; + + const int64_t r0 = tgpig.x; + const int64_t r1 = tgpig.y; + + device const block_q5_k * x = (device const block_q5_k *) src0 + r0*nb; + device const float * yy = (device const float *) src1 + r1*ne10; + + const int nth = tptg.x*tptg.y; + const int ith = tptg.y*tpitg.x + tpitg.y; + + const int tid = tpitg.y; // 0...16 + const int il = tid/4; // 0...3 + const int ir = tid - 4*il;// 0...3 + const int n = 4; + + const int im = il/2; // 0 or 1. 0 computes 0,32 + 128,160, 1 computes 64,96 + 192,224 + const int in = il%2; + + const int l0 = n*(2*ir + in); + const int q_offset = 32*im + l0; + const int y_offset = 64*im + l0; + + const uint8_t hm1 = 1u << (2*im); + const uint8_t hm2 = hm1 << 1; + const uint8_t hm3 = hm1 << 4; + const uint8_t hm4 = hm2 << 4; + + uchar2 sc1, sc2, sc3, sc4; + + float sumf = 0; + for (int i = tpitg.x; i < nb; i += tptg.x) { + + device const uint8_t * q1 = (x + i)->qs + q_offset; + device const uint8_t * q2 = q1 + 64; + device const uint8_t * qh = (x + i)->qh + l0; + device const float * y1 = yy + i*QK_K + y_offset; + device const float * y2 = y1 + 128; + + const float dall = (float)((x + i)->d); + const float dmin = (float)((x + i)->dmin); + + device const uint16_t * a = (device const uint16_t *)(x + i)->scales; + sc1 = as_type((uint16_t)(a[im+0] & kmask1)); + sc2 = as_type((uint16_t)(a[im+2] & kmask1)); + sc3 = as_type((uint16_t)(((a[im+4] >> 0) & kmask2) | ((a[im+0] & kmask3) >> 2))); + sc4 = as_type((uint16_t)(((a[im+4] >> 4) & kmask2) | ((a[im+2] & kmask3) >> 2))); + + float4 s = {0.f, 0.f, 0.f, 0.f}; + float smin = 0; + for (int l = 0; l < n; ++l) { + + s[0] += y1[l+ 0] * ((q1[l] & 0xF) + (qh[l] & hm1 ? 16 : 0)); + s[1] += y1[l+32] * ((q1[l] >> 4) + (qh[l] & hm2 ? 16 : 0)); + s[2] += y2[l+ 0] * ((q2[l] & 0xF) + (qh[l] & hm3 ? 16 : 0)); + s[3] += y2[l+32] * ((q2[l] >> 4) + (qh[l] & hm4 ? 16 : 0)); + smin += y1[l] * sc2[0] + y1[l+32] * sc2[1] + y2[l] * sc4[0] + y2[l+32] * sc4[1]; + + } + sumf += dall * (s[0] * sc1[0] + s[1] * sc1[1] + s[2] * sc3[0] + s[3] * sc3[1]) - dmin * smin; + + } + sum[ith] = sumf; + + // + // Accumulate the sum from all threads in the threadgroup + // + threadgroup_barrier(mem_flags::mem_threadgroup); + if (ith%4 == 0) { + sum[ith] += sum[ith+1] + sum[ith+2] + sum[ith+3]; + } + threadgroup_barrier(mem_flags::mem_threadgroup); + if (ith%16 == 0) { + sum[ith] += sum[ith+4] + sum[ith+8] + sum[ith+12]; + } + threadgroup_barrier(mem_flags::mem_threadgroup); + if (ith == 0) { + for (int i = 16; i < nth; i += 16) sum[0] += sum[i]; + dst[r1*ne0 + r0] = sum[0]; + } + +} + +kernel void kernel_mul_mat_q6_k_f32( + device const void * src0, + device const float * src1, + device float * dst, + constant int64_t & ne00, + constant int64_t & ne10, + constant int64_t & ne0, + threadgroup float * sum [[threadgroup(0)]], + uint2 tgpig[[threadgroup_position_in_grid]], + uint2 tpitg[[thread_position_in_threadgroup]], + uint2 tptg[[threads_per_threadgroup]]) { + + const uint8_t kmask1 = 0x03; + const uint8_t kmask2 = 0x0C; + const uint8_t kmask3 = 0x30; + const uint8_t kmask4 = 0xC0; + + const int nb = ne00/QK_K; + + const int64_t r0 = tgpig.x; + const int64_t r1 = tgpig.y; + + device const block_q6_k * x = (device const block_q6_k *) src0 + r0*nb; + device const float * yy = (device const float *) src1 + r1*ne10; + + const int nth = tptg.x*tptg.y; + const int ith = tptg.y*tpitg.x + tpitg.y; + + // Note: we absolutely assume that tptg.y = 16 and QK_K = 256! + const int iqs = 16 * tpitg.y; + const int ip = iqs / 128; // 0 or 1 + const int il = (iqs - 128*ip)/16; // 0...7 + const int n = 4; + const int l0 = n*il; + const int is = 8*ip + l0/16; + + const int y_offset = 128*ip + l0; + const int q_offset_l = 64*ip + l0; + const int q_offset_h = 32*ip + l0; + + float sumf = 0; + for (int i = tpitg.x; i < nb; i += tptg.x) { + + device const uint8_t * ql = x[i].ql + q_offset_l; + device const uint8_t * qh = x[i].qh + q_offset_h; + device const int8_t * sc = x[i].scales + is; + + device const float * y = yy + i * QK_K + y_offset; + + const float dall = x[i].d; + + float4 sums = {0.f, 0.f, 0.f, 0.f}; + for (int l = 0; l < n; ++l) { + sums[0] += y[l+ 0] * ((int8_t)((ql[l+ 0] & 0xF) | ((qh[l] & kmask1) << 4)) - 32); + sums[1] += y[l+32] * ((int8_t)((ql[l+32] & 0xF) | ((qh[l] & kmask2) << 2)) - 32); + sums[2] += y[l+64] * ((int8_t)((ql[l+ 0] >> 4) | ((qh[l] & kmask3) << 0)) - 32); + sums[3] += y[l+96] * ((int8_t)((ql[l+32] >> 4) | ((qh[l] & kmask4) >> 2)) - 32); + } + + sumf += dall * (sums[0] * sc[0] + sums[1] * sc[2] + sums[2] * sc[4] + sums[3] * sc[6]); + + } + + sum[ith] = sumf; + + // + // Accumulate the sum from all threads in the threadgroup + // + threadgroup_barrier(mem_flags::mem_threadgroup); + if (ith%4 == 0) { + for (int i = 1; i < 4; ++i) sum[ith] += sum[ith + i]; + } + threadgroup_barrier(mem_flags::mem_threadgroup); + if (ith%16 == 0) { + for (int i = 4; i < 16; i += 4) sum[ith] += sum[ith + i]; + } + threadgroup_barrier(mem_flags::mem_threadgroup); + if (ith == 0) { + for (int i = 16; i < nth; i += 16) sum[0] += sum[i]; + dst[r1*ne0 + r0] = sum[0]; + } + +} diff --git a/LLama/runtimes/libllama.dylib b/LLama/runtimes/libllama.dylib index e0678e1c99962a8bc10658aec31fae60e06b5ad2..4aaf149ea4fad0dd50df31f73730f916e3012505 100755 GIT binary patch delta 146494 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

%jlS=x5 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 delta 119310 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