1. 从讲台到集群：一次HPC暑期学校的MATLAB教学实战

每年夏天，全球各地都会涌现出各种高性能计算暑期学校，它们像一个个临时的技术熔炉，将来自不同背景的学生和研究者聚集在一起，在几周内密集地灌输并行计算的思想和技能。2024年的EUMaster4HPC暑期学校就是其中之一，而我今年的角色，是站在讲台上，负责教授MATLAB在HPC环境下的应用。这听起来可能有些反直觉——MATLAB，这个以交互式桌面环境闻名的科学计算语言，如何与动辄成千上万个计算核心的超级计算机产生关联？这正是课程的核心，也是许多初入HPC领域的研究者最容易忽视的盲区。我的任务，就是打通从个人工作站到大型集群的认知壁垒，让参与者明白，MATLAB不仅仅是一个强大的分析工具，更可以成为一个高效的大规模并行计算入口。

这门课面向的，主要是那些已经熟悉MATLAB基础操作，但在处理更大规模数据集或更复杂仿真时感到力不从心的硕士、博士生以及早期职业研究人员。他们可能精通各种工具箱里的函数，能流畅地写出脚本进行数据分析，但当问题规模扩大到需要数小时甚至数天才能完成一次计算时，就遇到了瓶颈。他们来参加HPC暑期学校，目标很明确：学习如何利用强大的计算资源加速自己的工作流。而我的MATLAB课程，就是要告诉他们，你不需要完全抛弃熟悉的MATLAB生态，转而去从头学习MPI、OpenMP等底层并行编程模型；相反，你可以通过一系列策略和工具，让你现有的MATLAB代码“飞”起来，直接驾驭HPC集群的强大算力。

在接下来的内容里，我不会仅仅复述官方文档，而是结合这次暑期学校教学中的真实案例、学员遇到的典型问题以及我作为讲师和长期用户的实战经验，拆解MATLAB与HPC结合的完整路径。我们会从最根本的“为什么要在HPC上用MATLAB”开始，逐步深入到代码并行化策略、集群作业提交、性能剖析与优化，最后探讨一些进阶的混合编程思路。无论你是正在考虑将MATLAB工作负载迁移到集群的用户，还是对科学计算与高性能计算交叉领域感兴趣的学习者，希望这篇基于真实教学实践的总结能给你带来切实的启发和可操作的指南。

2. 破除迷思：为什么MATLAB需要HPC，以及HPC为何需要MATLAB

在深入技术细节之前，我们必须先建立一个共识：MATLAB与HPC的结合，并非简单的工具堆砌，而是一种计算范式的扩展。很多学员最初带着疑问：“我的代码在笔记本上跑得好好的，为什么要费劲搬到集群上？”或者相反：“HPC不是都用C++/Fortran配合MPI吗？用MATLAB是不是效率太低了？”这两种观点都源于对两者能力的片面理解。

2.1 MATLAB的算力瓶颈与HPC的破局点

MATLAB作为一个集成化的高级语言环境，其优势在于快速的算法原型开发、丰富的内置数学函数和可视化工具。然而，当面临以下典型场景时，单机版的MATLAB就会捉襟见肘：

  1. 参数扫描与大规模仿真 ：例如，在计算流体动力学中，你需要对数十种不同的湍流模型参数进行测试；在系统生物学中，需要对一个包含成千上万个微分方程的模型进行上万次蒙特卡洛模拟。这类“令人尴尬的并行”问题，其计算任务彼此独立，天然适合分配到大量计算节点上同时进行。在单机上，你只能顺序执行，耗时以周甚至月计；而在HPC集群上，可以同时启动数百个任务，将总时间压缩到小时级别。

  2. 超大规模矩阵运算 ：虽然MATLAB的底层线性代数库（如Intel MKL）已经高度优化，但单机内存容量限制了可处理问题的规模。一个100k x 100k的双精度稠密矩阵就需要约80GB的内存，这超出了大多数工作站的极限。HPC集群的分布式内存架构，使得通过 spmd （单程序多数据）或 distributed 数组处理这类超大规模矩阵成为可能。

  3. 数据密集型预处理与后处理 ：现代科学实验产生的数据集（如天文图像、基因测序数据、气候模型输出）动辄达到TB级别。在单机上，仅仅是读取和初步筛选这些数据就可能耗尽内存和时间。HPC集群不仅提供巨大的并行I/O带宽，还可以利用MATLAB的 tall 数组对无法装入内存的数据进行“懒评估”式处理。

