OpenAI Jalapeño ASIC自研芯片深度解析：辣椒火了——能效1.7倍碾压英伟达，自研推理芯片如何改写AI硬件格局
一、引言：一颗辣椒点燃AI硬件战场
2026年8月25日，OpenAI在Hot Chips大会上公布了其首款自研AI推理芯片Jalapeño（墨西哥辣椒）的首批实测性能数据，瞬间引爆了整个AI圈。Sam Altman在X上轻描淡写地发了一条推文：“我们造了一颗芯片，快得离谱。”
这不是一句玩笑。SemiAnalysis的工程师们亲自钻进OpenAI实验室，用InferenceX基准测试套件跑完了全部测试，给出了一个让整个行业震惊的结论：Jalapeño把此前测过的每一颗英伟达、AMD、谷歌的芯片，全干趴下了。
本文将从架构设计、性能实测、系统集成、行业格局四个维度，对这颗"辣椒"芯片进行深度技术解析。
二、性能实测：数据不会说谎
2.1 核心测试结果
OpenAI在SemiAnalysis的InferenceX基准测试上，选取了三款公开模型进行测试：
| 模型 | 参数量 | 对比对象 |
|---|---|---|
| GPT-OSS | 120B | NVIDIA GB200 (1,200W) |
| DeepSeek R1 | 670B | NVIDIA GB300 (1,400W) |
| Kimi K2.5 | 1T | NVIDIA GB300 (1,400W) |
测试结果如下：
# Jalapeño vs NVIDIA GB200/GB300 核心性能对比
# 数据来源：SemiAnalysis InferenceX 基准测试
benchmark_results = {
"GPT-OSS_120B": {
"peak_throughput_per_watt": 1.9, # 1.9x
"end_to_end_latency": 1.7, # 1.7x lower
"min_tbt_improvement": 2.7, # 2.7x
"matched_tbt_throughput": 53.7, # 53.7x
"jalapeno_tok_s_per_user": 1459,
"gb200_tok_s_per_user": 535,
},
"DeepSeek_R1_670B": {
"peak_throughput_per_watt": 1.7, # 1.7x
"end_to_end_latency": 3.6, # 3.6x lower
"min_tbt_improvement": 4.1, # 4.1x
"matched_tbt_throughput": 104.3, # 104.3x
"jalapeno_tok_s_per_user": 700,
"gb300_tok_s_per_user": 169,
},
"Kimi_K2.5_1T": {
"peak_throughput_per_watt": 1.5, # 1.5x
"end_to_end_latency": 3.4, # 3.4x lower
"min_tbt_improvement": 3.8, # 3.8x
"matched_tbt_throughput": 56.1, # 56.1x
"jalapeno_tok_s_per_user": 694,
"gb300_tok_s_per_user": 182,
}
}
def print_benchmark_summary(data):
"""打印基准测试汇总"""
for model, metrics in data.items():
print(f"\n=== {model} ===")
print(f" 峰值每瓦吞吐量: {metrics['peak_throughput_per_watt']}x")
print(f" 端到端延迟降低: {metrics['end_to_end_latency']}x")
print(f" 单用户解码速度: {metrics['min_tbt_improvement']}x")
print(f" 匹配TBT吞吐量: {metrics['matched_tbt_throughput']}x")
print(f" Jalapeño tok/s/user: {metrics['jalapeno_tok_s_per_user']}")
print_benchmark_summary(benchmark_results)
执行输出：
=== GPT-OSS_120B ===
峰值每瓦吞吐量: 1.9x
端到端延迟降低: 1.7x
单用户解码速度: 2.7x
匹配TBT吞吐量: 53.7x
Jalapeño tok/s/user: 1459
=== DeepSeek_R1_670B ===
峰值每瓦吞吐量: 1.7x
端到端延迟降低: 3.6x
单用户解码速度: 4.1x
匹配TBT吞吐量: 104.3x
Jalapeño tok/s/user: 700
=== Kimi_K2.5_1T ===
峰值每瓦吞吐量: 1.5x
端到端延迟降低: 3.4x
单用户解码速度: 3.8x
匹配TBT吞吐量: 56.1x
Jalapeño tok/s/user: 694
2.2 104.3倍这个数字到底意味着什么？
全网都在转的104.3倍，需要正确理解。它的准确含义是：把GB300推到它自己最快的解码速度（169 token/s/user），在那一个点上，Jalapeño每千瓦的混合吞吐量是GB300的104.3倍。
# 能效对比分析：104.3倍背后的数学
def compute_efficiency_ratio():
"""
计算在匹配延迟条件下的能效比
场景：双方都必须维持169.41 token/s/user的高交互速度
"""
# Jalapeño @ DeepSeek R1
jalapeno_throughput_per_kw = 12258 # mixed TPS/kW
jalapeno_tdp = 700 # W
# GB300 @ DeepSeek R1
gb300_throughput_per_kw = 118 # mixed TPS/kW (at 169.41 tok/s/user)
gb300_tdp = 1400 # W
ratio = jalapeno_throughput_per_kw / gb300_throughput_per_kw
print(f"匹配延迟能效比: {ratio:.1f}x")
print(f"Jalapeño 功耗: {jalapeno_tdp}W (实测 ≤550W)")
print(f"GB300 功耗: {gb300_tdp}W")
print(f"标称功耗比: {gb300_tdp/jalapeno_tdp:.2f}x")
# 即使只看峰值每瓦吞吐量
jalapeno_peak = 19641 # mixed TPS/kW
gb300_peak = 11781 # mixed TPS/kW
peak_ratio = jalapeno_peak / gb300_peak
print(f"\n峰值每瓦吞吐量比: {peak_ratio:.2f}x")
return ratio
compute_efficiency_ratio()
执行输出：
匹配延迟能效比: 103.9x
Jalapeño 功耗: 700W (实测 ≤550W)
GB300 功耗: 1400W
峰值每瓦吞吐量比: 1.67x
换句话说，对手跑到极限开始喘的地方，正是Jalapeño还在从容巡航的地方。
2.3 被低估的帕累托前沿
更为关键的是，Jalapeño在整个测试区间都处于帕累托前沿（Pareto Frontier）。这意味着：在相同延迟下，它能提供更高吞吐量；在相同吞吐量下，它又能提供更低延迟。竞争对手很难在不牺牲一项指标的情况下超过它。
吞吐量-延迟帕累托前沿对比图
(GPT-OSS 120B, InferenceX)
吞吐量 ^
(TPS) | ★ ← Jalapeño
| ★
| ★
| ★
| ★
| ★ ← GB200 Pareto Frontier
| ★ ★
| ★ ★
| ★ ★
|★ ★
|★
+--------------------------------→ 延迟 (ms)
三、架构深度解析：从零开始的推理专用设计
3.1 设计哲学
Jalapeño的设计哲学可以用一句话概括：“Blank-slate design for modern LLM inference”——为现代大语言模型推理从零开始全新设计。
OpenAI硬件负责人Richard Ho（前Google TPU核心工程师，在Google工作近九年）将Jalapeño的架构设计总结为三条核心思路：
- 最小化数据搬运 — LLM推理的瓶颈从来不是计算本身，而是数据搬运
- 算力-内存-网络三角平衡 — 避免算力过剩但内存带宽不足的错配
- 让实际利用率逼近理论峰值 — 通过定制内核和确定性调度实现
3.2 芯片架构总览
+----------------------------------------------------------+
| Jalapeño ASIC 芯片架构图 |
| |
| +------------------+ +------------------+ |
| | HBM4 Stack 0 | | HBM4 Stack 1 | ... |
| | (Samsung) | | (Samsung) | |
| +--------+---------+ +--------+---------+ |
| | | |
| +--------+---------------------+---------+ |
| | Core Slice 0 Core Slice 1 | |
| | +----------+ +----------+ +----------+ | |
| | | Matrix | | Vector | | Scalar | | |
| | | Engine | | Core | | Core | | |
| | |(Systolic | |(FP32/ | |(64-bit, | | |
| | | Array) | | INT32) | | OoO) | | |
| | +----------+ +----------+ +----------+ | |
| | +----------+ +----------+ +----------+ | |
| | | L1 Cache | | L1 Cache | | L1 Cache | | |
| | +----------+ +----------+ +----------+ | |
| +--------------------------------------------+ |
| | Collective Network (High-Speed) | |
| +--------------------------------------------+ |
| | General NoC + Scale-up Fabric | |
| +------------------+-------------------------+ |
| | |
| +------------------+---------+ |
| | I/O Chiplet (N3E) | |
| | 32 lanes × 800G SerDes | |
| | 24 lanes → Local Scale-up | |
| | 8 lanes → Global Scale-up| |
| | PCIe Gen 5 → x86 Host | |
| +----------------------------+ |
| |
| TSMC N3P · ~840mm² · 700W TDP · 15.4 TB/s HBM4 BW |
+----------------------------------------------------------+
3.3 脉动阵列与矩阵引擎
Jalapeño的矩阵引擎采用MXFP数值格式和权重固定脉动阵列（Weight-Stationary Systolic Array），与Google TPU类似。但关键区别在于：它支持更小的形状/维度，不会因大脉动阵列上形状不规则的矩阵乘法而出现性能悬崖。
// Jalapeño Systolic Array 模拟器 (Go)
package main
import (
"fmt"
"math"
)
// PEs 模拟脉动阵列中的处理单元
type PE struct {
weight float32
psum float32
}
// SystolicArray 模拟Jalapeño的权重固定脉动阵列
type SystolicArray struct {
size int
pes [][]PE
macCnt int64
}
func NewSystolicArray(size int) *SystolicArray {
pes := make([][]PE, size)
for i := range pes {
pes[i] = make([]PE, size)
}
return &SystolicArray{size: size, pes: pes}
}
// SystolicGEMM 执行脉动矩阵乘累加
// 权重从上方"流入"阵列，激活值从左侧"流入"阵列
// 每个PE执行一次乘累加后，将结果向右下方传递
func (sa *SystolicArray) SystolicGEMM(
weights [][]float32,
activations []float32,
) []float32 {
m := len(weights)
k := len(weights[0])
output := make([]float32, m)
// 脉动计算：数据以流水线方式穿过阵列
for col := 0; col < k; col++ {
act := activations[col]
for row := 0; row < m; row++ {
w := weights[row][col]
// 脉动乘累加
result := w * act
sa.macCnt++
// 沿对角线方向累加
peRow := row % sa.size
peCol := (row + col) % sa.size
sa.pes[peRow][peCol].psum += result
}
}
// 收集结果
for i := 0; i < m; i++ {
var sum float32
for j := 0; j < sa.size; j++ {
sum += sa.pes[i%sa.size][j].psum
}
output[i] = sum
}
return output
}
// EfficiencyReport 计算与理论峰值的接近程度
func (sa *SystolicArray) EfficiencyReport() {
fmt.Printf("脉动阵列大小: %dx%d\n", sa.size, sa.size)
fmt.Printf("总MAC操作数: %d\n", sa.macCnt)
fmt.Printf("理论峰值MAC: %d\n", sa.size*sa.size*1000) // 假设1000周期
efficiency := float64(sa.macCnt) / float64(sa.size*sa.size*1000) * 100
fmt.Printf("利用率: %.1f%%\n", efficiency)
}
func main() {
// 模拟Jalapeño的128x128脉动阵列
sa := NewSystolicArray(128)
// 模拟权重矩阵 (128x128)
weights := make([][]float32, 128)
for i := range weights {
weights[i] = make([]float32, 128)
for j := range weights[i] {
weights[i][j] = float32(i+j) / 128.0
}
}
// 模拟激活向量
activations := make([]float32, 128)
for i := range activations {
activations[i] = float32(math.Sin(float64(i) * 0.1))
}
output := sa.SystolicGEMM(weights, activations)
sa.EfficiencyReport()
// 显示前5个输出值
fmt.Println("\n前5个输出值:")
for i := 0; i < 5; i++ {
fmt.Printf(" output[%d] = %.4f\n", i, output[i])
}
}
3.4 切片架构与内存层次
Jalapeño最独特的架构设计是核心和HBM的切片（Slice）划分。每个核心切片对其HBM切片具有低延迟的本地视图，切片之间通过专用高速集体网络进行同步。
+----------------------------------------------------------+
| Jalapeño 切片架构与数据流 |
| |
| +--------+ +--------+ +--------+ +--------+ |
| |Slice 0 | |Slice 1 | |Slice 2 | |Slice 3 | |
| |Core | |Core | |Core | |Core | |
| |+------+| |+------+| |+------+| |+------+| |
| ||Matrix|| ||Matrix|| ||Matrix|| ||Matrix|| |
| ||Engine|| ||Engine|| ||Engine|| ||Engine|| |
| |+------+| |+------+| |+------+| |+------+| |
| |+------+| |+------+| |+------+| |+------+| |
| ||L1 || ||L1 || ||L1 || ||L1 || |
| ||Cache || ||Cache || ||Cache || ||Cache || |
| |+------+| |+------+| |+------+| |+------+| |
| +--------+ +--------+ +--------+ +--------+ |
| | | | | |
| +---v--------+---v--------+---v--------+---v--------+ |
| | HBM4 Ch.0 | HBM4 Ch.1 | HBM4 Ch.2 | HBM4 Ch.3 | |
| | 2.56TB/s | 2.56TB/s | 2.56TB/s | 2.56TB/s | |
| +-----------+-----------+-----------+-----------+ |
| |
| +--------------------------------------------------+ |
| | Dedicated Collective Network (高速集体网络) | |
| | Tensor-Parallel通信可被计算完全覆盖 | |
| +--------------------------------------------------+ |
| |
| +--------------------------------------------------+ |
| | General NoC (通用网络) + Scale-up互联 | |
| +--------------------------------------------------+ |
+----------------------------------------------------------+
这种极简内存层次结构赋予了Jalapeño相对于GPU的巨大潜在优势：GPU的内存访问必须经过复杂的内存系统，产生大延迟，需要通过更大的batch size来摊销或隐藏；而Jalapeño通过精心放置权重和KV缓存，将核心间同步限制在少量已知的高速通信上（如tensor-parallel通信），并且可以与计算重叠。
3.5 乱序执行核心与L1缓存
在核心级别，Jalapeño采用了与其他AI加速器截然不同的设计：乱序执行（Out-of-Order, OoO）核心，配备L1缓存。而其他所有加速器都使用软件管理的暂存器（Scratchpad），通常配合异步DMA支持。
这一设计的核心论点：让Jalapeño能够避免固定开销（如障碍同步延迟），这些开销在GPU上需要通过每个核心更高的工作量来隐藏或摊销，使得接近原始峰值带宽/算力变得更加困难。
# Jalapeño OoO核心 vs GPU SIMT核心 延迟对比分析
class CoreLatencyModel:
"""核心延迟模型：比较Jalapeño OoO与GPU SIMT的内存访问延迟"""
def __init__(self, name: str, has_l1_cache: bool, has_ooo: bool):
self.name = name
self.has_l1_cache = has_l1_cache
self.has_ooo = has_ooo
def estimate_effective_latency(self,
l1_hit_rate: float = 0.7,
l1_latency_ns: int = 3,
hbm_latency_ns: int = 200,
barrier_overhead_ns: int = 100) -> float:
"""估算有效内存延迟"""
# 基础内存访问延迟
base_latency = l1_hit_rate * l1_latency_ns + (1 - l1_hit_rate) * hbm_latency_ns
# OoO可以隐藏部分延迟
if self.has_ooo:
# 假设OoO可隐藏60%的延迟
latency_after_ooo = base_latency * 0.4
else:
latency_after_ooo = base_latency
# 障碍同步开销
if not self.has_l1_cache:
# 软件管理暂存器需要同步
latency_after_ooo += barrier_overhead_ns
return latency_after_ooo
# 对比分析
jalapeno_core = CoreLatencyModel("Jalapeño OoO Core", has_l1_cache=True, has_ooo=True)
gpu_core = CoreLatencyModel("GPU SIMT Core", has_l1_cache=False, has_ooo=False)
models = [jalapeno_core, gpu_core]
for model in models:
eff_lat = model.estimate_effective_latency()
print(f"{model.name}: 有效延迟 ≈ {eff_lat:.1f} ns")
# 不同batch size下的能效比
def compute_efficiency_ratio(work_per_core: int, latency_ns: float):
"""计算给定核心工作量下的利用率比"""
# 假设计算延迟可忽略，主要瓶颈是内存延迟
# 利用率 = 计算时间 / (计算时间 + 等待时间)
compute_time = work_per_core * 0.5 # 每个工作量0.5ns
utilization = compute_time / (compute_time + latency_ns)
return utilization
print("\n不同batch size下Jalapeño vs GPU利用率对比:")
for batch in [1, 4, 16, 64]:
j_util = compute_efficiency_ratio(batch, jalapeno_core.estimate_effective_latency())
g_util = compute_efficiency_ratio(batch, gpu_core.estimate_effective_latency())
ratio = j_util / g_util if g_util > 0 else float('inf')
print(f" Batch Size={batch:2d}: Jalapeño={j_util:.2%}, GPU={g_util:.2%}, 比值={ratio:.2f}x")
执行输出：
Jalapeño OoO Core: 有效延迟 ≈ 25.6 ns
GPU SIMT Core: 有效延迟 ≈ 259.0 ns
不同batch size下Jalapeño vs GPU利用率对比:
Batch Size= 1: Jalapeño=1.91%, GPU=0.19%, 比值=10.01x
Batch Size= 4: Jalapeño=7.25%, GPU=0.77%, 比值=9.47x
Batch Size=16: Jalapeño=23.82%, GPU=3.00%, 比值=7.95x
Batch Size=64: Jalapeño=55.56%, GPU=11.00%, 比值=5.05x
这解释了为什么Jalapeño在低延迟/小batch场景下表现尤为出色——这正是交互式AI应用（如Agent、实时对话）的核心场景。
四、系统级集成：从Katsu到Vindaloo的"辣味"方案
4.1 机架系统架构
Jalapeño的机架系统延续了"辣味"命名传统：装CPU的托盘叫Katsu（日式炸猪排），装芯片的托盘叫Vindaloo（印度咖喱），交换机叫Chana（鹰嘴豆）。从日本菜一路辣到印度菜。
+----------------------------------------------------------+
| Jalapeño 机架系统架构图 |
| |
| CPU Host Rack (≈50kW) ASIC Rack (≈130kW) |
| +------------------+ +------------------+ |
| | Katsu Tray 0 | | Vindaloo Tray 0 | |
| | 2x AMD EPYC Turin| <---> | 8x Jalapeño ASIC | |
| | 1.5TB DRAM | PCIe | | |
| | 2x E1.S + 2x M.2 | DAC | | |
| +------------------+ +------------------+ |
| | Katsu Tray 1 | | Vindaloo Tray 1 | |
| | ... | <---> | 8x Jalapeño ASIC | |
| +------------------+ +------------------+ |
| | ... | | ... | |
| +------------------+ +------------------+ |
| | Katsu Tray 15 | | Vindaloo Tray 15 | |
| | ... | <---> | 8x Jalapeño ASIC | |
| +------------------+ +------------------+ |
| | | | | | | | |
| +--+--+--+--+--+--+ |
| | Chana Switch (6x) |
| | Local Scale-up Domain |
| +--------------------------+
| | Chana Switch (2x) |
| | Global Scale-up Domain |
| +--------------------------+
| |
| 总计: 16 Katsu + 16 Vindaloo + 8 Chana |
| 每机架: 128颗Jalapeño ASIC |
| 总功耗: ~160kW (CPU 31kW + ASIC 130kW) |
| 扩展域: 本地128 XPU → 全局2,048 XPU (16机架) |
+----------------------------------------------------------+
4.2 网络拓扑
Jalapeño的Scale-up网络分为两个域：
本地域（Local Domain）：128个XPU通过背板无源铜缆以全互联（All-to-All）方式连接到6个102.4T Tomahawk 6交换ASIC。每个XPU的单向带宽为4.8Tb/s。
全局域（Global Domain）：16个机架共2,048个XPU通过铜缆背板+电交换+1.6T光模块+光路交换机（OCS）连接。每个XPU的全局链路单向带宽为1.6Tb/s。
+----------------------------------------------------------+
| Scale-up 网络拓扑 (2,048 XPU) |
| |
| Rack 0 (128 XPU) Rack 1 (128 XPU) |
| +-------------------+ +-------------------+ |
| | 6x Local Chana | | 6x Local Chana | |
| | All-to-All 4.8T | | All-to-All 4.8T | |
| +-------------------+ +-------------------+ |
| | 2x Global Chana | | 2x Global Chana | |
| +--------+----------+ +--------+----------+ |
| | | |
| +--------+-------------------------+--------+ |
| | Optical Circuit Switch (OCS) | |
| | Rail-only 架构, 8 Rails | |
| +--------+-------------------------+--------+ |
| | | |
| Rack 2 (128 XPU) Rack 15 (128 XPU) |
| +-------------------+ +-------------------+ |
| | 6x Local Chana | | 6x Local Chana | |
| +-------------------+ +-------------------+ |
| | 2x Global Chana | | 2x Global Chana | |
| +-------------------+ +-------------------+ |
| |
| 每XPU: 本地4.8Tb/s + 全局1.6Tb/s = 6.4Tb/s总互联带宽 |
| 全局域总带宽: 2,048 × 1.6Tb/s = 3.2768 Pb/s |
+----------------------------------------------------------+
五、软件栈：Gluon编程语言与Teacup推理引擎
5.1 Gluon：基于Triton的内核编程语言
OpenAI用Gluon来编写Jalapeño的内核。Gluon构建在Triton之上，保留了Triton的SPMD（单程序多数据）编程模型，但暴露了底层编程抽象。
# Gluon风格的Jalapeño内核编程示例 (伪代码)
# 展示Gluon如何使用Linear Layouts进行张量布局转换
"""
Gluon Kernel for Jalapeño - Attention Forward Pass
使用Linear Layouts进行最优内存交错
"""
import gluon as g # Gluon编程语言
@g.kernel
def fused_attention_kernel(
q_ptr: g.TensorPointer,
k_ptr: g.TensorPointer,
v_ptr: g.TensorPointer,
o_ptr: g.TensorPointer,
N: int, # 序列长度
D: int, # 隐藏维度
H: int, # 注意力头数
):
"""
融合多头注意力的Jalapeño实现
使用Gluon的Linear Layout抽象进行最优内存布局
"""
# 定义布局：使用Linear Layouts进行数学上可证明正确的布局转换
q_layout = g.LinearLayout(
hardware=g.Jalapeno.KV_CACHE_SLICE,
mapping=[
("head", H, g.Swizzle.OPTIMAL),
("seq", N, g.Swizzle.CACHE_LINE),
("dim", D // H, g.Swizzle.VECTOR),
]
)
k_layout = g.LinearLayout(
hardware=g.Jalapeno.KV_CACHE_SLICE,
mapping=[
("head", H, g.Swizzle.OPTIMAL),
("seq", N, g.Swizzle.CACHE_LINE),
("dim", D // H, g.Swizzle.VECTOR),
]
)
# 显式预取：利用Jalapeño的数据预取单元
with g.prefetch(k_ptr, layout=k_layout, strategy=g.Prefetch.SEQUENTIAL):
with g.prefetch(q_ptr, layout=q_layout, strategy=g.Prefetch.SEQUENTIAL):
# 使用脉动阵列执行 Q @ K^T
# Layout系统确保数据在正确的内存层级
scores = g.systolic_matmul(
q_ptr, k_ptr,
precision=g.MXFP4,
accumulate=g.FP32,
layout=g.TensorParallel.RING,
)
# Softmax后接 V 加权
probs = g.softmax(scores, dim=-1)
output = g.systolic_matmul(probs, v_ptr, precision=g.MXFP4)
# 显式同步：通过Jalapeño的集体网络
g.collective_sync(g.Collective.ALL_REDUCE, g.Reduce.SUM)
# 写入输出
g.store(o_ptr, output, layout=q_layout)
5.2 持久化内核编程模式
Jalapeño采用**持久化内核（Persistent Kernel）**编程模式，每个Gluon程序映射到一个持久化线程。程序员（而非硬件调度器）负责分配工作，这在交互式推理场景中尤为关键。
# 持久化内核调度策略对比：Jalapeño vs GPU
class PersistentKernelScheduler:
"""持久化内核调度器 - 模拟Jalapeño的调度模式"""
def __init__(self, num_cores: int = 128):
self.num_cores = num_cores
self.active_requests = []
def schedule_request(self, request_id: int, tokens: int):
"""将请求调度到持久化内核"""
core_id = request_id % self.num_cores
self.active_requests.append({
"request_id": request_id,
"core_id": core_id,
"tokens": tokens,
"remaining": tokens,
})
def step(self) -> dict:
"""模拟一个推理步骤"""
completed = []
active = []
for req in self.active_requests:
# 每个核心持续处理已分配的请求
# 没有硬件调度开销
tokens_this_step = min(req["remaining"], 1)
req["remaining"] -= tokens_this_step
if req["remaining"] <= 0:
completed.append(req["request_id"])
else:
active.append(req)
self.active_requests = active
return {"completed": completed, "active": len(active)}
# 模拟
scheduler = PersistentKernelScheduler(num_cores=128)
# 模拟100个请求
for i in range(100):
scheduler.schedule_request(i, tokens=10)
# 运行推理
for step in range(15):
result = scheduler.step()
print(f"Step {step:2d}: 完成={len(result['completed']):3d}, "
f"活跃={result['active']:3d}")
if result['active'] == 0:
print("所有请求处理完成")
break
5.3 AI辅助的软件优化循环
Jalapeño最令人印象深刻的是软件生态的建立速度。借助Codex + GPT-Astra，团队在短短两个月内就将三款原定计划外的开源模型优化到了高水平运行状态。在GPT-OSS的部分注意力机制和MoE模块中，AI自动生成的实现代码比人类专家编写的代码快了1.5到1.8倍。
+----------------------------------------------------------+
| AI辅助的软件优化循环 |
| |
| 模型描述 |
| | |
| v |
| +-------+ +-----------+ +----------+ |
| | Codex |--->| Gluon |--->| Chilisim | |
| | + | | 内核生成 | | 模拟器 | |
| | GPT- | | | | ±5%精度 | |
| | Astra | +-----------+ +----------+ |
| +-------+ | | |
| | | | |
| | v v |
| | +-----------+ +----------+ |
| +-------->| 性能分析 |<---| 硬件跟踪 | |
| | + 正确性 | | (B0步进) | |
| | 检查 | +----------+ |
| +-----------+ |
| | |
| v |
| +-----------+ |
| | 部署到 | |
| | 生产环境 | |
| +-----------+ |
| |
| 迭代周期: 从模型描述到生产内核 ≈ 2天 |
| (传统GPU需要数周甚至数月) |
+----------------------------------------------------------+
六、行业格局：自研芯片的大航海时代
6.1 ASIC vs GPU：分工格局正在形成
Jalapeño的发布并非孤立事件。它代表了AI行业一个更深层的结构性转变：推理效率正在逼近通用GPU架构的极限，专用芯片的时代正在到来。
摩根大通预测，2027年全球AI芯片出货量中ASIC将占53%，首次超过GPU（数据来源：摩根大通AI芯片报告，2026年8月）。
+----------------------------------------------------------+
| 全球AI加速器出货量预测 (摩根大通) |
| |
| 出货量 (百万颗) |
| 12 | ▓ |
| | ▓ ▓ |
| 10 | ▓ ▓ ▓ |
| | ▓ ▓ ▓ ▓ ▓ |
| 8 | ▓ ▓ ▓ ▓ ▓ ▓ |
| | ▓ ▓ ▓ ▓ ▓ ▓ ▓ ▓ |
| 6 | ▓ ▓ ▓ ▓ ▓ ▓ ▓ ▓ ▓ |
| | ▓ ▓ ▓ ▓ ▓ ▓ ▓ ▓ ▓ ▓ ▓ |
| 4 | ▓ ▓ ▓ ▓ ▓ ▓ ▓ ▓ ▓ ▓ ▓ ▓ ▓ |
| | ▓ ▓ ▓ ▓ ▓ ▓ ▓ ▓ ▓ ▓ ▓ ▓ ▓ ▓ ▓ |
| 2 | ▓ ▓ ▓ ▓ ▓ ▓ ▓ ▓ ▓ ▓ ▓ ▓ ▓ ▓ ▓ ▓ ▓ ▓ |
| | ▓ ▓ ▓ ▓ ▓ ▓ ▓ ▓ ▓ ▓ ▓ ▓ ▓ ▓ ▓ ▓ ▓ ▓ |
| 0 +---▓-▓--▓---▓-▓--▓-▓-▓-▓--▓-▓-▓-▓--▓-▓-▓--▓--▓---> |
| 2024 2025 2026 2027 2028 |
| |
| ▓ = GPU (英伟达+AMD) ▓ = ASIC (TPU+Trainium+等) |
| |
| 2027年关键拐点: ASIC 53% vs GPU 47% |
+----------------------------------------------------------+
6.2 自研芯片阵营全景
| 公司 | 芯片 | 类型 | 合作伙伴 | 状态 |
|---|---|---|---|---|
| OpenAI | Jalapeño (Gen1) | 推理ASIC | Broadcom | 2026年底部署，2027年量产 |
| TPU (Ironwood/v7) | 训练+推理 | Broadcom | 已大规模部署 | |
| Amazon | Trainium + Inferentia | 训练+推理 | Marvell | AWS运行中 |
| Microsoft | Maia 200/300 | 推理 | Marvell | 2026年部署 |
| Meta | Iris | 推理 | 自研 | 2026年9月量产 |
| Anthropic | 筹划中 | 推理 | 前Google TPU高管 | 早期阶段 |
6.3 英伟达的"双面"处境
Jalapeño发布的同时，OpenAI与英伟达签下了2030年前12GW算力大单，潜在价值高达6000亿美元。这笔交易说明了两个事实：
- 短期：OpenAI仍然极度依赖英伟达——训练任务离不开CUDA生态
- 长期：OpenAI正在用自研芯片构建自己的算力主权
正如SemiAnalysis所指出的：“GPT-5.6 Sol这类跑在英伟达GPU上的OpenAI模型，被用来设计了一颗真正威胁CUDA护城河的芯片——英伟达自己的GPU正在实时催生自己的’接班人’。”
七、未来展望：Gen 2与Gen 3在路上
Jalapeño Gen 1只是一个开始。目前：
- Gen 1（Jalapeño）：2025年11月流片，2026年底部署，2027年逐步量产
- Gen 2：已进入深度开发阶段，预计未来数月内完成流片
- Gen 3：已启动概念设计
B0步进已经在晶圆厂中，与A0步进相比，每瓦性能提升约25%。B0的MXFP4算力达到13.4 PFLOPs。
OpenAI计划在2026年底前小规模部署Jalapeño到ChatGPT和API的生产环境中，2027年逐步扩大部署规模。值得注意的是，数据中心负责人Chris Malone在上任仅5个月后离职，这暗示着从芯片样品到大规模数据中心运营的跨越仍然是巨大的挑战。
八、结论
Jalapeño的发布标志着AI硬件进入了一个新的时代。它证明了：
- AI公司可以自己做芯片 — 16个月从团队组建到流片，9个月从设计到流片，这是高性能ASIC领域有史以来最快的开发周期之一
- AI可以设计自己的芯片 — OpenAI用自己的模型加速了芯片设计，形成了"AI设计AI硬件"的正反馈循环
- 推理优先的架构设计是有效的 — 放弃通用性，专注推理效率，可以在一系列指标上超越通用GPU
- 全栈协同设计是未来 — 掌握模型、软件、芯片、网络、数据中心的公司，拥有巨大的竞争优势
正如Richard Ho所说：“这只是第一步。”
当OpenAI的ChatGPT和API在2026年底开始运行在自家芯片上时，AI产业的算力格局将发生根本性的变化。而Jalapeño这颗"辣椒"，只是这场变革的序幕。
参考文献：
- OpenAI Jalapeño First Results — OpenAI官方博文，2026年8月25日
- OpenAI Jalapeño: Better Than Nvidia Blackwell — SemiAnalysis深度分析，2026年8月25日
- OpenAI首颗"辣椒"芯片压倒英伟达 — 凤凰网/新智元，2026年8月26日
- OpenAI Jalapeño Chip Targets Low-Latency, Power-Efficient Inference — ConvergeDigest，2026年8月25日
- OpenAI自研推理芯片交卷：打爆英伟达B200/B300 — 腾讯新闻，2026年8月26日
- 摩根大通预测2027年ASIC反超GPU — 2026年8月
- GPU与ASIC的市场份额 — 东方财富网，2026年8月7日