OpenAI Jalapeño首款自研AI芯片深度技术解析：9个月流片、推理成本降50%、AI设计AI硬件

导读：2026年6月24日，OpenAI与博通（Broadcom）联合发布首款定制AI推理芯片Jalapeño（墨西哥辣椒），从架构设计到流片仅用9个月，创下高性能ASIC开发速度纪录。这款采用台积电3nm工艺、脉动阵列架构的推理专用芯片，宣称推理成本较传统AI GPU降低约50%，年底启动千兆瓦级部署。更值得注意的是——AI模型深度参与了芯片设计流程，开启了\”AI设计AI硬件\”的新纪元。

一、行业背景：AI推理算力危机的必然选择

1.1 推理算力：从\”边角料\”到\”主战场\”

2024年之前，整个AI产业的目光几乎全部聚焦在模型训练上——GPT-5、Claude 4、Gemini 2.0，每一代模型的训练都需要数万张GPU连续运行数周，算力投入动辄数亿美元。然而进入2025-2026年，一个深刻的转变正在发生：

推理算力正在超过训练算力，成为AI基础设施最大的成本项。

以ChatGPT为例，其日活用户已突破数亿，每次对话背后都是一次推理请求。GPT-5系列模型的推理计算量是GPT-4的数十倍，而随着Codex、Deep Research、Operator等智能体产品的上线，推理侧的并发请求量和单请求计算量都在爆发式增长。据行业估算，OpenAI的推理算力成本已占其总算力支出的60%以上。

与此同时，通用GPU（如NVIDIA H100/B200）虽然在训练场景表现卓越，但在纯推理场景存在固有短板——它们为训练设计的张量核心、高精度计算单元，在推理场景中存在大量闲置。这就好比用波音747的引擎驱动一台家用轿车——动力过剩但效率低下。

1.2 供应链风险：单一依赖的脆弱性

更深层的动因是供应链安全。OpenAI对NVIDIA GPU的依赖程度极高——其绝大部分训练和推理负载运行在NVIDIA的GPU集群上。这种单一依赖意味着：

• 定价权：NVIDIA掌握定价权，Blackwell GPU供不应求导致溢价持续
• 产能瓶颈：CoWoS封装产能紧张，HBM内存供应受限，直接影响GPU交付
• 路线图依赖：OpenAI的算力扩张计划受制于NVIDIA的产品迭代节奏

正是这种双重重压——推理成本的指数级增长和对单一供应商的过度依赖——迫使OpenAI走上自研芯片之路。这不是一个\”锦上添花\”的项目，而是一个关乎生存的战略决策。

二、芯片架构深度解析：从零开始的推理专用设计

2.1 基础参数与设计哲学

Jalapeño是一颗专用集成电路（ASIC），采用台积电3nm（N3）工艺制造，核心设计理念可以用一句话概括：“blank-slate design for modern LLM inference”——为现代大语言模型推理从零开始全新设计。

2.2 三大核心设计思路

OpenAI硬件负责人Richard Ho（前Google TPU核心工程师）将Jalapeño的架构设计总结为三条核心思路：

第一，减少数据搬运（Reduces Data Movement）。

大模型推理的瓶颈从来不是计算本身，而是数据搬运。LLM推理的本质是权重矩阵与激活向量的反复乘累加，但每次计算都需要从HBM中搬运权重到计算单元，这个搬运过程的能耗和延迟远超计算本身。Jalapeño在数据路径上做了定向优化：

第二，平衡算力、内存、网络三者的资源分配。

传统GPU在设计时追求极致的计算吞吐量——更多的CUDA核心、更高的时钟频率。但这在推理场景中可能导致严重的资源错配：算力过剩但内存带宽不足，数据供不上计算单元。Jalapeño在设计时围绕\”计算-内存-网络\”三角进行了精确均衡：

• 计算单元规模与内存带宽精确匹配，确保每个时钟周期计算单元都能\”吃饱\”
• 网络互联带宽与机架内通信需求对齐，避免节点间通信成为瓶颈
• 片上存储与片外HBM之间形成高效的缓存层级

第三，让实际利用率逼近理论峰值。

通用GPU的理论峰值利用率往往难以在实际工作负载中实现——分支预测失败、缓存缺失、内存带宽瓶颈都会导致利用率大幅下降。Jalapeño通过以下手段逼近理论极限：

2.3 脉动阵列：推理效率的核心武器

脉动阵列（Systolic Array）是Jalapeño计算核心的关键架构选择。与GPU中大量通用CUDA核心不同，脉动阵列是一种专用化的计算单元阵列，数据在阵列中以\”脉动\”方式逐级传递：

import numpy as np
from typing import List, Optional

class SystolicArraySimulator:
\”\”\”
Jalapeño推理芯片脉动阵列模拟器

模拟脉动阵列执行矩阵乘累加的核心计算模式。
LLM推理中，核心运算是: output = weight @ activation
脉动阵列通过数据流水线实现高效的乘累加。
\”\”\”

