一根細管喂一大片乘法器 左邊寫著每個 token 要讀 16 GB 權重、乘法器只有 0.3% 在忙。右邊是一摞視訊記憶體晶片,透過一根細管把權重送進一塊大晶片;晶片上密密麻麻的計算單元裡只有零星幾個亮著。 16 GB 每個 token 讀一遍 0.3% 的乘法器在忙

用 GPU 跑一個 80 億引數的模型,比如 Llama 3.1 8B,只給一個人用,一塊 H100 每秒大約能吐出 140 個 token1。生成一個 token,模型要做大約 160 億次浮點運算(每個引數一次乘法一次加法),一秒 140 個就是 2.2 萬億次。H100 的標稱算力是每秒 989 萬億次2。

兩個數一除,不到 0.3%。也就是說,這塊三萬美元的卡,在給一個人寫字的時候,絕大部分乘法器是閒著的。

這就讓人想問:GPU 是為各種計算設計的通用晶片,如果我們只跑 Transformer,能不能為它專門搭一塊電路?FPGA 正好能搭出任意電路,而且不用去流片。這樣一塊專用電路,會不會更快、更省電、更便宜?它又會卡在哪裡?

一、推理時晶片在等什麼

現象:算力用不滿

先弄清楚那 99.7% 的乘法器為什麼閒著。大模型生成文字分兩段:先把使用者的整段輸入一次性算完(prefill),然後一個 token 一個 token 地往外寫(decode)。我們和模型聊天時看到的“逐字往外蹦”,就是 decode。

decode 每寫一個 token,都要讓這個 token 依次穿過模型的每一層,每一層都要用到這一層的全部權重。80 億個引數,每個用 16 位浮點存,一共 16 GB。所以每生成一個 token,晶片就要把 16 GB 的權重從視訊記憶體裡完整地讀一遍,而讀進來的每個引數只參與一次乘法和一次加法。

decode 一個 token 時,資料從視訊記憶體流到計算單元 左邊是視訊記憶體裡的 16 GB 權重,每生成一個 token 要全部讀一遍;中間是 3.35 TB/s 的頻寬;右邊是 989 TFLOPS 的計算單元。讀權重要 4.8 毫秒,計算只要 0.016 毫秒,乘法器忙碌的時間約 0.3%。 視訊記憶體 · HBM3 80 GB 計算單元 · H100 SXM 3.35 TB/s 每個 token 一趟 權重 Llama 3.1 8B 引數量80 億 精度FP16 · 2 位元組 大小16 GB 每個 token全部讀一遍 生成 1 個 token 批大小 1 乘加16 GFLOP 讀權重用時4.8 ms 計算用時0.016 ms 乘法器忙碌約 0.3% 上限:3.35 TB/s ÷ 16 GB ≈ 209 token/s 晶片每讀 1 位元組能算 295 次 decode 只用得上 1 次
圖 1 · 批大小為 1 時,生成一個 token 的時間幾乎全花在讀權重上,乘法器 99% 以上的時間在等資料

圖 1 把賬算了出來。H100 的視訊記憶體頻寬是 3.35 TB/s,讀完 16 GB 要 4.8 毫秒;而 160 億次運算,按 989 TFLOPS 算只要 0.016 毫秒。這塊晶片的“算力 ÷ 頻寬”約為 295,意思是每從視訊記憶體讀進 1 個位元組,它有能力做 295 次運算;decode 卻只給了它 1 次。所以單使用者 decode 的速度上限由頻寬決定:3.35 TB/s ÷ 16 GB ≈ 209 token/s,實際能做到的一百二三十到一百四十,就是頻寬用到了六七成。

原因:讀一遍權重,只服務了一個 token

問題不在乘法器不夠快,而在讀進來的每個權重只用了一次。這件事有一個直接的推論:如果同一時刻有很多使用者,每人都要生成下一個 token,那麼讀一遍權重,就可以讓這些 token 一起用。讀權重的時間不變,產出卻翻了很多倍。這就是推理服務裡的“批處理”(batching)。

我們在一臺 4 核的 CPU 機器上模擬了這件事3。取一個 512 MB 的權重矩陣(遠大於 CPU 快取),分別乘上 1 個、2 個……512 個 token 的啟用向量,看完成一次要多久。