在这次暑期学校的一个案例中，一位从事计算电磁学的研究生就遇到了典型的第一类问题。他需要仿真一个复杂天线阵列在不同频率和入射角下的辐射特性，这构成了一个二维参数空间。在本地，完成一次全参数扫描需要近一周。通过将仿真脚本改写为接受参数输入的独立函数，并利用MATLAB Parallel Server的批处理作业功能，我们将任务分解成上千个独立作业提交到集群。最终，整个参数扫描在2小时内完成，效率提升超过80倍。这个案例生动地说明了，HPC对于MATLAB用户而言，核心价值在于 将“等待时间”转化为“探索时间” ，让研究者能更快地进行迭代和发现。

2.2 MATLAB为HPC生态带来的独特价值

反过来看，MATLAB也为HPC社区带来了其特有的价值，这尤其体现在降低并行编程门槛和加速研究周期上。

  • 降低并行编程的认知负荷 ：传统的MPI编程需要处理进程间通信、数据分发、死锁避免等一系列复杂问题，学习曲线陡峭。MATLAB提供了更高层次的抽象，例如 parfor 循环用于任务并行， spmd 用于数据并行，用户无需直接管理进程和消息，只需关注算法逻辑本身。这对于那些核心专长在物理学、生物学、金融学等领域而非计算机科学的研究者来说，是巨大的福音。

  • 无缝集成与快速验证 ：研究者可以在熟悉的MATLAB环境中快速开发并验证算法的正确性，然后几乎无需重写核心逻辑，就能将其扩展到集群上运行。这种“写一次，到处跑”的能力，保护了宝贵的研究代码资产，也加快了从想法到大规模验证的进程。

  • 丰富的工具箱生态 ：MATLAB拥有超过50个专业工具箱，覆盖信号处理、图像处理、控制系统、深度学习等众多领域。这些工具箱中的许多函数本身就支持GPU加速或并行计算。在HPC集群上，用户可以直接调用这些高度优化的并行函数，相当于直接利用了一个经过多年打磨的并行算法库。

注意：一个常见的误解是认为MATLAB在集群上运行效率低下。实际上，MATLAB Parallel Server的客户端-服务器架构中，客户端只负责提交作业和收集结果，真正的计算负载是由部署在计算节点上的MATLAB工作进程执行的。这些工作进程运行的是经过编译优化的MEX函数或内置的并行算法，其计算效率在多数场景下与原生编译代码相差不大，尤其是当计算密集型部分由MATLAB内置的并行函数（如 pagefun 用于GPU数组）或通过MATLAB Coder生成的代码承担时。

3. 实战准备：从桌面到集群的环境配置与思维转换

将MATLAB工作流迁移到HPC集群，第一步不是改代码，而是配置环境和转变思维。这次暑期学校中，我们花了相当一部分时间帮助学员完成这个“登陆”过程。许多问题都源于对集群环境的不熟悉。

3.1 集群环境下的MATLAB访问模式

通常，在HPC集群上使用MATLAB有三种主要模式，你需要根据任务特性和集群政策来选择：

  1. 交互式并行池（Interactive Parallel Pool） ：通过SSH连接到集群的登录节点，在命令行启动MATLAB，并使用 parpool 命令在后台的计算节点上启动一个并行工作进程池。随后，你可以在交互式会话中直接运行 parfor 或 spmd 代码。这种方式 仅适用于短时间、小规模的测试和调试 ，因为登录节点资源有限，且长时间占用交互式资源通常被集群管理员禁止。

  2. 批处理作业（Batch Job） ：这是生产级计算最常用、最规范的方式。你将MATLAB脚本或函数封装成一个独立的作业脚本（通常是Slurm、PBS等作业调度系统的脚本），通过命令（如 sbatch ）提交到作业队列。作业调度器会在资源可用时，在指定的计算节点上分配资源并运行你的MATLAB程序。运行结果（标准输出、错误日志、数据文件）会保存在指定位置。这种方式完全脱离了交互式桌面，适合长时间、大规模的计算。

  3. MATLAB Parallel Server的集群配置文件 ：对于需要频繁提交作业的用户，可以创建和使用集群配置文件。在MATLAB桌面环境中，通过“Parallel”菜单创建指向集群的配置文件，配置好作业存储位置、提交函数等。之后，就可以直接在桌面MATLAB中创建“集群作业”，像在本地提交一样方便，而实际执行则在远程集群上。这提供了极大的便利性。

