用Common Lisp实现LLM推理引擎：AVX2加速与多线程实战

如果你第一次看到llambda.lisp这个项目名，大概率会产生一个疑问：Common Lisp？LLM 推理引擎？

在多数人对 LLM 推理的印象里，C++、Rust、CUDA 才是主流答案。用一门有几十年历史、以动态与宏著称的 Lisp 方言去做推理引擎，听起来像是“老古董的新冒险”。但仔细拆解项目标题中的定位——Bare-Metal、Multi-Threaded、AVX2-Accelerated——你会发现这并不是随意为之的玩具项目，而是一条把 Lisp 的类型系统、线程能力和底层 SIMD 指令集结合起来的工程路线。

本文不打算复述某个具体项目的源码，而是从“如果要实现这样一个引擎，我们应该考虑哪些问题”的角度，梳理 LLM 推理引擎的完整架构：从精度选择、AVX2 加速原理、多线程切分，到如何用 Common Lisp 写出一个最小的推理引擎骨架。内容偏工程实践，适合正在研究 LLM 推理优化的开发者，也适合对 Common Lisp 高性能计算感兴趣的同学。

1. 从名字说起：llambda.lisp 到底是什么

1.1 一个另类的技术定位

llambda.lisp这个名字本身就有信息量。

开头的ll可以理解成 LLM 的缩写，lambda是 Lisp 最核心的概念，后缀.lisp则直接点明它是一门 Common Lisp 项目。组合起来，这个项目想要表达的意思是：用 Lisp 的函数式抽象承载大语言模型推理。项目标题里的inf eng是 inference engine 的缩写，也就是推理引擎，而不是训练框架。

这类项目的价值，不能简单用“性能是否超过 llama.cpp”来评判。它更像是一种实验性实现：当动态语言与静态性能目标相遇，Lisp 的宏、REPL、类型注解到底能不能支撑起一个贴近硬件的推理引擎？这个回答对很多想扩展 Lisp 应用边界的开发者很有吸引力。

从工程角度看，它也提供了一套很好的“最小推理引擎”学习素材。因为 Common Lisp 没有像 PyTorch 那样庞大的生态，你无法简单地调torch.matmul，所有东西都必须自己搭。

1.2 四个关键词拆解设计路线

可以把标题拆成四个关键词，每个都指向一类技术决策：

其中“Bare-Metal”是一个很关键的信号。在 Lisp 环境中，自动内存管理（GC）是默认行为，但推理引擎一旦处理大矩阵，GC 就会成为性能杀手。因此 Bare-Metal 的思路通常意味着使用静态向量（static-vectors）、预分配内存池，甚至在关键内层循环中规避普通 Lisp 对象的分配，让权重数据与 CPU 缓存、SIMD 寄存器之间形成更直接的路径。

2. LLM 推理引擎的核心问题

2.1 自回归生成的基本链路

大语言模型的推理是典型的自回归过程。给定一串 prompt，模型每次只生成一个 token，再把新生成的 token 拼到输入序列末尾，继续下一轮前向计算，直到遇到结束符或达到最大长度限制。

完整链路如下：

输入文本 -> tokenizer 编码 -> embedding 查表 -> Transformer 层堆叠（LayerNorm + Attention + FFN） -> 最后一层输出 logits -> softmax + 采样 -> 生成一个 token -> 重新输入，循环直到结束

这里有两个核心概念需要区分：

• Prefill（预填充）：输入 prompt 时，一次性处理整段 token，计算量很大。
• Decode（生成）：每轮只处理最后一个 token，计算量相对小，但序列变长后 KV Cache 的读写会成为瓶颈。

一个推理引擎必须同时优化这两种阶段。llambda.lisp这类 CPU 推理引擎，通常面向的是小模型私有化部署、嵌入式场景或教学实验，所以要格外关注内存带宽与矩阵计算效率。

2.2 推理引擎与训练框架的本质差异

很多人会误以为推理引擎只是把 PyTorch 模型换成model.eval()。事实上，推理引擎和训练框架的目标差异非常大：

• 训练注重反向传播、大 batch、高数值精度。
• 推理注重低延迟、高吞吐、显存/内存占用控制。
• 推理时权重不再更新，可以做精度压缩、算子融合、Batch 动态拼接。