同一個 512 MB 的權重矩陣,一次乘上 B 個 token(4 核 Xeon,numpy)
批大小 B一次用時等效 token/s等效讀權重頻寬
112.8 ms7841.8 GB/s
426.5 ms15120.3 GB/s
1628.7 ms55818.7 GB/s
6447.5 ms134711.3 GB/s
256134.5 ms19034.0 GB/s

B=1 時 numpy 走的是矩陣 × 向量的專門路徑,頻寬用得最好;B≥2 換成矩陣 × 矩陣的路徑,所以 B=2 到 16 的用時差不多,都是 26–29 ms。

表 1 · 批大小從 4 漲到 16,用時幾乎不變,產出翻了近 4 倍:讀一遍權重的成本被多個 token 分攤了

表 1 裡最值得看的是 B 從 4 到 16 那一段:一次的用時從 26.5 毫秒只漲到 28.7 毫秒,產出卻從每秒 151 個 token 漲到 558 個。再往後,計算量追上來了,用時才開始明顯增加,到 256 時 CPU 已經主要在算而不是在等。GPU 上是同樣的規律,只是拐點更靠後:H100 每讀 1 位元組能算 295 次,批要到一兩百才會被算力卡住。

這就是 GPU 服務大模型的基本做法:把很多使用者的請求拼成一批,讓那 99% 閒著的乘法器忙起來。可是批處理只解決了“很多人同時用”的情況。對一個使用者來說,他的下一個 token 必須等上一個 token 算完,批再大也幫不了他的延遲。

那麼,如果不靠批處理,而是從電路本身下手,能把這一個使用者的 token 做得更快、更省嗎?

二、專用電路能省在哪裡

通用處理器為“通用”付的錢

要回答這個問題,先得知道一塊晶片的能量花在了哪裡。Horowitz 在 2014 年 ISSCC 的主題報告裡,把 45 nm 工藝下各種操作的能耗擺在一起比較4,結果如圖 2。

一次操作的能耗(45 nm) 對數刻度。一次加法或乘法幾 pJ,一級快取取數約 20 pJ,處理器執行一條指令的額外開銷約 70 pJ,從 DRAM 取一次資料 1000 到 2000 pJ。後兩項用強調色標出。 一次操作要花多少能量 · 45 nm · 對數刻度 1 pJ 10 pJ 100 pJ 1 nJ 10 nJ 一次加法或乘法 幾 pJ 一級快取取一次數 20 pJ 執行一條指令的開銷 70 pJ 從 DRAM 取一次數 1–2 nJ 強調色兩項:一項為“可程式設計”付,一項為“資料在晶片外面”付。專用電路主要省這兩筆。
圖 2 · 真正做運算的那一下只要幾 pJ,取指令和從片外取資料要貴一到三個數量級

真正做乘加的那一下,只要幾 pJ。可是在通用處理器上,為了執行這一下,要先取一條指令、譯碼、排程、讀寫暫存器,這些加起來約 70 pJ,是運算本身的十幾倍以上。資料如果不在手邊,要從 DRAM 取,一次就是 1 到 2 nJ,又貴了幾百倍。Horowitz 由此得出一個結論:專用硬體比處理器高效兩到三個數量級,而省下來的主要不是運算,而是指令和資料搬運。

GPU 已經比 CPU 好很多:一條指令驅動幾十個執行緒,Tensor Core 一條指令做一整塊矩陣乘,指令開銷被攤薄了。但前兩節的賬告訴我們,decode 時的大頭是圖 2 最下面那一行:每個 token 都要從視訊記憶體搬 16 GB。

專用電路的三根槓桿

把這些放在一起,一塊只為 Transformer 設計的電路,能在三個地方動手:

  • 去掉指令。 計算的順序在設計電路時就定好了,資料從一個單元直接流到下一個單元,不再取指、譯碼、排程。
  • 位寬按需定。 GPU 的乘法器只有幾種固定位寬。專用電路可以給權重用 4 bit、3 bit,甚至只用 −1、0、+1 三個值,每個權重佔的位元組少了,讀一遍權重的時間就短了,乘法器也跟著變小。
  • 資料不出晶片。 一層算完的中間結果直接送進下一級,不寫回視訊記憶體;如果片上儲存夠大,連權重都放在片上,徹底不用每個 token 去片外搬一趟。