在暑期学校，我们强制要求所有学员从第一种模式（交互式调试）快速过渡到第二种模式（批处理作业），因为这才是HPC的正确使用姿势。我们提供了一个标准的Slurm作业脚本模板：

#!/bin/bash
#SBATCH --job-name=matlab_hpc_demo
#SBATCH --output=result_%j.out
#SBATCH --error=error_%j.err
#SBATCH --time=01:00:00
#SBATCH --ntasks=1
#SBATCH --cpus-per-task=8
#SBATCH --mem=16G

# 加载MATLAB模块（具体命令因集群而异）
module load matlab/R2023a

# 进入工作目录
cd $SLURM_SUBMIT_DIR

# 以非交互式批处理模式运行MATLAB脚本
# -nodisplay: 无图形显示
# -nosplash: 不显示启动画面
# -r: 运行指定命令后退出
matlab -nodisplay -nosplash -r "my_parallel_script; exit"

这个脚本请求1个任务（一个MATLAB进程），但该任务可以使用8个CPU核心（ --cpus-per-task=8 ）和16GB内存。在MATLAB脚本 my_parallel_script.m 中，我们可以通过 parpool('local', 8) 在本地（即该作业分配到的节点上）启动一个包含8个工作进程的并行池。

3.2 代码的“集群友好化”改造

你的桌面MATLAB代码通常不能直接扔到集群上就跑。需要做一些适应性修改：

  • 路径与依赖管理 ：集群的计算节点可能无法访问你的本地硬盘。必须将所有依赖的脚本、函数、数据文件通过作业脚本复制到集群的共享存储（如 $SCRATCH ）或通过绝对路径引用。使用 addpath(genpath('.')) 添加当前目录所有子目录到路径是一种简单粗暴但有效的方法，但更好的做法是在脚本开头清晰地添加所需路径。

  • 避免图形化交互和文件对话框 ：批处理作业没有图形界面。所有像 input 、 ginput 、 uigetfile 这样的交互命令都必须被移除或替换为硬编码的参数。图形绘制命令（如 plot ）虽然可以执行，但如果没有设置合适的输出（如保存为 png 或 fig 文件），将不会产生任何可见输出。

  • 善用日志输出 ：在桌面环境，你可以随时在命令行窗口看到 disp 和 fprintf 的输出。在批处理作业中，这些输出会被重定向到Slurm指定的输出文件（如上面的 result_%j.out ）。因此，在代码的关键阶段（如循环开始、结束、发生错误时）添加带时间戳的日志输出，对于事后调试和监控作业进度至关重要。我常使用 fprintf('[%s] Iteration %d started.\n', datestr(now), i); 这样的格式。

  • 参数化你的脚本 ：将需要变化的参数（如输入文件名、仿真参数、输出目录）通过脚本的命令行参数或环境变量传入，而不是写死在代码里。这样，你可以轻松地生成一系列作业脚本，用于参数扫描。MATLAB可以通过 getenv 函数读取环境变量，也可以通过解析 varargin 来接收命令行参数（当通过 -r 传递时需注意格式）。

4. 并行化策略深度解析：选择正确的武器

MATLAB提供了多种并行编程范式，选择哪一种取决于你的问题结构和数据特性。教学中最关键的就是帮助学员建立这种“问题-策略”的映射关系。

4.1 任务并行（Task Parallelism）： parfor 循环

这是最直观、最常用的并行模式，适用于循环迭代间彼此独立无依赖的情况。

% 串行版本
results = zeros(1, N);
for i = 1:N
    results(i) = timeConsumingFunction(inputData(i));
end

% 并行版本
parpool('local', 8); % 启动包含8个工作进程的并行池
results = zeros(1, N);
parfor i = 1:N
    results(i) = timeConsumingFunction(inputData(i));
end
delete(gcp); % 关闭并行池