因此，推理引擎可以更“激进”地使用半精度、量化、算子融合等优化手段。在精度允许的前提下，FP16、BF16、甚至 int8 量化都是常见选择。

2.3 精度选择：FP32、FP16、BF16 到底怎么选

这是 LLM 推理中最容易被忽略、却最容易出问题的点。尤其是最近社区里关于“LLM 大模型之精度问题（FP16、FP32、BF16）”的讨论很多，这里单独展开。

推理引擎中常见做法是：

• 权重用 BF16 或 FP16 存储，减少内存占用。
• 计算时把中间结果提升到 FP32，避免累加误差。
• LayerNorm、Softmax 这类对精度敏感的操作，通常在 FP32 下计算。
• 如果使用 AVX2 加速，FP16 和 BF16 都不能直接在 256 位寄存器里做原生算术，需要转成 FP32 后计算，或者利用 FMA 指令做近似。

这也是很多 CPU 推理引擎选择“存储半精度、计算单精度”混合方案的原因。llambda.lisp如果走 AVX2 路线，大概率也会采用类似策略。

3. 环境准备：搭建 Common Lisp 高性能计算环境

3.1 为什么推荐 SBCL

Common Lisp 有多个实现，比如 SBCL、CCL、ECL、ABCL。对于高性能计算，SBCL 是目前最主流的推荐：

• 原生代码生成质量高，编译优化选项丰富。
• 线程支持比较成熟，基于sb-thread。
• 社区活跃，Quicklisp 生态覆盖大多数需求。
• 支持内嵌汇编、静态向量、外部函数接口（CFFI），适合 Bare-Metal 风格开发。

版本不需要刻意追求最新，建议以系统稳定发行版为准。本文示例不依赖某个特定版本，重点演示实现思路。

安装 SBCL 很简单，以常见 Linux/macOS 为例：

# Ubuntu / Debian sudo apt install sbcl # macOS brew install sbcl

Windows 下可以下载官方安装包，或者通过 WSL 使用 Linux 环境。

3.2 Quicklisp 与依赖库

Quicklisp 是 Common Lisp 的事实标准包管理器，类似于 Python 的 pip。安装方式在官网文档中都有，这里给出核心步骤：

curl -O https://beta.quicklisp.org/quicklisp.lisp sbcl --load quicklisp.lisp

进入 SBCL REPL 后执行：

(quicklisp-quickstart:install) (ql:add-to-init-file)

完成之后，可以用ql:quickload加载库。

对于本文涉及的推理引擎骨架，比较常用的库有：

本文示例代码以标准 Common Lisp 为主，依赖较少；真正接入硬件加速时，可以再引入上述库。

3.3 验证环境是否可用

安装完成后，在命令行验证：

sbcl --version

然后在 REPL 中运行一段最小测试：