FPGA 正好能把這三件事都做出來:它的查詢表能搭出任意位寬的運算單元,佈線能把單元連成固定的流水線,晶片上還散佈著幾千塊小儲存。那麼,真在 FPGA 上把 Transformer 搭成一條流水線,效果怎麼樣?

三、在 FPGA 上搭一條推理流水線

已經做出來的:FlightLLM

這件事已經有人做了,而且做得相當完整。FlightLLM 是發表在 FPGA 2024 上的一項工作,在一塊 AMD Alveo U280 加速卡上跑 LLaMA2-7B5。U280 是一張資料中心用的 FPGA 卡,帶 8 GB HBM,頻寬 460 GB/s,大約八千美元6。

它基本就是把上一節的三根槓桿都用上了。權重壓到平均 3.5 bit,並做了 N:M 結構化稀疏(每 M 個權重裡只留 N 個非零);注意力也用塊稀疏,只算一部分位置。計算組織成一條按層走的流水線,GPU 上拆成好幾個 kernel 的步驟,在這裡是幾個相鄰的專用單元,啟用在單元之間直接傳(圖 3)。

同一層在 GPU 和 FPGA 上的走法 上半部分是 GPU:QKV 矩陣乘、注意力、輸出投影、FFN 四個 kernel,各自從視訊記憶體讀權重和啟用、再把結果寫回視訊記憶體。下半部分是 FPGA 流水線:HBM 裡的 3.5 bit 權重流進解壓單元,再進稀疏乘加陣列和 softmax/歸一化單元,啟用在單元之間直接傳,不回 HBM。 GPU · 批大小 1:一層拆成幾個 kernel QKV 矩陣乘 注意力 輸出投影 FFN HBM · 權重(16 bit)+ 每一步的中間啟用 每個 kernel 單獨啟動,讀完寫回再交給下一個;A100 上頻寬只用到 28.6%(最佳化後 57.4%) FPGA(FlightLLM,U280)· 一層是一條流水線 HBM 權重流 解壓 3.5 bit→int8 N:M 稀疏乘加 softmax / 歸一化 只有權重從 HBM 流進來,啟用在相鄰單元之間直接傳;HBM 頻寬用到 65.9%
圖 3 · GPU 上一層要分幾趟進出視訊記憶體,FPGA 上一層是一條直通的流水線,頻寬利用率因此更高

圖 3 只是示意,GPU 這邊的運算元融合(比如 FlashAttention)也能把一部分中間結果留在片上,但在批大小為 1 時,GPU 的頻寬確實用得不好:FlightLLM 測到 A100 只用到 28.6%,換上最佳化過的推理框架是 57.4%;它自己在 U280 上是 65.9%。

結果是這樣的:和 V100S 比,FlightLLM 每焦耳能生成的 token 多 6.0 倍;和最佳化過的 A100 比,多 3.8 倍。按“每美元每秒能生成多少 token”算,比 V100S 好 1.8 倍。另一篇在 U280 上做 GPT 推理的工作也得到相近的結論:decode 比 A100 快 1.9 倍,能效高 5.7 倍7。做 FPGA 推理伺服器的 Positron 公司,在 Agilex 7 FPGA 上做出了產品,自稱比 H100 有 3.5 倍的價效比和能效1。

所以第一個問題的答案是肯定的:為 Transformer 搭的 FPGA 流水線,在單使用者 decode 上確實能比 GPU 省幾倍電,單 token 也更便宜。

不足:比的是誰

但仔細看這些對比,會發現兩個問題。

一是 GPU 那一邊用的是 16 位權重,FPGA 這一邊是 3.5 bit。讀一遍權重的位元組數差了四倍多,而 decode 的速度正是由讀多少位元組決定的。如果 GPU 也把權重壓到 4 bit,差距會小很多:FlightLLM 自己列出的 A100 加 INT4 的對照是每秒 196.8 個 token,而它在更新的 Versal VHK158 上是 92.5 個。