核心要点与避坑指南：

  • 数据分类（Broadcast, Sliced, Reduction） ： parfor 要求循环变量（ i ）是连续的整数。循环体内的变量会被自动分类。 inputData 是“切片（Sliced）”变量，每个工作进程获取其对应 i 的部分。在循环外定义的 results 也是切片变量，每个进程写入不同的位置。如果有一个在循环内被累加的变量（如 totalSum = totalSum + x(i) ），它会被识别为“归约（Reduction）”变量，MATLAB会自动处理线程安全的累加。而一些只读的配置参数，则会被“广播（Broadcast）”到所有工作进程。理解这个自动分类机制是写出正确 parfor 代码的关键。

  • 避免“parfor 迷信” ：不是所有 for 循环改成 parfor 都能加速。如果每次迭代的计算量极小（微秒级），那么进程间通信和任务调度的开销可能会远大于计算本身，导致并行后反而更慢。一个经验法则是，单次迭代的计算时间至少应在0.1秒以上，并行才有收益。可以使用 ticBytes 和 tocBytes 来估算通信开销。

  • 嵌套循环的处理 ：通常只并行化最外层的、迭代次数多的循环。并行化内层循环会导致每个工作进程内部再启动并行，引发“嵌套并行”，可能造成资源竞争和性能下降。如果内外层循环都可并行且无依赖，可以考虑使用 parfor 配合 spmd 进行更复杂的嵌套并行，但这需要更精细的控制。

4.2 数据并行（Data Parallelism）： spmd 单程序多数据

spmd 允许你将数据显式地分布到多个工作进程（称为“Labor”），每个进程对各自的数据块执行相同的程序。这特别适合处理单个大型数组。

parpool('local', 4);
spmd
    % 每个工作进程都有一个独立的变量 labindex (1,2,3,4)
    % 我们将一个大数组分布式地创建
    if labindex == 1
        myPart = magic(500); % 进程1创建一部分
    else
        myPart = zeros(500); % 其他进程创建零矩阵
    end
    % 通过 codistributed 数组在进程间同步和分发
    D = codistributed(myPart, codistributor1d(2)); % 沿第二维分布
    % 每个进程现在只持有D的一部分，但可以像操作普通数组一样操作D
    localPart = getLocalPart(D); % 获取本地部分
    % 对分布式数组进行运算（如FFT）会自动在多个进程上并行执行
    result = fft(D);
end
delete(gcp);

核心要点与避坑指南：

  • 理解 codistributed 数组 ：这是 spmd 模式下的核心数据结构。它逻辑上是一个完整的数组，但物理上被分割成块存储在不同工作进程的内存中。许多MATLAB内置函数（如 fft , sum , * （矩阵乘法））已经重载，可以透明地操作 codistributed 数组，在后台进行必要的进程间通信和计算。

  • 通信开销是性能关键 ： spmd 模式下的操作如果涉及不同进程持有的数据块之间的交互（例如转置、某些维度的求和），就会触发进程间通信。通信速度远慢于内存访问。因此，算法设计应尽量让计算局限于每个进程的本地数据块（ getLocalPart(D) ），减少通信频率和数据量。

  • spmd vs parfor ：简单来说， parfor 是“多个任务，不同数据（或相同数据的不同部分）”，侧重任务分发； spmd 是“相同任务，数据被分块”，侧重数据分发。对于需要在整个大数组上进行线性代数运算的问题， spmd 配合分布式数组通常更高效。

4.3 超越CPU：利用GPU加速

现代HPC集群通常配备有GPU节点。MATLAB通过 gpuArray 提供了极为便捷的GPU编程接口。

% 将数据从CPU内存转移到GPU显存
A_cpu = rand(5000, 5000);
A_gpu = gpuArray(A_cpu);

% 在GPU上进行计算（语法与CPU数组几乎完全一致）
B_gpu = A_gpu * A_gpu'; % 矩阵乘法在GPU上执行
C_gpu = fft(A_gpu);     % FFT在GPU上执行

% 将结果取回CPU内存
B_cpu = gather(B_gpu);

核心要点与避坑指南：

  • 显存限制 ：GPU显存容量远小于系统内存。必须确保待处理的数据（包括输入、输出和中间变量）能放入显存。对于超大规模数据，需要结合 spmd 将数据分布到多个GPU上，或者采用“核外计算”策略，分批将数据送入GPU。

  • 适合GPU的计算特征 ：GPU擅长高度并行、计算密集、控制逻辑简单的运算，如大规模矩阵/向量运算、图像卷积、深度学习训练/推理。对于包含大量 if-else 分支、递归或串行依赖严重的算法，GPU加速效果可能不佳，甚至更慢。

  • CPU-GPU数据传输瓶颈 ： gpuArray 和 gather 操作涉及PCIe总线上的数据传输，这是昂贵的。最佳实践是尽可能在GPU上完成整个计算流水线，只在最初将数据送入GPU，最终将结果取回，避免在CPU和GPU之间来回拷贝数据。