def __init__(self, array_size: int = 128, precision: str = \”fp16\”):
\”\”\”
初始化脉动阵列

Args:
array_size: 脉动阵列的维度 (array_size x array_size)
precision: 计算精度 (fp16/bf16/int8)
\”\”\”
self.array_size = array_size
self.precision = precision
# 脉动阵列中的处理单元(PE)网格
self.pe_array = np.zeros((array_size, array_size), dtype=np.float32)
# 部分和缓冲区
self.partial_sums = np.zeros((array_size, array_size), dtype=np.float32)
# 统计指标
self.mac_count = 0
self.data_movement = 0

def systolic_gemm(self,
weight_matrix: np.ndarray,
activation_vector: np.ndarray) –> np.ndarray:
\”\”\”
脉动矩阵乘累加(GEMM) – 核心推理计算

与GPU的并行执行不同，脉动阵列采用数据流水线方式：
权重从上方\”流入\”阵列，激活值从左侧\”流入\”阵列，
每个PE执行一次乘累加后，将结果向右下方传递。

Args:
weight_matrix: 权重矩阵 (M x K)
activation_vector: 激活向量 (K,)

Returns:
输出向量 (M,)
\”\”\”
M, K = weight_matrix.shape
output = np.zeros(M, dtype=np.float32)

# 数据搬运统计：每次搬运权重矩阵
self.data_movement += M * K * 2 # 权重字节数(fp16)

# 脉动计算：数据以流水线方式穿过阵列
# 每个时钟周期，每个PE执行一次乘累加
for k in range(K):
# 激活值从左侧广播到整行
act_val = activation_vector[k]

for i in range(M):
# 权重从上方流入
weight = weight_matrix[i, k]

# 脉动乘累加：每个PE一次MAC操作
if i < self.array_size:
result = weight * act_val
self.mac_count += 1

# 结果沿对角线方向向下传递（累加）
# 模拟脉动阵列的\”波前\”传播
if k == 0:
partial_sums[i, 0] = result
else:
partial_sums[i % self.array_size,
(i + k) % self.array_size] = result

# 收集最终结果
for i in range(M):
output[i] = np.sum(partial_sums[i % self.array_size, :])

return output

def fused_mha_systolic(self,
query: np.ndarray,
key: np.ndarray,
value: np.ndarray,
num_heads: int = 32) –> np.ndarray:
\”\”\”
融合多头注意力的脉动阵列实现

Jalapeño的关键创新之一：将多头注意力的多个步骤
(QK^T → Softmax → SV) 融合到单个脉动流水线中，
减少中间结果的HBM读写。

Args:
query: Q矩阵 (seq_len x d_model)
key: K矩阵 (seq_len x d_model)
value: V矩阵 (seq_len x d_model)
num_heads: 注意力头数

Returns:
注意力输出 (seq_len x d_model)
\”\”\”
seq_len, d_model = query.shape
head_dim = d_model // num_heads

# 分头
q_heads = query.reshape(seq_len, num_heads, head_dim).transpose(1, 0, 2)
k_heads = key.reshape(seq_len, num_heads, head_dim).transpose(1, 0, 2)
v_heads = value.reshape(seq_len, num_heads, head_dim).transpose(1, 0, 2)

outputs = []
for h in range(num_heads):
# Step 1: QK^T – 使用脉动阵列计算
# 在传统GPU上：写入HBM → 读取计算 → 写回HBM
# 在Jalapeño上：直接通过脉动流水线保持中间结果在片上
scores = self.systolic_gemm(
q_heads[h], # seq_len x head_dim
k_heads[h].T # head_dim x seq_len
)

# Step 2: Softmax (尺度化+指数+归一化)
# 在脉动阵列的\”波前\”之间内联执行
d_k = np.sqrt(head_dim)
scores = scores / d_k
scores = np.exp(scores – np.max(scores))
scores = scores / np.sum(scores)

# Step 3: SV – 继续在脉动阵列中执行
# 无需将scores写回HBM
attn_out = self.systolic_gemm(
scores.reshape(–1, 1),
v_heads[h].reshape(–1)
)
outputs.append(attn_out)

return np.concatenate(outputs).reshape(seq_len, d_model)

def report_efficiency(self):
\”\”\”报告阵列利用效率\”\”\”
theoretical_max = self.array_size * self.array_size * 1000 # 假设1000周期
actual = self.mac_count
efficiency = actual / theoretical_max * 100

print(f\”脉动阵列效率分析:\”)
print(f\” 阵列尺寸: {

self.array_size}x{

self.array_size}\”)
print(f\” MAC操作数: {

self.mac_count}\”)
print(f\” 理论最大值: {

theoretical_max}\”)
print(f\” 利用率: {

efficiency:.1f}%\”)
print(f\” 数据搬运量: {

self.data_movement} bytes\”)

return efficiency

# 模拟Jalapeño推理场景
def simulate_jalapeno_inference():