(ql:quickload :static-vectors) (defpackage #:llambda.demo (:use #:cl #:static-vectors)) (in-package #:llambda.demo) (let ((v (make-static-vector 8 :element-type 'single-float :initial-element 0.0))) (setf (static-vector-aref v 0) 1.0) (format t "~a~%" (static-vector-aref v 0)))

如果输出1.0，说明环境正常，静态向量分配可用。这是后面“裸机内存管理”的基础。

4. 核心原理拆解：AVX2、并发与内存布局

4.1 模型推理的数学主体是矩阵乘法

Transformer 的每一层可以分为两部分：

• Attention 部分：对输入做 QKV 线性投影，然后计算注意力权重，再对 Value 加权求和。
• Feed-Forward 部分：两层全连接网络，中间通常接一个激活函数，如 GELU 或 SwiGLU。

无论是x @ W_q、注意力得分Q @ K^T，还是attention_output @ W_o，本质上都是矩阵乘法。因此，矩阵乘法的效率直接决定了推理引擎的吞吐上限。

在自回归 decode 阶段，输入矩阵通常是[1, hidden_size]，虽然单次计算量不大，但每个 token 都要重复执行，且 KV Cache 会越来越大，所以引擎还需要对 attention 的读取模式做专门优化。

4.2 AVX2 指令集到底能带来什么

AVX2 是 x86-64 CPU 上常见的单指令多数据流（SIMD）扩展。它引入了 256 位宽的 YMM 寄存器，一条指令可以同时处理多个浮点或整数数据。

具体到 LLM 推理：

• 一个 YMM 寄存器可以装下 8 个单精度浮点数。
• 一次 FMA（融合乘加）指令可以完成 8 组a*b+c，这是矩阵乘法的核心操作。
• 如果优化得当，比普通标量循环快数倍。

但需要注意，AVX2 并不是万能的：

• FP16 在 AVX2 中没有原生算术指令，需要依赖 F16C 指令在半精度与单精度之间转换。
• BF16 在 AVX2 中同样没有原生乘法指令，真正的原生 BF16 支持要到 AVX512_BF16 才出现。
• 内存对齐非常重要，如果数据没有按 32 字节对齐，性能会明显下降。

因此，llambda.lisp即使标称 AVX2 Accelerated，也很可能只是把关键路径中的单精度浮点循环向量化了，半精度只用于权重存储。

在 Common Lisp 中做 AVX2 加速，通常有三种途径：

1. 在 SBCL 中写内嵌汇编或使用 VOP（虚拟操作符）扩展。
2. 通过 CFFI 调用一个用 C、Rust 或汇编写好 SIMD 内核的小库。
3. 使用sb-simd这类提供 SIMD 数据类型的扩展库。

第一种和第二种更接近“Bare-Metal”，也最容易做出性能；第三种写起来更接近 Lisp 风格，但依赖项目成熟度。

4.3 裸机思维：摆脱 GC 与堆分配

Common Lisp 的自动 GC 对很多业务程序是好事，但对推理引擎来说，大量的临时矩阵分配会导致：

• GC 频繁触发，产生停顿。
• 矩阵数据在堆上移动，破坏内存局部性。
• 缓存失效，SIMD 加载速度下降。

Bare-Metal 思路的核心就是让权重和中间缓冲区脱离 GC 托管。常用手段：

• 使用static-vectors库分配静态内存。
• 在系统初始化时一次性分配所有中间张量的缓冲区。
• 尽量通过预分配的 workspace 池复用中间结果。
• 内层循环中避免创建新的 Lisp 对象，比如不要用cons临时拼接列表。

这听起来像 C 语言风格，但在 Lisp 中同样可以做，只是需要克制地使用动态特性。

4.4 多线程推理的并行粒度

多线程推理需要先想清楚一个问题：并行切在哪里？

常见策略有三种：

在单机 CPU 推理中，Batch 并行比较容易实现，因为每个请求的前向计算相互独立。张量并行则能提高单个请求的吞吐，但需要处理好矩阵切分后的归约与同步。

Common Lisp 中实现多线程，可以使用sb-thread或第三方库lparallel。一个基本思路是：

• 为每个工作线程分配独立的内存 workspace。
• 主线程负责接收请求，将请求分发给工作线程。
• 工作线程完成前向计算后，通过队列或 future 返回结果。
• 共享模型权重是只读的，计算过程中不允许修改权重。

这里的关键教训是：不要在多线程中共享可变张量。每个线程的临时中间矩阵必须独立，否则会出现难以排查的数值错误。

5. 完整实战：用 Common Lisp 写一个最小推理引擎骨架

下面我们搭建一个最小推理引擎骨架。它不是完整可用的llambda.lisp，而是对应其核心设计目标的一个学习版实现。代码重点是：

• 定义矩阵结构和矩阵乘法。
• 展示简化 Transformer 前向的调用方式。
• 展示自回归生成主循环。
• 验证矩阵计算正确性。

5.1 项目结构设计

llambda-demo/ ├── llambda-demo.asd ├── src/ │ ├── matrix.lisp │ ├── model.lisp │ └── infer.lisp └── test/ └── smoke.lisp

.asd文件是 ASDF 系统定义文件，类似于 Rust 的Cargo.toml或 Python 的pyproject.toml。

文件llambda-demo.asd：

(defsystem "llambda-demo" :description "A minimal LLM inference engine skeleton in Common Lisp" :version "0.0.1" :serial t :components ((:module "src" :components ((:file "matrix") (:file "model") (:file "infer")))))

5.2 定义权重张量与矩阵乘法

文件src/matrix.lisp：

(defpackage #:llambda.matrix (:use #:cl) (:export #:mat #:make-mat #:mat-rows #:mat-cols #:mat-data #:matmul #:random-mat #:mat-print)) (in-package #:llambda.matrix) (defstruct mat (rows 0 :type fixnum) (cols 0 :type fixnum) (data nil :type (simple-array single-float (*)))) (defun make-zero-mat (rows cols) (make-mat :rows rows :cols cols :data (make-array (* rows cols) :element-type 'single-float :initial-element 0.0))) (defun random-mat (rows cols) "生成一个随机初始化矩阵，范围在 [-0.1, 0.1]，用于验证计算正确性。" (let ((data (make-array (* rows cols) :element-type 'single-float))) (dotimes (i (* rows cols)) (setf (aref data i) (float (- (random 0.2) 0.1) 0.0))) (make-mat :rows rows :cols cols :data data))) (defun matmul (a b) "矩阵乘法 C = A * B，其中 A 为 m x k，B 为 k x n。" (declare (optimize (speed 3) (safety 1))) (assert (= (mat-cols a) (mat-rows b)) nil "矩阵维度不匹配: A cols=~d, B rows=~d" (mat-cols a) (mat-rows b)) (let* ((m (mat-rows a)) (k (mat-cols a)) (n (mat-cols b)) (data (make-array (* m n) :element-type 'single-float :initial-element 0.0))) (declare (type fixnum m k n) (type (simple-array single-float (*)) data)) (loop for i below m do (loop for p below k for av = (aref (mat-data a) (+ (* i k) p)) do (when (not (zerop av)) (loop for j below n do (incf (aref data (+ (* i n) j)) (* av (aref (mat-data b) (+ (* p n) j)))))))) (make-mat :rows m :cols n :data data))) (defun mat-print (mat) (loop for i below (mat-rows mat) do (format t "~{~a~^ ~}~%" (loop for j below (mat-cols mat) collect (aref (mat-data mat) (+ (* i (mat-cols mat)) j))))))

这段代码是标准的 O(n^3) 矩阵乘法，朴素实现，适合作为正确性参考。真正的性能优化会将最内层循环替换为 AVX2 向量化代码，并利用内存对齐加载data。

5.3 简化 Transformer 前向骨架

文件src/model.lisp：

(defpackage #:llambda.model (:use #:cl) (:import-from #:llambda.matrix #:mat #:matmul #:make-zero-mat #:mat-cols #:mat-rows) (:export #:model #:mlp-forward #:llm-forward)) (in-package #:llambda.model) (defstruct model (w1 nil :type (or null mat)) (w2 nil :type (or null mat))) (defun relu-mat (x) "对矩阵每个元素做 ReLU：max(0, x)。" (let* ((rows (mat-rows x)) (cols (mat-cols x)) (data (mat-data x)) (out (make-zero-mat rows cols))) (dotimes (idx (* rows cols)) (setf (aref (mat-data out) idx) (max 0.0 (aref data idx)))) out)) (defun mlp-forward (model x) "两层 MLP 前向：x -> matmul(x, W1) -> ReLU -> matmul(relu, W2)。" (let* ((hidden (matmul x (model-w1 model))) (activated (relu-mat hidden)) (out (matmul activated (model-w2 model)))) out)) (defun llm-forward (model tokens) "简化 LLM 前向入口。tokens 是一个长度向量，这里仅示意调用链。 实际实现中需要先做 embedding 查表，再逐层执行 LayerNorm、Attention、FFN。" (declare (ignore tokens)) (mlp-forward model (make-zero-mat 1 16)))

这里先用一个两层 MLP 占位，展示前向传播的组织方式。真正的 Transformer 需要加入 embedding、LayerNorm、Multi-Head Attention 和 KV Cache，但整体调用结构是相似的。

5.4 采样器与自回归生成主循环

文件src/infer.lisp：

(defpackage #:llambda.infer (:use #:cl) (:import-from #:llambda.matrix #:mat-rows #:mat-cols #:mat-data) (:export #:generate #:argmax #:sample)) (in-package #:llambda.infer) (defun argmax (data) "返回一维向量或简单数组中最大元素的下标。" (let ((best-idx 0) (best-val (aref data 0))) (loop for i from 1 below (length data) do (when (> (aref data i) best-val) (setf best-idx i best-val (aref data i)))) best-idx)) (defun sample (logits &key (temperature 1.0)) "根据 logits 采样一个 token id。temperature <= 0 时直接取 argmax。" (if (<= temperature 1e-6) (argmax logits) ;; 完整实现应做 softmax 后按概率采样，这里先展示 argmax 路径 (argmax logits))) (defun generate (model tokenizer prompt &key (max-tokens 128)) "自回归生成主循环。 model 是模型结构，tokenizer 需要实现 encode/decode/eos。 这是一个接口骨架，接入真实 tokenizer 后即可跑通完整流程。" (let ((tokens (funcall tokenizer 'encode prompt))) (loop repeat max-tokens for logits = (llm-forward model tokens) for next-id = (sample logits :temperature 0.8) until (= next-id (funcall tokenizer 'eos)) do (setf tokens (append tokens (list next-id)))) (funcall tokenizer 'decode tokens)))

需要说明，这段代码里的llm-forward、tokenizer都是接口占位。重点在于展示自回归循环的组织方式：每轮前向、采样、追加 token。

5.5 接入真实权重的思路

真实推理引擎不会只用随机矩阵。接入真实权重时，需要解决两个问题：

1. 权重文件格式。
2. tokenizer 文件。

目前常见的权重格式有：

• PyTorch 的.bin/.safetensors。
• llama.cpp 的.gguf。
• Hugging Face 的pytorch_model.bin。

在 Common Lisp 项目里，可以通过CFFI调用一个 C 语言解析器读取这些格式，也可以直接用 Lisp 写二进制解析器。safetensors格式本身是 JSON 头 + 二进制数据块，用 Lisp 解析并不困难。

权重读取后，应当复制到static-vectors分配的静态内存中，而不是普通 Lisp 数组。这样矩阵乘法内层循环可以直接使用地址连续、对齐良好的内存。

tokenizer 也是如此，需要把词表文件解析成 Lisp 可用的映射表。如果没有训练工具，也可以先用简单字符级词典测试。

5.6 运行与预期输出

我们先用矩阵乘法验证整个骨架的正确性。在 SBCL REPL 中执行：

(ql:quickload :llambda-demo) (in-package :llambda.matrix) (let ((a (make-mat :rows 2 :cols 3 :data (make-array 6 :element-type 'single-float :initial-contents '(1.0 2.0 3.0 4.0 5.0 6.0)))) (b (make-mat :rows 3 :cols 2 :data (make-array 6 :element-type 'single-float :initial-contents '(7.0 8.0 9.0 10.0 11.0 12.0))))) (mat-print (matmul a b)))

预期输出为：

58.0 64.0 139.0 154.0

这个结果可以手算验证：第一行第一列就是1*7 + 2*9 + 3*11 = 58。

如果这个结果正确，说明矩阵存储和乘法逻辑闭环，后续可以继续扩展更复杂的算子。

6. 常见问题与排查清单

6.1 性能问题排查

SBCL 默认的编译优化偏重安全性和调试性。发布推理引擎时，应该把矩阵运算相关文件的编译策略调整为速度优先：

(declaim (optimize (speed 3) (safety 1) (debug 1)))

6.2 数值精度问题排查

精度问题在推理引擎中非常隐蔽。建议在引入半精度前，先以 FP32 作为基线跑通一个短句子，确认结果一致后再逐步降低精度。

6.3 并发与稳定性问题

多线程排查可以利用 SBCL 的sb-concurrency调试功能，也可以先用少量线程单测验证逻辑，再逐步增加并发度。

6.4 模型加载与内存问题

7. 最佳实践与工程建议

7.1 编译优化：把 SBCL 的代码生成吃透

Common Lisp 程序性能高低，很多时候取决于编译器优化声明。推理引擎的核心文件应当统一配置：

(declaim (optimize (speed 3) (safety 1) (debug 1)))

同时，对热点函数内部的数据类型做声明。比如矩阵乘法的索引变量使用fixnum，数组元素类型声明为single-float，这样 SBCL 能生成更紧凑的原生代码。

但要注意，safety 0虽然能压榨性能，也可能掩盖错误。工程上建议safety 1起步，上线前再评估是否进一步降低。

7.2 内存分配：用静态内存替代自动分配

推理引擎中，一个很实用的经验法则是：**