在暑期学校的实践中，我们让学员用同一个图像滤波算法分别实现CPU多核并行（ parfor ）和GPU加速版本，然后对比运行时间。对于一张4K图像，GPU版本通常能带来数十倍的加速，这直观地展示了异构计算的优势。同时，我们也强调了数据搬运成本：如果只是对一张小图做一次滤波，数据传输开销可能会抵消掉GPU的计算优势。

5. 性能剖析与优化：让代码在集群上真正“飞”起来

将代码并行化并成功在集群上运行，只是第一步。接下来需要像侦探一样，找出性能瓶颈并优化。MATLAB提供了强大的性能剖析工具。

5.1 使用MATLAB Profiler和Parallel Profiler

在桌面环境，先用Profiler分析串行代码的热点。

profile on
my_serial_function(); % 运行你的串行代码
profile viewer

Profiler会列出所有被调用函数及其耗时，帮助你找到最耗时的函数（通常是内层循环或某个特定算法）。这是优化的首要目标。

对于并行代码，必须使用 Parallel Profiler 。在运行 parfor 或 spmd 代码时，通过 mpiprofile 来收集数据。

mpiprofile on
% 运行你的并行代码，例如包含parfor的代码
my_parallel_function();
mpiprofile viewer

Parallel Profiler会展示每个工作进程（Labor）的执行时间线、通信时间、空闲时间等。一个健康的并行执行图，应该是各个进程的计算条带（红色）饱满且均匀，通信条带（蓝色）短暂。如果你看到某个进程长时间空闲，或者通信时间占比过高，就说明存在负载不均衡或通信瓶颈。

5.2 典型性能问题与调优策略

根据这次教学和以往经验，以下是一些常见瓶颈及解决方法：

  1. 负载不均衡（Load Imbalance） ：

    • 现象 ：Parallel Profiler显示各工作进程计算时间差异很大，有的早早结束进入空闲等待。
    • 根因 ： parfor 循环中每次迭代的计算量不同。默认情况下，MATLAB以“静态调度”方式分配迭代，即提前将循环范围平均分块给各进程。如果迭代1很快，迭代100很慢，分配到慢迭代的进程就会成为拖累。
    • 解决方案 ：使用 parfor 的附加调度方案。 parfor (i = 1:N, chunksize) 可以指定块大小。更有效的是，如果迭代间耗时差异有规律，可以尝试随机打乱迭代顺序，或者使用 parfeval 进行更动态的任务调度。对于完全无规律的耗时， parfeval 和 afterEach 组合是高级解决方案，它实现了工作窃取（work-stealing）模式。

  2. 过度通信（Excessive Communication） ：

    • 现象 ：Parallel Profiler中通信条带（蓝色）又长又多，甚至超过计算时间。
    • 根因 ：在 spmd 块内频繁访问 codistributed 数组的全局属性，或在 parfor 循环中频繁读取/写入大型广播变量。
    • 解决方案 ：
      • 对于 spmd ，尽量减少对分布式数组的全局操作。如果可能，先将分布式数组的本地部分（ getLocalPart(D) ）取出，在本地进行计算，最后再组合。
      • 对于 parfor ，检查循环体内是否频繁读取一个巨大的只读数组。确保它是“广播（Broadcast）”变量而非“切片（Sliced）”变量。如果广播变量太大，可以考虑将其拆分成多个小变量，或使用 parallel.pool.Constant 将其封装为常量，这样它只会被复制到各工作进程一次，而不是在每次迭代中传递引用。

  3. 内存瓶颈（Memory Bottleneck） ：

    • 现象 ：作业运行缓慢，甚至因内存不足（Out of Memory）而崩溃。在集群上，这可能表现为单个节点内存耗尽。
    • 根因 ：每个MATLAB工作进程都会复制一份广播变量。如果有一个500MB的只读数据，在8个进程的并行池中，总内存占用就是4GB！此外，在 parfor 中不当创建大型临时数组也会导致内存激增。
    • 解决方案 ：
      • 使用 parallel.pool.Constant 包装大型只读数据。
      • 在 parfor 循环内，及时用 clear 清理不再需要的大型临时变量。
      • 考虑使用 tall 数组处理超出内存的数据集，它会在后台进行分块处理。
      • 在提交作业时，根据预估的内存使用量，向调度器（如Slurm）请求足够但不过量的内存（ --mem ）。请求过多会导致作业排队时间变长；请求过少会导致作业失败。

  4. I/O竞争（I/O Contention） ：

    • 现象 ：当数百个作业同时运行时，每个作业都试图从共享文件系统读取输入数据或写入结果，导致I/O速度急剧下降，成为整个流程的瓶颈。
    • 解决方案 ：
      • 阶段化I/O ：如果可能，在作业开始前，将每个任务所需的数据从共享存储复制到计算节点的本地临时存储（如 $TMPDIR ）。计算完成后，先将结果写入本地，再统一拷贝回共享存储。这利用了节点本地SSD的高速度。
      • 使用并行文件系统特性 ：如果集群使用Lustre等并行文件系统，可以尝试将输出写入不同的OST（Object Storage Target），以分散负载。但这通常需要管理员权限或特定配置。
      • 简化输出 ：避免每个进程都写入大量小文件或频繁写入。尽量在内存中聚合结果，最后由一个进程（如客户端或 spmd 中的Lab 1）进行一次性写入。