二是這些對比幾乎都在批大小為 1 的條件下做。前面看到,批處理是 GPU 服務大模型的基本做法,那才是資料中心裡的常態。

把這兩點都算進去,FPGA 還便宜嗎?

四、頻寬這道牆

原因:FPGA 卡的視訊記憶體頻寬小得多

decode 的速度上限是“頻寬 ÷ 權重位元組數”,那就先比頻寬。U280 的 HBM 是 460 GB/s,新一代的 Alveo V80 是 820 GB/s8,H100 是 3.35 TB/s,差了 4 到 7 倍。FPGA 再怎麼把頻寬用滿,也追不上頻寬本身的差距;它能贏,靠的是把權重壓得更小,而 GPU 也能壓。

批處理一來,差距就更大了。FPGA 卡上的乘法器(DSP)只有一萬個上下,批稍微大一點就被算力卡住;H100 每讀 1 位元組能算 295 次,批到一兩百都還在“等頻寬”的那一段,產出幾乎隨批大小線性增長。

估算:每百萬 token 多少錢

我們按“每一步的用時 = 讀權重的時間和計算時間裡較大的那個”做了一個粗略的估算3,模型是 Llama 3.1 8B。成本只算硬體按三年攤銷加上滿功耗的電費(0.1 美元/度),H100 按三萬美元,FPGA 用廠商標價;頻寬利用率 GPU 取 45%–60%、FPGA 取 65%,算力利用率 GPU 取 50%、FPGA 取 70%。這些都是假設,表 2 看數量級就好。

Llama 3.1 8B decode 的屋頂線估算(只算權重,不算 KV cache)
裝置 · 權重精度token/s焦耳/token美元/百萬 token
批大小 1:一個使用者
H100 · FP161265.62.68
H100 · INT43771.90.89
U280 · 3.5 bit872.61.05
V80 · 4 bit1331.40.79
批大小 64:很多使用者同時用
H100 · FP1680400.0870.042
H100 · INT4241200.0290.014
U280 · 3.5 bit1781.30.51
V80 · 4 bit2850.670.37

功耗按標稱最大值算,FPGA 的實際功耗通常低得多,所以 FPGA 那幾行的焦耳/token 偏保守。FPGA 的算力只按 DSP 每拍一次乘加估算,批到 8 左右就飽和了。

表 2 · 一個使用者時,FPGA 能和 16 位的 GPU 拉開差距,但和同樣壓到 4 bit 的 GPU 差不多;使用者一多,GPU 每 token 的成本低一個數量級

表 2 的上半部分和 FlightLLM 的結論吻合:一個使用者、GPU 用 16 位權重時,FPGA 每百萬 token 便宜一半以上,能耗也低一半。可是一旦 GPU 也用 4 bit,兩邊就差不多了。下半部分才是資料中心真正的賬:64 個使用者同時用,H100 讀一遍權重能產出 64 個 token,每百萬 token 的成本降到一兩分美元,FPGA 卡在自己的算力上,比它貴二三十倍。

這樣看,“FPGA 專用電路降低推理成本”這個說法要加上條件。在一個使用者、對延遲敏感、或者功耗受限的場合(邊緣裝置、機櫃供電緊張的機房),它能贏;在大批次的雲端服務裡,GPU 靠批處理把讀權重的成本攤薄了,FPGA 贏不了。

到這裡,FPGA 的專用電路其實只用上了三根槓桿裡的前兩根:去掉指令、壓低位寬。權重還在片外的 HBM 裡,每個 token 照樣要讀一遍,頻寬牆一點沒動。如果把權重整個搬進晶片裡呢?

五、把權重搬進晶片

片上儲存有多快

FPGA 晶片上散佈著幾千塊小儲存:U280 有 2016 塊 BRAM 和 960 塊 UltraRAM6,每一塊都有自己的讀寫口,每個時鐘週期都能同時出數。按塊數粗略算,片上的總頻寬在 10 TB/s 量級,是它那 460 GB/s HBM 的二十多倍,而且讀片上儲存的能耗比讀片外低一兩個數量級(回看圖 2)。

