高性能计算（HPC）基础
为什么需要高性能计算
单台计算机的处理能力存在物理极限。当计算规模达到一定程度时，即使使用最强大的单机也无法在合理时间内完成任务。高性能计算通过将计算任务分散到大量处理器上并行执行，突破了单机性能瓶颈。
2004 年前后，单核处理器的性能提升遇到了多重瓶颈：晶体管集成度已进入纳米级别，难以继续大幅提高；指令级并行技术（流水线、分支预测、超标量、乱序执行等）已接近极限；CPU 速度与主存速度的差距日益拉大（CPU 访问约 1ns，主存约 100ns）；频率提升导致功耗急剧增加（功耗 P = CV²f），Intel 在 2004 年放弃 Tejas 4GHz 处理器计划，标志着"升频时代"的终结。
此后，工业界全面转向多核与众核并行计算。从双核、四核到如今的数十核通用处理器，以及 GPU、TPU 等专用众核加速器，并行计算已成为提升性能的核心途径。与此同时，应用领域的数据规模也在爆炸式增长——Google 每天处理数十亿次搜索，大型强子对撞机每年产生 15PB 数据，基因测序中心每天产出数百 GB 数据。这些需求催生了对并行计算技术的迫切需要。
HPC 的三层设计思想
HPC 在三个层面上解决了大规模计算问题：
- 分而治之：对相互间没有计算依赖关系的大任务，最自然的并行方式就是将任务划分为多个子块，分配给多个处理器并行处理
- 抽象模型：提供 MPI、OpenMP、CUDA 等编程模型，让程序员专注于算法逻辑，而不需要关心底层硬件细节
- 系统优化：通过内存层次优化、通信优化、负载均衡等技术，最大化硬件利用率
核心设计原则
HPC 的成功不仅在于编程模型，更在于一系列精心设计的系统原则：
- 数据局部性（Data Locality）：确保处理器需要的数据已经在最快的可用内存中。一次缓存未命中可能导致处理器停顿数百个时钟周期
- 计算与通信重叠：使用非阻塞通信，让计算和通信同时进行，隐藏通信延迟
- 负载均衡：确保所有处理器的工作量大致相等，避免部分处理器空闲等待
- 最小化通信：通信开销往往比计算开销大几个数量级，应尽量减少进程间通信
并行计算的分类
Flynn 分类法
1966 年，斯坦福大学教授 Flynn 从指令和数据流的角度提出了经典的计算机结构分类：
| 类型 | 全称 | 说明 | 典型系统 |
|---|---|---|---|
| SISD | 单指令单数据流 | 传统串行处理器 | 早期单核 CPU |
| SIMD | 单指令多数据流 | 一条指令同时处理多个数据 | 向量机、GPU |
| MISD | 多指令单数据流 | 很少实际使用 | 容错系统 |
| MIMD | 多指令多数据流 | 最常见的并行形式 | 多核 CPU、集群 |
TOP500 超级计算机几乎全部属于 MIMD 类型。
按存储访问架构分类
graph TD
subgraph A[共享内存 UMA]
P1[处理器] --- Bus[总线]
P2[处理器] --- Bus
P3[处理器] --- Bus
Bus --- M[共享内存]
end
subgraph B[分布式内存]
P4[处理器] --- M1[本地内存]
P5[处理器] --- M2[本地内存]
P6[处理器] --- M3[本地内存]
P4 <-.->|网络| P5
P5 <-.->|网络| P6
end- 共享内存（UMA）：所有处理器通过总线访问同一内存，编程简单但扩展性有限，典型代表是 SMP（对称多处理）系统
- 分布式内存：每个处理器拥有独立的本地内存，通过网络通信，扩展性强但编程复杂，典型代表是集群和 MPP
- 分布式共享内存（NUMA）：兼具两者特点，处理器有本地内存也可访问全局内存，需处理缓存一致性问题
按系统类型分类
| 类型 | 全称 | 特点 |
|---|---|---|
| MC | Multicore/Manycore | 处理器核通过片上网络（NOC）集成在一个芯片上，功耗很低 |
| SMP | Symmetric Multiprocessing | 多个相同处理器通过总线共享内存，运行一个 OS，规模较小（2-8 处理器） |
| MPP | Massive Parallel Processing | 专用内联网连接独立处理器，各有独立内存和 OS，TOP500 中有 80 多个 |
| Cluster | 集群 | 商品化服务器通过网络互联，可扩展性强，TOP500 中有 400 多个 |
| Grid | 网格 | 地理上广泛分布的异构计算资源，极为松散，主要用于低并行度的大规模科学计算 |
Amdahl 定律
Amdahl 定律描述了并行程序的理论加速上限。设程序中可并行化的比例为 P，处理器数量为 N，则加速比 S 为：
\[S = \frac{1}{(1-P) + \frac{P}{N}}\]
当 N 趋于无穷大时，最大加速比为 1/(1-P)。这意味着：
| 可并行比例 P | 理论最大加速比 |
|---|---|
| 50% | 2× |
| 75% | 4× |
| 90% | 10× |
| 95% | 20× |
| 99% | 100× |
Amdahl 定律揭示了一个重要事实：串行部分是并行化的瓶颈。即使增加再多的处理器，程序的加速比也受限于不可并行的部分。这启示我们在设计并行算法时，应尽量减小串行比例。
MPI 编程
MPI（Message Passing Interface）是基于消息传递的高性能并行计算编程接口标准，1994 年发布 1.0 版本，经过 MPI 2.x、MPI 3.x 发展到 MPI 4.0（2021 年）乃至 MPI 5.0（2025 年）。其核心特点：
- 提供可靠的、面向消息的通信
- 独立于语言的编程规范（C/C++、Fortran、Python、Java 均有实现）
- 广泛用于科学计算领域的计算密集型任务
- 主要实现包括 MPICH、OpenMPI、Intel MPI 等
六个基本 API
MPI 提供了 6 个最基本的编程接口，理论上任何并行程序都可以通过它们实现：
// 1. 初始化 MPI 环境
MPI_Init(&argc, &argv);
// 2. 获取通信组中的进程总数
MPI_Comm_size(MPI_COMM_WORLD, &numprocs);
// 3. 获取当前进程的标识号
MPI_Comm_rank(MPI_COMM_WORLD, &myid);
// 4. 发送消息
MPI_Send(buf, count, datatype, dest, tag, comm);
// 5. 接收消息
MPI_Recv(buf, count, datatype, source, tag, comm, &status);
// 6. 终止 MPI 环境
MPI_Finalize();
其中 MPI_COMM_WORLD 是默认的全局通信组，dest/source 是目标/源进程的标识号，tag 是消息标签用于区分不同类型的消息。
点对点通信
MPI 的点对点通信分为同步（阻塞）和异步（非阻塞）两种模式：
阻塞通信：MPI_Send 和 MPI_Recv 在通信完成前不会返回，保证数据已发送/接收完毕。
非阻塞通信：MPI_Isend 和 MPI_Irecv 立即返回，通过 MPI_Wait 等待完成或 MPI_Test 查询状态，允许通信与计算重叠以提高效率。
sequenceDiagram
participant P0 as 进程 0
participant P1 as 进程 1
Note over P0,P1: 阻塞通信
P0->>P1: MPI_Send (阻塞)
Note over P0: 等待发送完成
P1->>P0: MPI_Recv (阻塞)
Note over P1: 等待接收完成
Note over P0,P1: 非阻塞通信
P0->>P1: MPI_Isend (立即返回)
Note over P0: 继续计算
P1->>P0: MPI_Irecv (立即返回)
Note over P1: 继续计算
P0->>P0: MPI_Wait
P1->>P1: MPI_Wait集合通信
集合通信提供一个进程与多个进程间同时通信的功能，主要包括三类：
| 类型 | 函数 | 功能 |
|---|---|---|
| 同步 | MPI_Barrier |
设置同步屏障，所有进程在此等待直到全部到达 |
| 数据移动 | MPI_Bcast |
一对多广播 |
| 数据移动 | MPI_Gather |
多对一收集 |
| 数据移动 | MPI_Scatter |
一对多分发 |
| 规约 | MPI_Reduce |
将各进程数据按指定操作规约到一个进程 |
MPI_Reduce 支持多种规约操作：MPI_SUM（求和）、MPI_MAX（最大值）、MPI_MIN（最小值）、MPI_PROD（求积）等。
编程示例：Monte Carlo 方法计算圆周率
Monte Carlo 方法通过随机抽样来近似求解问题。计算 π 的原理是：在边长为 1 的正方形内随机撒点，统计落入内切圆（半径 0.5）内的点数比例，π ≈ 4 × (圆内点数 / 总点数)。
#include <mpi.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main(int argc, char **argv) {
int myid, numprocs;
long count = 1000000; // 每个进程的采样点数
long m = 0; // 圆内点数
double x, y, pi;
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &myid);
MPI_Comm_size(MPI_COMM_WORLD, &numprocs);
srand((int)time(0) + myid); // 每个进程使用不同随机种子
// 每个进程独立进行随机采样
for (long i = 0; i < count; i++) {
x = (double)rand() / RAND_MAX;
y = (double)rand() / RAND_MAX;
if ((x - 0.5) * (x - 0.5) + (y - 0.5) * (y - 0.5) < 0.25)
m++;
}
// 使用 MPI_Reduce 将各进程的圆内点数求和到主进程
long total_m;
MPI_Reduce(&m, &total_m, 1, MPI_LONG, MPI_SUM, 0, MPI_COMM_WORLD);
if (myid == 0) {
pi = 4.0 * total_m / (count * numprocs);
printf("pi = %f\n", pi);
}
MPI_Finalize();
return 0;
}
编译和运行：
这个例子展示了 MPI 并行编程的基本模式：每个进程独立计算局部结果，然后通过 MPI_Reduce 将结果规约汇总。随着进程数增加，总采样点数成倍增长，计算精度和速度都能得到提升。
编程示例：使用集合通信计算积分
用梯形法计算函数 f(x) = x² 在区间 [0, 10] 上的定积分：
#include <mpi.h>
#include <stdio.h>
#define N 100000000 // 总区间数
#define A 0.0
#define B 10.0
int main(int argc, char **argv) {
int myid, numprocs;
double local_sum = 0.0, global_sum;
double dx = (B - A) / N;
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &myid);
MPI_Comm_size(MPI_COMM_WORLD, &numprocs);
// 每个进程计算一部分矩形面积
for (int i = myid; i < N; i += numprocs) {
double x = A + i * dx + dx / 2; // 矩形中心点
local_sum += x * x * dx; // 矩形面积
}
// 使用 Reduce 将各进程的局部和规约为全局和
MPI_Reduce(&local_sum, &global_sum, 1, MPI_DOUBLE,
MPI_SUM, 0, MPI_COMM_WORLD);
if (myid == 0)
printf("Integral of x^2 in [0, 10] = %.15f\n", global_sum);
MPI_Finalize();
return 0;
}
这个例子中，N 个矩形按循环方式分配给各进程（进程 myid 处理第 myid、myid+numprocs、myid+2×numprocs... 个矩形），最后通过 MPI_Reduce 求和得到积分值。理论值为 1000/3 ≈ 333.333...。
OpenMP 编程
OpenMP 是共享内存系统的并行编程模型，通过编译器指令（pragma）实现并行化。程序员只需在代码中添加注释形式的指令，编译器会自动生成多线程代码。
核心概念
- 并行区域（Parallel Region）：由
#pragma omp parallel标识的代码块，由多个线程同时执行 - 工作共享构造（Work-sharing Constructs）：将任务分配给线程，如
for、sections、single - 同步构造（Synchronization Constructs）：控制线程间的执行顺序，如
critical、atomic、barrier - 数据共享属性：
shared（共享）、private（私有）、reduction（规约）
基本语法
#include <omp.h>
int main() {
// 并行区域
#pragma omp parallel
{
int tid = omp_get_thread_num();
printf("Hello from thread %d\n", tid);
}
// 并行化 for 循环
int sum = 0;
#pragma omp parallel for reduction(+:sum)
for (int i = 0; i < N; i++) {
sum += a[i];
}
return 0;
}
编程示例：矩阵乘法
矩阵乘法 C = A × B 的并行化：
#include <omp.h>
#include <stdio.h>
#include <stdlib.h>
#define N 1000
void matrix_multiply(double A[N][N], double B[N][N], double C[N][N]) {
// 外层循环并行化，内层循环顺序执行
#pragma omp parallel for collapse(2)
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
C[i][j] = 0.0;
for (int k = 0; k < N; k++) {
C[i][j] += A[i][k] * B[k][j];
}
}
}
}
int main() {
double A[N][N], B[N][N], C[N][N];
// 初始化矩阵
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
A[i][j] = rand() / (double)RAND_MAX;
B[i][j] = rand() / (double)RAND_MAX;
}
}
double start = omp_get_wtime();
matrix_multiply(A, B, C);
double end = omp_get_wtime();
printf("Matrix multiplication took %.3f seconds\n", end - start);
return 0;
}
编译和运行：
编程示例：并行排序
使用 OpenMP 实现并行归并排序：
#include <omp.h>
#include <stdio.h>
#include <stdlib.h>
void merge(int arr[], int left, int mid, int right) {
int n1 = mid - left + 1;
int n2 = right - mid;
int *L = (int *)malloc(n1 * sizeof(int));
int *R = (int *)malloc(n2 * sizeof(int));
for (int i = 0; i < n1; i++)
L[i] = arr[left + i];
for (int j = 0; j < n2; j++)
R[j] = arr[mid + 1 + j];
int i = 0, j = 0, k = left;
while (i < n1 && j < n2) {
if (L[i] <= R[j]) {
arr[k++] = L[i++];
} else {
arr[k++] = R[j++];
}
}
while (i < n1) arr[k++] = L[i++];
while (j < n2) arr[k++] = R[j++];
free(L);
free(R);
}
void parallel_merge_sort(int arr[], int left, int right, int depth) {
if (left < right) {
int mid = left + (right - left) / 2;
if (depth < 3) { // 限制并行深度，避免过度创建线程
#pragma omp parallel sections
{
#pragma omp section
parallel_merge_sort(arr, left, mid, depth + 1);
#pragma omp section
parallel_merge_sort(arr, mid + 1, right, depth + 1);
}
} else {
parallel_merge_sort(arr, left, mid, depth + 1);
parallel_merge_sort(arr, mid + 1, right, depth + 1);
}
merge(arr, left, mid, right);
}
}
int main() {
int N = 1000000;
int *arr = (int *)malloc(N * sizeof(int));
// 初始化数组
for (int i = 0; i < N; i++) {
arr[i] = rand();
}
double start = omp_get_wtime();
parallel_merge_sort(arr, 0, N - 1, 0);
double end = omp_get_wtime();
printf("Parallel merge sort took %.3f seconds\n", end - start);
// 验证排序结果
for (int i = 0; i < N - 1; i++) {
if (arr[i] > arr[i + 1]) {
printf("Sort failed!\n");
break;
}
}
free(arr);
return 0;
}
CUDA 编程
CUDA 是 NVIDIA 的 GPU 通用计算编程模型。GPU 拥有数千个轻量级核心，擅长数据并行——同一指令同时作用于大量数据。
GPU 架构
graph TB
subgraph GPU
subgraph SM1[SM 0]
T0[Thread 0]
T1[Thread 1]
T2[Thread ...]
T31[Thread 31]
end
subgraph SM2[SM 1]
T32[Thread 0]
T33[Thread 1]
T34[Thread ...]
T63[Thread 31]
end
subgraph SMn[SM n]
Tn0[Thread 0]
Tn1[Thread 1]
Tn2[Thread ...]
Tn31[Thread 31]
end
end
CPU[CPU] -->|数据传输| GPUGPU 由多个流多处理器（SM）组成，每个 SM 包含多个CUDA 核心。线程以Warp（32 个线程）为单位执行，同一 Warp 内的线程执行相同的指令。
核心概念
- 核函数（Kernel）：在 GPU 上执行的函数，由所有线程并行执行
- 线程层次：Thread → Block → Grid
- 内存层次：寄存器 → 共享内存 → 全局内存
基本语法
// GPU 核函数
__global__ void vectorAdd(float *a, float *b, float *c, int n) {
int i = blockIdx.x * blockDim.x + threadIdx.x;
if (i < n) {
c[i] = a[i] + b[i];
}
}
int main() {
int n = 1000000;
size_t size = n * sizeof(float);
// 分配主机内存
float *h_a = (float *)malloc(size);
float *h_b = (float *)malloc(size);
float *h_c = (float *)malloc(size);
// 分配设备内存
float *d_a, *d_b, *d_c;
cudaMalloc(&d_a, size);
cudaMalloc(&d_b, size);
cudaMalloc(&d_c, size);
// 初始化数据
for (int i = 0; i < n; i++) {
h_a[i] = rand() / (float)RAND_MAX;
h_b[i] = rand() / (float)RAND_MAX;
}
// 将数据从主机复制到设备
cudaMemcpy(d_a, h_a, size, cudaMemcpyHostToDevice);
cudaMemcpy(d_b, h_b, size, cudaMemcpyHostToDevice);
// 启动核函数
int blockSize = 256;
int numBlocks = (n + blockSize - 1) / blockSize;
vectorAdd<<<numBlocks, blockSize>>>(d_a, d_b, d_c, n);
// 将结果从设备复制回主机
cudaMemcpy(h_c, d_c, size, cudaMemcpyDeviceToHost);
// 验证结果
for (int i = 0; i < n; i++) {
if (fabs(h_c[i] - (h_a[i] + h_b[i])) > 1e-5) {
printf("Verification failed!\n");
break;
}
}
// 释放内存
cudaFree(d_a);
cudaFree(d_b);
cudaFree(d_c);
free(h_a);
free(h_b);
free(h_c);
return 0;
}
编程示例：矩阵乘法
使用 CUDA 实现矩阵乘法：
#define BLOCK_SIZE 16
__global__ void matrixMultiply(float *A, float *B, float *C, int N) {
int row = blockIdx.y * blockDim.y + threadIdx.y;
int col = blockIdx.x * blockDim.x + threadIdx.x;
if (row < N && col < N) {
float sum = 0.0f;
for (int k = 0; k < N; k++) {
sum += A[row * N + k] * B[k * N + col];
}
C[row * N + col] = sum;
}
}
int main() {
int N = 1024;
size_t size = N * N * sizeof(float);
// 分配和初始化主机内存
float *h_A = (float *)malloc(size);
float *h_B = (float *)malloc(size);
float *h_C = (float *)malloc(size);
for (int i = 0; i < N * N; i++) {
h_A[i] = rand() / (float)RAND_MAX;
h_B[i] = rand() / (float)RAND_MAX;
}
// 分配设备内存
float *d_A, *d_B, *d_C;
cudaMalloc(&d_A, size);
cudaMalloc(&d_B, size);
cudaMalloc(&d_C, size);
// 复制数据到设备
cudaMemcpy(d_A, h_A, size, cudaMemcpyHostToDevice);
cudaMemcpy(d_B, h_B, size, cudaMemcpyHostToDevice);
// 配置执行参数
dim3 blockSize(BLOCK_SIZE, BLOCK_SIZE);
dim3 gridSize((N + BLOCK_SIZE - 1) / BLOCK_SIZE,
(N + BLOCK_SIZE - 1) / BLOCK_SIZE);
// 启动核函数
matrixMultiply<<<gridSize, blockSize>>>(d_A, d_B, d_C, N);
// 复制结果回主机
cudaMemcpy(h_C, d_C, size, cudaMemcpyDeviceToHost);
// 释放内存
cudaFree(d_A);
cudaFree(d_B);
cudaFree(d_C);
free(h_A);
free(h_B);
free(h_C);
return 0;
}
优化：共享内存
使用共享内存优化矩阵乘法，减少全局内存访问：
#define BLOCK_SIZE 16
__global__ void matrixMultiplyShared(float *A, float *B, float *C, int N) {
__shared__ float sA[BLOCK_SIZE][BLOCK_SIZE];
__shared__ float sB[BLOCK_SIZE][BLOCK_SIZE];
int row = blockIdx.y * BLOCK_SIZE + threadIdx.y;
int col = blockIdx.x * BLOCK_SIZE + threadIdx.x;
float sum = 0.0f;
for (int k = 0; k < N; k += BLOCK_SIZE) {
// 加载数据到共享内存
sA[threadIdx.y][threadIdx.x] = A[row * N + k + threadIdx.x];
sB[threadIdx.y][threadIdx.x] = B[(k + threadIdx.y) * N + col];
__syncthreads(); // 同步，确保数据加载完成
// 计算部分结果
for (int i = 0; i < BLOCK_SIZE; i++) {
sum += sA[threadIdx.y][i] * sB[i][threadIdx.x];
}
__syncthreads(); // 同步，确保计算完成
}
C[row * N + col] = sum;
}
性能优化技术
数据局部性优化
循环分块（Loop Tiling）：将大循环分解为小块，使每块数据能放入缓存。
// 未优化版本
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
C[i][j] = A[i][j] + B[i][j];
}
}
// 循环分块版本
int block_size = 32;
for (int ii = 0; ii < N; ii += block_size) {
for (int jj = 0; jj < N; jj += block_size) {
for (int i = ii; i < min(ii + block_size, N); i++) {
for (int j = jj; j < min(jj + block_size, N); j++) {
C[i][j] = A[i][j] + B[i][j];
}
}
}
}
数据布局优化：将结构体数组（AoS）改为数组结构体（SoA），提高缓存命中率。
// AoS (Array of Structures) - 缓存不友好
struct Point {
float x, y, z;
};
Point points[N];
// SoA (Structure of Arrays) - 缓存友好
struct Points {
float x[N];
float y[N];
float z[N];
};
Points points;
向量化
利用 SIMD 指令（如 SSE、AVX）同时处理多个数据元素：
// 标量版本
for (int i = 0; i < N; i++) {
c[i] = a[i] + b[i];
}
// 向量化版本（使用 AVX-512，每次处理 16 个 float）
#include <immintrin.h>
void vector_add_avx512(float *a, float *b, float *c, int n) {
for (int i = 0; i < n; i += 16) {
__m512 va = _mm512_load_ps(&a[i]);
__m512 vb = _mm512_load_ps(&b[i]);
__m512 vc = _mm512_add_ps(va, vb);
_mm512_store_ps(&c[i], vc);
}
}
通信优化
- 计算与通信重叠：使用非阻塞通信，让计算和通信同时进行
- 集合通信优化：使用树形结构减少通信轮次
- 数据压缩：减少传输数据量
// 计算与通信重叠示例
MPI_Request request;
MPI_Irecv(recv_buf, count, MPI_DOUBLE, source, tag, MPI_COMM_WORLD, &request);
// 在等待通信完成的同时进行计算
compute_local_result();
// 等待通信完成
MPI_Wait(&request, MPI_STATUS_IGNORE);
// 使用接收到的数据
process_received_data();
并行算法设计模式
数据并行模式
将数据划分为多个块，每个处理器处理一个块。
graph LR
subgraph Input[输入数据]
D1[块 1]
D2[块 2]
D3[块 3]
D4[块 4]
end
subgraph Process[处理器]
P1[处理器 1]
P2[处理器 2]
P3[处理器 3]
P4[处理器 4]
end
subgraph Output[输出结果]
R1[结果 1]
R2[结果 2]
R3[结果 3]
R4[结果 4]
end
D1 --> P1 --> R1
D2 --> P2 --> R2
D3 --> P3 --> R3
D4 --> P4 --> R4任务并行模式
将不同的任务分配给不同的处理器。
graph TB
subgraph Tasks[任务]
T1[任务 A]
T2[任务 B]
T3[任务 C]
end
subgraph Processors[处理器]
P1[处理器 1]
P2[处理器 2]
P3[处理器 3]
end
T1 --> P1
T2 --> P2
T3 --> P3流水线模式
将计算分为多个阶段，不同处理器执行不同阶段。
graph LR
subgraph Stage1[阶段 1]
P1[处理器 1]
end
subgraph Stage2[阶段 2]
P2[处理器 2]
end
subgraph Stage3[阶段 3]
P3[处理器 3]
end
Input[输入] --> P1 --> P2 --> P3 --> Output[输出]分治模式
将问题递归分解为子问题，分别求解后合并结果。
graph TB
Problem[原始问题] --> Sub1[子问题 1]
Problem --> Sub2[子问题 2]
Problem --> Sub3[子问题 3]
Problem --> Sub4[子问题 4]
Sub1 --> R1[结果 1]
Sub2 --> R2[结果 2]
Sub3 --> R3[结果 3]
Sub4 --> R4[结果 4]
R1 --> Merge[合并]
R2 --> Merge
R3 --> Merge
R4 --> Merge
Merge --> Final[最终结果]HPC 应用领域
HPC 驱动着人类最雄心勃勃的科学探索：
| 领域 | 应用 | 特点 |
|---|---|---|
| 气象预报 | 全球大气模拟、气候预测 | 求解偏微分方程，数据密集 |
| 分子动力学 | 蛋白质折叠、药物设计 | 粒子相互作用，计算密集 |
| 天体物理 | 星系演化、引力波模拟 | N 体问题，长时程模拟 |
| 材料科学 | 新材料设计、相变模拟 | 量子力学计算，高精度 |
| 深度学习 | 大型语言模型训练 | 矩阵运算，数据并行 |
| 生物信息 | 基因组比对、蛋白质结构预测 | 海量数据，模式匹配 |
这些工作负载有一个共同特征：需要求解偏微分方程或模拟数百万个粒子在数百万个时间步长上的相互作用，每个步骤都需要巨大的浮点计算量。一次现代超级计算机上的模拟可能消耗数百万 CPU 小时，使得效率不仅令人向往，而且至关重要。
HPC 的特点与局限
优势：
- 灵活性好，适合各类计算密集型并行任务
- 独立于语言和平台，可移植性强
- 有丰富的开源和商业实现
- 能够处理单机无法完成的大规模计算任务
局限：
- 需要程序员手动处理数据划分、通信、同步等细节
- 编程复杂度高，调试困难
- 通信开销大，节点规模增大时性能下降明显
- 无内置的容错机制，节点失效可能导致整个计算失败
这些局限性正在推动 HPC 技术的不断发展。以下趋势正在改变 HPC 的面貌：
- 异构计算：现代超算普遍采用 CPU + GPU 混合架构。例如 Frontier 使用 AMD EPYC CPU + AMD Instinct MI250X GPU，El Capitan 使用 AMD CPU + AMD Instinct GPU。NVIDIA 的 H100/H200 和 AMD 的 MI300X 是当前主流加速器
- 百亿亿次计算（Exascale）：2022 年 Frontier 首次突破 10¹⁸ FLOPS 的百亿亿次大关，标志着 HPC 进入 Exascale 时代。截至 2025 年，全球已有 4 台 Exascale 系统（El Capitan、Frontier、Aurora、JUPITER）
- AI 与 HPC 融合：现代超算同时服务于科学模拟和深度学习训练。HPL-AI 混合精度基准测试模糊了 AI 和 HPC 的性能界限
- 云 HPC：AWS、Azure、Google Cloud 提供 HPC 即服务（HPC-as-a-Service），降低了超算的使用门槛