6. 超越内置并行：混合编程与集群作业管理进阶

当内置的 parfor 和 spmd 无法满足需求，或者需要与现有HPC生态深度集成时，就需要更进阶的技术。

6.1 调用外部编译代码：MEX文件与系统命令

MATLAB可以通过MEX接口调用C/C++或Fortran编写的函数，也可以直接执行系统命令。这在HPC环境下非常有用。

  • MEX文件 ：如果你有性能至关重要的核心算法，可以用C/C++编写并编译成MEX文件。在集群上使用MEX文件需要注意：

    • 编译环境必须与计算节点的运行时环境兼容。最好在集群的登录节点上，使用集群提供的相同编译器模块来编译你的MEX文件。
    • 如果MEX文件本身使用了多线程（如OpenMP），需要小心处理与MATLAB并行池的线程交互，避免过度订阅CPU资源。通常建议在MEX文件中关闭多线程，或者通过环境变量（如 OMP_NUM_THREADS ）严格控制线程数。

  • 系统命令 ：使用 system 或 ! 命令可以调用任何已安装在计算节点上的命令行工具。例如，你可以用MATLAB作为“胶水”脚本，调用一个用C++和MPI编写的传统HPC程序，然后读取其输出文件进行后续分析。

    % 在MATLAB作业脚本中调用外部MPI程序
mpiCommand = 'mpirun -np 16 ./my_mpi_program input.dat';
[status, cmdout] = system(mpiCommand);
if status == 0
    data = readOutputFile('output.dat');
    % ... 进一步处理 data
else
    error('External MPI program failed: %s', cmdout);
end

    这种方式赋予了MATLAB工作流极大的灵活性，使其能够整合已有的HPC软件栈。

6.2 作业阵列（Job Arrays）与参数化扫描

对于大规模的参数扫描，手动编写几百个作业脚本是不现实的。作业调度器（如Slurm）的作业阵列功能是完美解决方案。你可以提交一个作业模板，但指定一个索引范围，调度器会自动生成一系列独立的作业。

#!/bin/bash
#SBATCH --job-name=param_scan
#SBATCH --output=result_%A_%a.out # %A 是作业ID， %a 是阵列索引
#SBATCH --error=error_%A_%a.err
#SBATCH --array=1-100 # 这是一个作业阵列，索引从1到100
#SBATCH --ntasks=1
#SBATCH --cpus-per-task=4

module load matlab/R2023a
cd $SLURM_SUBMIT_DIR

# 使用SLURM_ARRAY_TASK_ID环境变量作为参数
MATLAB_PARAM=$SLURM_ARRAY_TASK_ID

matlab -nodisplay -nosplash -r "mySimulationFunction($MATLAB_PARAM); exit"

在这个例子中，一个提交命令就启动了100个作业，每个作业的 SLURM_ARRAY_TASK_ID 环境变量分别为1到100。在MATLAB函数 mySimulationFunction 中，可以通过 str2double(getenv('SLURM_ARRAY_TASK_ID')) 获取这个索引值，并用它来决定加载哪组参数、使用哪个输入文件等。这是进行高通量计算（High-Throughput Computing）的标准模式。

6.3 使用MATLAB Parallel Server的编程作业（Programming Jobs）