TerEffic(2025)就是這麼做的9。它用三值權重:每個權重只能是 −1、0 或 +1,5 個權重打包成 8 bit,平均 1.6 bit。乘法也就不需要乘法器了,乘以 +1 是原樣,乘以 −1 是取負,乘以 0 是丟掉,用查詢表搭一個選擇器就夠。這樣兩塊 U280 能把一個 3.7 億引數的模型全部放進片上儲存,單使用者每秒生成 16300 個 token,是前面 7B 模型速度的上百倍。

不足:片上裝不下大模型

問題是,16300 token/s 的是一個 3.7 億引數的小模型,而且要兩塊卡。每塊 U280 的片上儲存大約 41 MB,按 1.6 bit 一個權重,只能裝兩億出頭。圖 4 把幾種晶片的片上容量和幾個模型的大小放在一起。

片上儲存容量和模型大小 對數刻度,單位 MB。晶片:U280 片上約 41 MB,V80 約 84 MB,Groq LPU 一片 230 MB,Cerebras WSE-3 一整片晶圓 44 GB。模型:3.7 億引數三值模型 74 MB,Llama 3.1 8B 四位元 4 GB,Llama 3 70B 四位元 35 GB。 能放下多少權重 · 對數刻度 10 MB 100 MB 1 GB 10 GB 100 GB U280 片上儲存 41 MB V80 片上儲存 84 MB Groq LPU 一片 230 MB Cerebras WSE-3 整片晶圓 44 GB 3.7 億引數 · 三值 74 MB Llama 3.1 8B · 4 bit 4 GB Llama 3 70B · 4 bit 35 GB FPGA 片上只裝得下幾億引數的小模型;80 億引數要麼讀片外 HBM,要麼攤到幾十上百塊晶片上
圖 4 · 片上儲存和模型之間差了兩到三個數量級,只有整片晶圓大小的晶片才裝得下幾十億引數

8B 模型壓到 4 bit 也有 4 GB,是 V80 片上容量的近 50 倍。這不是 FPGA 獨有的難題:專門走“全 SRAM”路線的 Groq,每片也只有 230 MB,演示 Llama 2 70B 用了 576 片10;Cerebras 乾脆把一整片晶圓做成一塊晶片,才有 44 GB 的片上儲存11。權重放在片上,速度確實快,代價是要很多晶片一起扛,每片都要買、都要供電。

片上儲存裝不下,是因為儲存塊本身佔地方。那如果不“存”權重,而是把權重直接做成電路的一部分呢?

六、把權重焊進電路

實驗:權重可改和權重寫死,面積差多少

到目前為止,權重都是“資料”:放在儲存裡,算的時候讀出來,送進乘法器。可推理時權重根本不變,那麼完全可以把它當成常數,直接寫進電路。乘以一個已知的常數,電路能簡單很多:乘以 0 的那根線可以整個刪掉,乘以 +1 就是一根導線,乘以 −1 只要一個取負;乘以 37 這樣的整數,也可以化成幾次移位和加法。

為了看看到底能省多少,我們用開源綜合工具 yosys 做了個實驗3。電路是一個 64 元點積,啟用是 8 位整數;權重分成 8 位、4 位、三值三種,每種又分兩種寫法:一種是權重從埠送進來(可以隨時換,相當於通用電路),一種是寫死成常數(換一組隨機權重各綜合三次)。全部綜合到 Xilinx 7 系列的 6 輸入查詢表上,不用 DSP,只看用了多少個查詢表。每種寫法都先用 Icarus Verilog 隨機模擬了 200 組輸入,結果全對。

64 元點積綜合到 Xilinx 7 系列,用了多少個查詢表(LUT6,不用 DSP)
權重從埠送進來(可改)寫死成常數(3 組隨機權重)省了
8 位整數145294915、5113、4483約 3 倍
4 位整數72712267、2513、2508約 3 倍
三值 −1/0/+12618793、884、844約 3 倍

開源 yosys 綜合出來的面積比廠商工具 Vivado 大,絕對值只作參考,看同一列、同一行之間的比例。

表 3 · 位寬從 8 位降到三值省了 5 倍多,權重從可改變成寫死又省了 3 倍,兩樣疊起來差 17 倍

