Skip to content

Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.

3.5 KB
Raw Blame
#include "textflag.h"

// The kernels here use SSE2 only, which every amd64 has.

// func dot4sse(a, b *int8, k int, out *[4]int32)
// out[j] = Σ a[i]*b[j*k+i] for i < k, k a multiple of 16.
TEXT ·dot4sse(SB), NOSPLIT, $0-32
	MOVQ a+0(FP), BX
	MOVQ b+8(FP), SI
	MOVQ k+16(FP), DX
	MOVQ out+24(FP), DI
	LEAQ (SI)(DX*1), R8
	LEAQ (R8)(DX*1), R9
	LEAQ (R9)(DX*1), R10
	PXOR X8, X8
	PXOR X9, X9
	PXOR X10, X10
	PXOR X11, X11
	XORQ CX, CX
	TESTQ DX, DX
	JEQ  ddone
dloop:
	MOVOU (BX)(CX*1), X1
	MOVO  X1, X2
	PUNPCKLBW X1, X1
	PUNPCKHBW X2, X2
	PSRAW $8, X1
	PSRAW $8, X2
	MOVOU (SI)(CX*1), X3
	MOVO  X3, X4
	PUNPCKLBW X3, X3
	PUNPCKHBW X4, X4
	PSRAW $8, X3
	PSRAW $8, X4
	PMADDWL X1, X3
	PMADDWL X2, X4
	PADDL X3, X8
	PADDL X4, X8
	MOVOU (R8)(CX*1), X3
	MOVO  X3, X4
	PUNPCKLBW X3, X3
	PUNPCKHBW X4, X4
	PSRAW $8, X3
	PSRAW $8, X4
	PMADDWL X1, X3
	PMADDWL X2, X4
	PADDL X3, X9
	PADDL X4, X9
	MOVOU (R9)(CX*1), X3
	MOVO  X3, X4
	PUNPCKLBW X3, X3
	PUNPCKHBW X4, X4
	PSRAW $8, X3
	PSRAW $8, X4
	PMADDWL X1, X3
	PMADDWL X2, X4
	PADDL X3, X10
	PADDL X4, X10
	MOVOU (R10)(CX*1), X3
	MOVO  X3, X4
	PUNPCKLBW X3, X3
	PUNPCKHBW X4, X4
	PSRAW $8, X3
	PSRAW $8, X4
	PMADDWL X1, X3
	PMADDWL X2, X4
	PADDL X3, X11
	PADDL X4, X11
	ADDQ $16, CX
	CMPQ CX, DX
	JLT  dloop
ddone:
	PSHUFD $0x4e, X8, X0
	PADDL  X0, X8
	PSHUFD $0xb1, X8, X0
	PADDL  X0, X8
	MOVQ   X8, AX
	MOVL   AX, 0(DI)
	PSHUFD $0x4e, X9, X0
	PADDL  X0, X9
	PSHUFD $0xb1, X9, X0
	PADDL  X0, X9
	MOVQ   X9, AX
	MOVL   AX, 4(DI)
	PSHUFD $0x4e, X10, X0
	PADDL  X0, X10
	PSHUFD $0xb1, X10, X0
	PADDL  X0, X10
	MOVQ   X10, AX
	MOVL   AX, 8(DI)
	PSHUFD $0x4e, X11, X0
	PADDL  X0, X11
	PSHUFD $0xb1, X11, X0
	PADDL  X0, X11
	MOVQ   X11, AX
	MOVL   AX, 12(DI)
	RET

// func scoresT(q, kt *float32, np int, out *float32)
// out[u] = Σ q[i]*kt[i*np+u] for i < 32, u < np, np a multiple of 16.
TEXT ·scoresT(SB), NOSPLIT, $0-32
	MOVQ q+0(FP), SI
	MOVQ kt+8(FP), BX
	MOVQ np+16(FP), DX
	MOVQ out+24(FP), DI
	MOVQ DX, R8
	SHLQ $2, R8 // a row of kt in bytes
	TESTQ DX, DX
	JEQ  tdone
tblock:
	XORPS X0, X0
	XORPS X1, X1
	XORPS X2, X2
	XORPS X3, X3
	MOVQ SI, R9
	MOVQ BX, R10
	MOVQ $32, CX
trow:
	MOVSS  (R9), X4
	SHUFPS $0, X4, X4
	MOVUPS (R10), X5
	MOVUPS 16(R10), X6
	MOVUPS 32(R10), X7
	MOVUPS 48(R10), X8
	MULPS  X4, X5
	MULPS  X4, X6
	MULPS  X4, X7
	MULPS  X4, X8
	ADDPS  X5, X0
	ADDPS  X6, X1
	ADDPS  X7, X2
	ADDPS  X8, X3
	ADDQ   $4, R9
	ADDQ   R8, R10
	DECQ   CX
	JNE    trow
	MOVUPS X0, (DI)
	MOVUPS X1, 16(DI)
	MOVUPS X2, 32(DI)
	MOVUPS X3, 48(DI)
	ADDQ $64, DI
	ADDQ $64, BX
	SUBQ $16, DX
	JNE  tblock
tdone:
	RET

// func mix32(c, p, v *float32, n int)
// c[i] += Σ p[u]*v[u*32+i] for u < n, i < 32.
TEXT ·mix32(SB), NOSPLIT, $0-32
	MOVQ c+0(FP), DI
	MOVQ p+8(FP), SI
	MOVQ v+16(FP), DX
	MOVQ n+24(FP), CX
	MOVUPS (DI), X0
	MOVUPS 16(DI), X1
	MOVUPS 32(DI), X2
	MOVUPS 48(DI), X3
	MOVUPS 64(DI), X4
	MOVUPS 80(DI), X5
	MOVUPS 96(DI), X6
	MOVUPS 112(DI), X7
	TESTQ CX, CX
	JEQ  mdone
mloop:
	MOVSS  (SI), X15
	SHUFPS $0, X15, X15
	MOVUPS 0(DX), X8
	MULPS  X15, X8
	ADDPS  X8, X0
	MOVUPS 16(DX), X9
	MULPS  X15, X9
	ADDPS  X9, X1
	MOVUPS 32(DX), X8
	MULPS  X15, X8
	ADDPS  X8, X2
	MOVUPS 48(DX), X9
	MULPS  X15, X9
	ADDPS  X9, X3
	MOVUPS 64(DX), X8
	MULPS  X15, X8
	ADDPS  X8, X4
	MOVUPS 80(DX), X9
	MULPS  X15, X9
	ADDPS  X9, X5
	MOVUPS 96(DX), X8
	MULPS  X15, X8
	ADDPS  X8, X6
	MOVUPS 112(DX), X9
	MULPS  X15, X9
	ADDPS  X9, X7
	ADDQ $4, SI
	ADDQ $128, DX
	DECQ CX
	JNE  mloop
mdone:
	MOVUPS X0, (DI)
	MOVUPS X1, 16(DI)
	MOVUPS X2, 32(DI)
	MOVUPS X3, 48(DI)
	MOVUPS X4, 64(DI)
	MOVUPS X5, 80(DI)
	MOVUPS X6, 96(DI)
	MOVUPS X7, 112(DI)
	RET