对于更复杂的、需要动态任务分配或工作流管理的场景，可以使用MATLAB Parallel Server的编程作业API。这允许你在一个“客户端”MATLAB会话中，以编程方式创建、提交、监控和管理在集群上运行的“作业”和“任务”。

% 连接到集群
c = parcluster('MyClusterProfile');

% 创建一个作业
j = createJob(c);

% 创建多个任务（每个任务是一个函数调用）
for i = 1:100
    createTask(j, @mySimulationFunction, 1, {i}); % 参数为i
end

% 提交作业到集群
submit(j);

% 等待作业完成，并获取结果
wait(j);
results = fetchOutputs(j); % results是一个cell数组，包含每个任务的输出

% 清理
delete(j);

这种方式比批处理脚本更灵活，因为你可以根据中间结果动态地创建新任务，或者处理任务之间的依赖关系。它适合实现主从（Master-Worker）模式的计算框架。

7. 教学反思与给HPC新手的实用建议

为期数天的MATLAB for HPC课程结束了，但学员们的HPC之旅才刚刚开始。回顾整个教学过程，以及课后与学员的交流，我总结了几个最常被问到的问题和最具普适性的建议，这或许比某个具体的技术点更有价值。

首先，建立“性能分析优先”的思维习惯。 很多学员一上来就想把所有的 for 循环都改成 parfor 。我的第一个练习往往是让他们先用Profiler分析一段串行代码，找出真正耗时的“热点”。结果常常令人惊讶：80%的时间可能花在了某个文件读取函数或者一个看似简单的矩阵索引操作上。优化这个热点，可能带来10倍的串行加速，这比盲目并行化一个本来只占5%运行时间的循环要有效得多。记住阿姆达尔定律：并行化只能加速代码中可并行部分。所以，优化序列部分和并行化同样重要，甚至更重要。

其次，理解“数据移动”的成本。 在并行计算中，尤其是在分布式内存的集群上，数据在进程间或CPU与GPU间的移动成本非常高。一个优秀的并行算法设计，其目标是最大化计算/通信比。在动手写并行代码前，先画一画数据流图：哪些数据是每个进程都需要的（广播），哪些数据是进程独有的（分区），计算过程中需要交换哪些中间结果？尽量减少共享数据的体积，减少同步点的数量。有时候，为了减少通信，宁愿让每个进程冗余计算一小部分，也是值得的。

第三，从小规模测试开始，逐步放大。 不要第一次就在集群上提交一个需要256核、运行3天的大作业。大概率它会因为某个愚蠢的错误（比如路径错误、文件权限不对、内存估计不足）而迅速失败。正确的流程是：先在本地用多核工作站或笔记本电脑，用 parpool('local', 4) 启动一个小型并行池，测试你的代码逻辑和并行化是否正确。然后，在集群上申请少量资源（如2个节点，每个节点8核），运行一个缩短版本的测试（比如参数扫描只做10次而不是10000次）。确保一切正常，日志输出清晰，结果正确后，再逐步增加资源规模和问题规模。这种渐进式的方法能极大提高调试效率。

最后，拥抱社区和文档。 MATLAB的官方文档关于并行计算的部分写得相当全面，特别是“Parallel Computing Toolbox”和“MATLAB Parallel Server”的文档，包含了大量的示例和最佳实践。遇到问题时，仔细阅读错误信息，在MathWorks官网的社区论坛搜索，很可能已经有人遇到过相同的问题。同时，也要熟悉你所在HPC集群的特定环境：它使用什么作业调度器？有哪些可用的MATLAB版本？共享存储的路径是什么？计算节点有哪些硬件配置？与集群管理员和同事多交流，这些本地知识往往能帮你避开很多坑。

HPC不是魔法，MATLAB也不是HPC的“外行”。它们的结合，是一套让复杂计算变得触手可及的高级工具链。掌握它，意味着你能将个人的分析能力放大数十倍、数百倍，去解决那些曾经因为算力限制而无法触及的科学与工程问题。从桌面到集群，这一步跨出去，你看到的将是截然不同的风景。

Logo
脑启社区

脑启社区是一个专注类脑智能领域的开发者社区。欢迎加入社区，共建类脑智能生态。社区为开发者提供了丰富的开源类脑工具软件、类脑算法模型及数据集、类脑知识库、类脑技术培训课程以及类脑应用案例等资源。