表 3 裡有兩條線索。豎著看,位寬越小越省:8 位可改要 14529 個查詢表,三值可改只要 2618 個,因為乘法器變成了選擇器。橫著看,寫死的版本都只有可改版本的三分之一左右。圖 5 拿四個輸入畫出了三值的情況。

三值權重:可改的點積和寫死的點積 左邊:x0 到 x3 各接一個選擇器,由 2 位權重暫存器決定選 +x、−x 還是 0,再進一個 3 個加法器的加法樹。右邊:權重寫死為 +1、0、−1、+1,x1 的線被刪掉,x2 只接一個取負,x0 和 x3 直連,加法樹只剩 2 個加法器。 權重可改:每個輸入一個選擇器 權重寫死:w = [+1, 0, −1, +1] x0 x1 x2 x3 選 ±x0/0 · w0 選 ±x1/0 · w1 選 ±x2/0 · w2 選 ±x3/0 · w3 加法樹 3 個加法器 64 元時:2618 個 LUT x0 x1 w = 0:這根線被刪掉 x2 取負 −x2 x3 加法樹 2 個加法器 64 元時:約 840 個 LUT
圖 5 · 權重寫死以後,選擇器和存權重的暫存器都沒了,權重為 0 的輸入連線也一起消失

可改的版本要為每個輸入準備一個選擇器,還要有地方存權重;寫死以後,選擇器消失了,權重為 0 的輸入(我們的隨機權重里約佔三分之一)連線都不用接。這就是“專用”這兩個字能走到的最遠處:電路就是這一個模型,別的什麼都不是。

不足:一個模型要上萬塊 FPGA

可是把這個數放大到真模型上,就看出問題了。三值寫死的點積,平均每個權重大約要 13 個查詢表(840 ÷ 64)。一個 80 億引數的模型,就是大約 1000 億個查詢表;目前最大的 FPGA 之一 VP1902 有 846 萬個,算下來要一萬多塊。哪怕 Vivado 能把面積再壓掉一半,也是幾千塊。

而且這樣的電路算得太“多”了:它在每個時鐘週期把整個模型完整地算一遍,跑在 200 MHz 上,相當於每秒能處理兩億個 token。一個使用者根本用不完。要是讓同一塊電路分時複用,輪流算不同的層,權重就又得存起來、讀出來,又回到了第五節的容量問題。

FPGA 本身的“可程式設計”也有代價。同樣一個電路做在 FPGA 上,面積大約是做成專用晶片(ASIC)的 35 倍(大量用硬核乘法器和儲存塊時能降到 5 倍左右),速度慢三四倍,動態功耗高 14 倍左右12。FPGA 用這些代價換來了“能重新燒寫”,可一塊焊死了模型的電路,恰恰用不上重新燒寫。

解決:交給 ASIC

所以“把模型焊進電路”這條路,最後走向了 ASIC。2026 年初,一家叫 Taalas 的公司釋出了 HC1 晶片,把 Llama 3.1 8B 直接做進了晶片:815 平方毫米、530 億個電晶體,權重用 3 bit 和 6 bit 的混合格式,一張卡約 200 W,廠商稱每個使用者每秒能生成約 17000 個 token13。它的代價也寫得很清楚:這塊晶片只能跑這一個基礎模型,最多加個 LoRA 微調;換模型,就得重新流片。

這裡 FPGA 反而找到了自己的位置。模型結構每半年就變一次(分組注意力、混合專家、新的位置編碼……),直接去流片風險很大,FPGA 正好可以先把架構跑通、拿去賣、收集反饋,再把成熟的設計做成 ASIC。前面提到的 Positron 就是這麼走的:第一代產品 Atlas 用 FPGA,第二代 Asimov 改成自研 ASIC,並說以後都保持“FPGA 先行、ASIC 跟進”的節奏14。

七、回到開頭

開頭那塊 H100,給一個人寫字時不到 0.3% 的乘法器在幹活。現在我們知道,這不是乘法器設計得不好,而是每個 token 都要把 16 GB 權重從視訊記憶體搬一遍,乘法器在等資料。專用電路能做的,就是想辦法不讓它等,而三條路各有各的代價:

  • 讓很多 token 共用一次讀取(批處理):GPU 的做法,成本最低,但幫不了單個使用者的延遲。
  • 讓每次讀取更少、更順(低位寬、稀疏、流水線):FPGA 推理加速器的做法,單使用者時能比 16 位的 GPU 省幾倍電,但卡在 FPGA 卡的視訊記憶體頻寬上。
  • 乾脆不讀(權重放在片上,或者焊進電路):速度能高出一兩個數量級,但晶片要裝得下整個模型,FPGA 只裝得下小模型,大模型要靠成百上千塊晶片或者專門流片。

小結

  1. decode 時晶片在等什麼? 等權重。每生成一個 token 要把全部權重從視訊記憶體讀一遍,每個權重只用一次,單使用者時乘法器 99% 以上的時間閒著。批處理能讓多個 token 共用一次讀取,這是 GPU 服務大模型的基本做法。
  2. 專用電路能省在哪? 運算本身只要幾 pJ,取指令約 70 pJ,從 DRAM 取數 1–2 nJ。專用電路省的是指令和資料搬運:計算順序寫死、位寬按需、資料不出晶片。
  3. FPGA 流水線效果如何? FlightLLM 在 U280 上跑 LLaMA2-7B,3.5 bit 權重加稀疏,頻寬利用率 65.9%,能效是 GPU 的 3.8 到 6 倍,單使用者場景下每 token 也更便宜。
  4. 能降低成本嗎? 要看場景。GPU 也壓到 4 bit 時,單使用者的成本差不多;使用者一多,GPU 靠批處理把成本壓低一個數量級,FPGA 卡在 460–820 GB/s 的視訊記憶體頻寬和一萬個上下的 DSP 上。邊緣、低延遲、功耗受限時 FPGA 有優勢,雲端大批次服務時 GPU 更便宜。
  5. 把權重搬進晶片呢? 片上儲存快得多,3.7 億引數的三值模型在兩塊 U280 上能跑到每秒 16300 個 token,但一塊 FPGA 的片上儲存只裝得下兩億權重左右。
  6. 把權重焊進電路呢? 我們的綜合實驗裡,寫死權重比可改省約 3 倍面積,三值寫死比 8 位可改省 17 倍;但 8B 模型按這樣算要一萬多塊 FPGA。這條路的終點是 ASIC(Taalas HC1),FPGA 適合做它的原型和小模型的載體。

想自己試的話,綜合實驗只需要 yosys 和 Python:gen_dot.py 生成六種點積寫法,run_synth.sh 逐個綜合並統計查詢表,改一下點積長度或權重位寬就能看到面積怎麼變3。

參考資料

參考資料

  1. Positron AtlasBittWarebittware.com ↗Positron 的第一代推理伺服器,用 Intel Agilex 7 M 系列 FPGA(帶 HBM)。廠商稱對 H100 有 3.5 倍的價效比和能效;演示裡 Llama 3.1 8B 在 H100 上約 140 token/s。都是廠商數字。https://www.bittware.com/products/positron-atlas/ ↩ ↩2

  2. NVIDIA H100 Tensor Core GPUNVIDIAnvidia.com ↗H100 SXM:80 GB HBM3,頻寬 3.35 TB/s,BF16 稠密算力約 989 TFLOPS(官網標的 1979 是稀疏數字),功耗最高 700 W。https://www.nvidia.com/en-us/data-center/h100/ ↩

  3. 本文的實驗程式碼與調研筆記/mnt/project-files/fpga-transformer-research/:experiment/batch_bw.py 是批處理實驗,gen_dot.py、run_synth.sh、check_dot.py 是綜合實驗,cost_model.py 是成本估算,輸出在 logs/。yosys 0.33、Icarus Verilog、numpy 2.5,4 核 Xeon。 ↩ ↩2 ↩3 ↩4

  4. Computing's Energy Problem (and what we can do about it)Mark Horowitz · ISSCC 2014ieeexplore.ieee.org ↗正文第 5、6 節:處理器每條指令約 70 pJ 的開銷,一次運算只要幾 pJ;快取取數 20 pJ;DRAM 一次訪問 1–2 nJ;專用硬體比處理器高效 2–3 個數量級。45 nm 工藝。https://ieeexplore.ieee.org/document/6757323 ↩

  5. FlightLLM: Efficient Large Language Model Inference with a Complete Mapping Flow on FPGAsShulin Zeng 等 · FPGA 2024arxiv.org ↗Alveo U280 上跑 LLaMA2-7B,權重平均 3.5 bit、N:M 稀疏,225 MHz,HBM 利用率 65.9%;能效是 V100S 的 6.0 倍、最佳化後 A100 的 3.8 倍,價效比是 V100S 的 1.8 倍(U280 按約 8000 美元算)。https://arxiv.org/abs/2401.03868 ↩

  6. Alveo U280 Data Center Accelerator Card Data Sheet (DS963)AMDdocs.amd.com ↗8 GB HBM2,460 GB/s;約 130 萬個 LUT、9024 個 DSP、2016 塊 BRAM、960 塊 UltraRAM,片上儲存約 41 MB(TerEffic 論文裡寫約 42 MB);最大功耗 225 W。https://docs.amd.com/r/en-US/ds963-u280 ↩ ↩2

  7. Understanding the Potential of FPGA-Based Spatial Acceleration for Large Language Model InferenceHongzheng Chen 等 · ACM TRETS · 2024arxiv.org ↗同樣在 U280 上,GPT 的 decode 比 A100 快 1.9 倍、能效高 5.7 倍。https://arxiv.org/abs/2312.15159 ↩

  8. AMD Alveo V80 Compute AcceleratorAMDamd.com ↗32 GB HBM2e,約 820 GB/s;約 260 萬個 LUT、10848 個 DSP,片上儲存 673 Mb(約 84 MB);TDP 190 W,標價 9495 美元。https://www.amd.com/en/products/accelerators/alveo/v80/a-v80-p64g-pq-g.html ↩

  9. TerEffic: Highly Efficient Ternary LLM Inference on FPGAChenyang Yin 等 · 2025arxiv.org ↗三值權重(每個 −1/0/+1,5 個打包成 8 bit,平均 1.6 bit)。兩塊 U280 把 3.7 億引數模型全部放在片上,單批 16300 token/s;功耗 35.8 W 來自 Vivado 功耗報告,不是實測。HBM 版跑 27 億引數模型 727 token/s,約為 A100 的 3 倍。https://arxiv.org/abs/2502.16473 ↩

  10. A Review on Proprietary Accelerators for Large Language Models2025arxiv.org ↗綜述裡 Groq LPU 的資料:每片 230 MB SRAM,片內頻寬 80 TB/s;跑 Llama 70B 這類模型要幾百片。Groq 演示 Llama 2 70B 用了 576 片。https://arxiv.org/abs/2503.09650 ↩

  11. Cerebras Wafer-Scale Engine 3Cerebrascerebras.ai ↗一整片晶圓做成的晶片,片上 SRAM 44 GB。https://www.cerebras.ai/chip ↩

  12. Measuring the Gap Between FPGAs and ASICsIan Kuon, Jonathan Rose · IEEE TCAD · 2007eecg.utoronto.ca ↗90 nm 工藝:只用 LUT 時 FPGA 面積是 ASIC 的約 35 倍,大量用硬核乘法器和儲存塊時可降到 4.7 倍;速度慢 3.4–4.6 倍;動態功耗約 14 倍。https://www.eecg.utoronto.ca/~jayar/pubs/kuon/kuontcad06.pdf ↩

  13. AI inference cast in silicon: Taalas announces HC1 chipheise online · 2026-02heise.de ↗Llama 3.1 8B 直接做進 TSMC N6 工藝的晶片:815 mm²、530 億電晶體,3 bit / 6 bit 混合格式,約 200 W 一張卡;廠商稱每使用者約 17000 token/s。只能跑這一個基礎模型,可以加 LoRA。https://heise.de/-11185112 ↩

  14. Positron jumps up to the big league investment circleJon Peddie Researchjonpeddie.com ↗Positron 從第一代 FPGA 系統 Atlas 轉向自研 ASIC Asimov,並說以後保持“FPGA 先行、ASIC 跟進”的節奏。https://www.jonpeddie.com/news/positron-jumps-up-to-the-big-league-investment-circle/ ↩