TCB集群使用说明
集群概要
TCB（Theoretical computation of biology）集群是面向生物物理计算的高性能集群，坐落于中国科学院大学雁栖湖校区网络中心，配置了多个CPU计算节点，多块GPU计算卡和Inifinband网络等硬件资源；采用继承CentOS开源的Rocky Linux 9操作系统，保证系统的稳定性；采用NFS、GlusterFS分布式共享存储和Slurm作业管理系统，提供Module environment软件包管理，用户操作简单透明，致力于高效服务于科学计算研究，为分子模拟计算与人工智能计算提供专业的软硬件平台。
TCB集群始建于2014年，当时采用Rock Cluster的CentOS 6.3操作系统，40个CPU计算节点和装配了4块 Tesla C2075 GPU卡，其软硬件经过10年的服役已难以胜任计算任务，软件升级依赖库严重滞后、节点不稳定经常掉线。于是2024年5月间进行了系统的软硬件升级，卸载了不稳定的计算节点，换上了性能更好的4块V100 GPU和10块 RTX 4080 GPU，优化了infiniband网络连接，安装了最新的Rocky Linux 9.4操作系统，系统的稳定性和易用性显著提升，2024年12月又新增加2台 RTX 4090 8卡服务器，性能更强大。
- 集群管理联系：徐顺 alwintsui@icloud.com 本集群系统设计者；
- 在线用户手册：http://tcb.ucas.ac.cn/cluster 初版写于2024年6月5日，最近更新日期见文档尾部。
致谢TCB集群声明
如果您使用TCB集群服务还满意，请在论文发表或工作报告中积极致谢本集群，我们会一直全力为您提供满意的服务。
登录连接
集群登录节点支持SSH通过IPv4或IPv6两种方式连接，端口都是7010
-
IPv4地址域名为tcb.ucas.ac.cn，备份域名tcb.hpc4s.cn
-
IPv6地址域名为tcb6.hpc4s.cn
ssh命令行登录方式，以xushun用户名为例
或者使用IPv6方式
建议通过公钥方式登录，使用ssh-keygen产生一对密钥，默认保存在~/.ssh目录，再运行ssh-copy-id方式自动配置公钥：
下次就不用输入文本密码登录。
对于Windows客户端，建议使用MobaXterm终端连接软件，下载链接https://mobaxterm.mobatek.net/download.html，只需要下载安装免费的Home Edition版本即可，其功能已强过其他同类软件（如Xshell、Putty）。
在MobaXterm打开远程服务器连接后，在左侧文件目录树中，可用通过文件的内外拖拉进行上传和下载。
TCB集群普通用户名的命名规范
“姓”全拼+“名”，“名”首选全拼，如整体超7个字母，则取“名”中各字拼音的首字母，如有重名则加数字后缀。实例如xushun和zhangcb。
密码修改方式： TCB部署了NIS统一认证用户系统，普通用户修改密码使用yppasswd命令，不要用passwd命令。如果使用passwd命令修改密码，这很可能导致无法登录计算节点。可在login和各计算节点上使用ypasswd命令修改密码。类似的用ypchfn替代chfn， ypchsh替代chsh，它们功能是一致。
使用大语言模型
TCB部署了Llama3.1和通义千问（qwen2）等大语言模型，为本地离线工作形式，不涉及隐私数据泄漏，大模型参数达到70B，模型更智能。在login节点命令行，使用ch命令进入 大模型聊天交互模式，支撑中、英文等多种交互语言。
使用实例
[xushun@login ~]$ ch
>>> 请用C++语言写一个分子动力学模拟邻居列表构建的算法
在分子动力学（Molecular Dynamics, MD）模拟中，为了高效地计算系统中粒子的相互作用，通常会采用邻居列表（Neighbor List）方法来减少不必要的计算。
这是一个基本的C++代码示例，用以演示如何构建一个简单的邻居列表：
//此处省略以下内容，使用ch命令提问可查看完整的内容。
>>> 水的分子动力学模拟的力场模型有哪些
水的分子动力学模拟中常用的力场模型主要包括以下几种：
1. TIPnP系列力场（TIPnPs）：其中最著名的是TIP3P和TIP4P。这些力场通过不同的参数化来描述水分子的结构和性质，例如氢键角度、键长等。这些力场以其简单性和较高的计算效率而广
泛使用，但在一些情况下可能无法准确捕捉某些物理性质。
2. SPC/E（Simple Point Charge/Extended）力场：这是一个改进版的SPC力场，通过调整参数来更好地模拟水分子的热动力学性质。它比TIP3P更加准确，特别是在模拟水的临界点和液体-蒸
汽相平衡时。
//此处省略以下内容，使用ch命令提问可查看完整的内容。
>>> Send a message (/? for help)
输入/bye退出聊天。
也可以在ch命令后直接可输入”提问词“作为参数传入，大模型输出结果后终端会返回。这种交互是一次性的，类似shell命令处理，不是上下文关联的对话方式。
[xushun@login ~]$ ch "what is the mass of water molecule"
The mass of a water molecule (H2O) can be calculated by adding the atomic masses of its constituent atoms: hydrogen and oxygen. The
atomic mass of hydrogen (H) is approximately 1 atomic mass unit (amu), and the atomic mass of oxygen (O) is about 16 amu.
So, the mass of one water molecule would be:
2(atomic mass of H) + atomic mass of O
= 2(1 amu) + 16 amu
= 2 amu + 16 amu
= 18 amu
Therefore, the mass of a water molecule is approximately 18 atomic mass units.
[xushun@login ~]$ ch 1+23+4343=?
The sum of 1, 23, and 4343 is 4367.
[xushun@login ~]$
ch命令更多使用方式
[xushun@login ~]$ ch -h
Usage: ch [Options] [Promote message]...
Chat with LLM on Ollama server.
Options:
--list|-l list LLM models and exit
--model|-m <model-name> use the model of <model-name>
available models: 'codellama:70b',
'llama3.1:70b-cn', 'llama3.1:70b' and 'qwen2:72b'
--help|-h print the help and exit
The script was made by Shun Xu, Sep. 4, 2024
[xushun@login ~]$ ch 世界最高的山峰是什么
世界上最高的山峰是珠穆朗玛峰（Mount Everest），位于中国与尼泊尔边界的喜马拉雅山脉。它的海拔高度约为8,848.86米（29,031.7英尺），这个数据
是根据2020年由中国和尼泊尔共同宣布的最新测量结果。
[xushun@login ~]$ ch -l
NAME ID SIZE MODIFIED
deepseek-r1:70b 0c1615a8ca32 42 GB 30 hours ago
llama3.2-vision:90b 2ba4f038aab3 54 GB 47 hours ago
llama3.2-vision:latest 38107a0cd119 7.9 GB 2 days ago
bge-m3:latest 790764642607 1.2 GB 13 days ago
nomic-embed-text:latest 0a109f422b47 274 MB 3 months ago
llama3.1:70b-cn 33220d01c404 42 GB 3 months ago
qwen2:72b 14066dfa503f 41 GB 3 months ago
[xushun@login ~]$ ch -m qwen2:72b 世界最高的山峰是什么
世界最高峰是珠穆朗玛峰（Mount Everest），位于中国和尼泊尔边境的喜马拉雅山脉，海拔高度为8,848.86米。这是根据最新测量数据于2020年12月公布
的。珠穆朗玛峰也被称为“地球的屋脊”。
[xushun@login ~]$ ch 从以下数据中提取Density这列的数据，并从小到大排序 < lammps-data.log
列的数据如下：
1.1079657
1.0689683
1.0426856
1.0251838
1.0153501
1.009541
1.0045412
1.0034489
1.0004048
0.99958754
1.0001911
从小到大排序后的Density数据为：
0.99958754
1.0001911
1.0004048
1.0034489
1.0045412
1.009541
1.0153501
1.0251838
1.0426856
1.0689683
1.1079657
注意事项
- 当前默认大模型为经过中文调教过的llama3.1:70b-cn，在理解和回复中文请求时，更符合中文习惯；
- 运行大模型默认使用compute-g-0上的最后两块V100 GPU卡加速，大模型在运行时大约占30% GPU的利用率，5分钟之后无请求时，会自动清退占用的GPU卡（资源）。普通作业建议尽量不使用compute-g-0上id=2,3的GPU卡，以免与大模型任务产生资源抢占，影响作业性能；
- 同时支持4个ch命令并行工作，更多的ch命令请求将排队等待响应；
- 只在login节点可使用ch命令，请不用直接ssh到compute-g-0操作大模型配置，后果自负。有需求和问题联系管理员。
与大模型交互提示词(prompt)是关键，适宜大模型的提问要素是：定义角色，背景信息，任务目标，输出要求。 对于一些具体专业要求，可参照ChatGPT的提示词方式
- 英文提示词 https://github.com/f/awesome-chatgpt-prompts
- 中文提示词 https://github.com/PlexPt/awesome-chatgpt-prompts-zh
数据存储
普通用户登录其$HOME目录在/opt/home?/下，这是一个NFS网络分区，单个分区7TB，几个用户共有一个分区。数据读出性能好于GlusterFS分区。通过df命令查看/opt/home?分区大小，这个分区固定的，后期更加需求重新布局用户数据。
[xushun@login ~]$ df -h
Filesystem Size Used Avail Use% Mounted on
login:/export/local 812G 303G 469G 40% /opt/local
compute-g-1:/data2/home 7.0T 17G 6.6T 1% /opt/home2
compute-g-1:/data1/home 7.0T 282G 6.4T 5% /opt/home1
compute-g-2:/data1/home 7.0T 460G 6.2T 7% /opt/home3
compute-g-2:/data2/home 7.0T 70G 6.6T 2% /opt/home4
compute-g-4:/data1/home 7.0T 0 6.6T 0% /opt/home5
compute-g-4:/data2/home 7.0T 0 6.6T 0% /opt/home6
compute-g-5:/data1/home 7.0T 0 6.6T 0% /opt/home7
compute-g-5:/data2/home 7.0T 0 6.6T 0% /opt/home8
-
/opt/local分区（挂接点）为NFS共享存储，实际物理磁盘在login节点上，各计算节点都可读/opt/local分区，但只用root用户有权限写。该分区主要用于存放集群安装的常用软件，这些软件包由管理员提前安装到/opt/local目录，以全局共享给普通用户。
-
/opt/data分区（挂接点）为GlusterFS无备份分区，整合大部分计算节点上的存储空间，以供用户计算作业的数据存储。GlusterFS分区读写速度较慢，而且有无法读出的问题，故该分区只做临时使用。
普通用户使用
cd命令返回$HOME目录cdd快捷命令进入/opt/data/$USER目录
使用module管理软件
用户使用module命令查看系统已安装的软件包，通过module avail查看当前可用软件包列表，比较重要的系统软件有
-
openmpi/5.0.6 MPI并行环境，支持UCX和SLURM环境
-
cuda/12.5 CUDA异构计算环境，只在GPU计算节点上调用才有效
-
miniconda3/2024.6 Conda软件环境，提供用户灵活可控的Python环境
-
intel/oneapi/2024.1 OneAPI软件工具集，提供基于Intel平台的软件开发工具
常用的软件可将module load [pkg]命令写入~/.bash_profile文件，实现登录时自动加载想要的pkg软件包。load后面添加-s选项可静默式加载（无输出信息）。
通过module show [pkg] 显示特定pkg软件包的路径和环境变量信息配置
用户的module file可放在$HOME/local/modulefiles目录，使用use目录加载这个目录
由于/opt/local普通用户不可写，因此可用$HOME/local/modulefiles目录存放的用户自编译安装的软件包module信息。TCB系统提供名为create_module_file的Bash函数，可方便自动构建module file文件
[xushun@login ~]$ which create_module_file
[xushun@login ~]$ create_module_file
input: package-installed-path package-version modufile-path
这里的modufile-path指向$HOME/local/modulefiles即可。
例如对于安装在$HOME/local/fftw-3.3.8的本地软件，使用create_module_file为其创建一个module file文件，并保存在本地$HOME/local/modulefiles目录
mkdir -p $HOME/local/modulefiles
create_module_file $HOME/local/fftw-3.3.8 fftw-3.3.8 $HOME/local/modulefiles/lib/fftw3/3.3.8
module use $HOME/local/modulefiles
module avail
module show lib/fftw3/3.3.8
如果module load某个软件包时，出现missing prereq报错，则需要配置auto_handling为1，则会自动加载prereq指示的依赖库。
OneAPI软件集
TCB集群计算节点CPU为Intel处理器，除了安装CUDA开发环境，Intel OneAPI软件工具也有必要提供。当前Intel OneAPI开放使用，包括几大模块，包括基本的Base Toolkit，还有面向HPC的 HPC Toolkit，面向AI的AI Tools等等。模块可单独安装。
详见 https://www.intel.com/content/www/us/en/developer/tools/oneapi/toolkits.html
我们在TCB集群上安装Base Toolkit和HPC Toolkit两大模块，统一安装在/opt/local/intel/oneapi共享目录，使得集群全部用户可用。
选择TCB使用的modulefiles方式管理这些软件工具，形成统一的使用方法。
通过module avail，除了可查看到默认的/opt/local/modulefiles，还可看到OneAPI提供的/opt/local/intel/oneapi/modulefiles下面的软件包。
[xushun@login ~]$ module avail
---------------------------------- /opt/local/intel/oneapi/modulefiles -----------------------------------
advisor/2024.1 compiler32/2024.1.0 ifort/2024.1.0 mkl32/2024.1
ccl/2021.12.0 dal/2024.0.0 ifort32/2024.1.0 mpi/2021.12
compiler-intel-llvm/2024.1.0 debugger/2024.1.0 intel_ipp_ia32/2021.11 oclfpga/2024.1.0
compiler-intel-llvm32/2024.1.0 dev-utilities/2024.0.0 intel_ipp_intel64/2021.11 tbb/2021.12
compiler-rt/2024.1.0 dnnl/3.4.0 intel_ippcp_ia32/2021.11 tbb32/2021.12
compiler-rt32/2024.1.0 dpct/2024.1.0 intel_ippcp_intel64/2021.11 vtune/2024.1
compiler/2024.1.0 dpl/2022.5 mkl/2024.1
----------------------------------------- /opt/local/modulefiles -----------------------------------------
app/gromacs/2024.2 cuda/12.5 lib/openblas/0.3.26 llvm/18.1.8
app/gromacs/2024.2-gpu gcc/14.2.0 lib/ucx/1.16.0 miniconda3/2024.6
app/lammps/17Apr2024-cpu lib/eigen/3.4.0 lib/voro++/0.4.6 openmpi/5.0.6
app/lammps/17Apr2024-gpu lib/fftw/3.3.10 llvm/10.0.1 util/gperftools/2.15
app/lammps/17Apr2024-torch lib/gsl/2.8 llvm/14.0.6 util/pdsh/2.35
OneAPI提供了Intel MKL，TBB、vTune和advisor等丰富的软件（库）工具。
加载Vtune和MKL变得很简单
[xushun@login ~]$ module load vtune/2024.1
[xushun@login ~]$ which amplxe-cl
/opt/local/intel/oneapi/vtune/2024.1/bin64/amplxe-cl
[xushun@login mp_linpack]$ module add mkl/2024.1
Loading mkl/2024.1
Loading requirement: tbb/2021.12 compiler-rt/2024.1.0
Intel MKL软件包提供3个benchmark程序：hpcg、linpack和mp_linpack，普通用户可以拷贝对应目录到本地，可用于测试平台计算性能。
[xushun@login mp_linpack]$ ls /opt/local/intel/oneapi/mkl/2024.1/share/mkl/benchmarks/
hpcg linpack mp_linpack
使用Conda环境
TCB集群可以连网下载软件包，包括各计算节点也可连外网，因此特别方便使用Conda环境。TCB集群提供了Miniconda3环境。
首先使用module加载conda环境，首次使用conda要init环境
[xushun@login ~]$ module add miniconda3/2024.6
[xushun@login ~]$ conda init bash
[xushun@login ~]$ conda config --set auto_activate_base false
init之后会新建~/.conda本地文件夹；auto_activate_base设置为false，表示开启默认的base环境。之后logout当前用户，再重新login，就可以正常使用conda环境。
使用系统env
进一步查看可用env
[xushun@login ~]$ conda env list
# conda environments:
#
base /opt/local/miniconda3
py3mol /opt/local/miniconda3/envs/py3mol
使用env list查看可用的env（环境），默认在系统环境下包括base和py3mol两个环境，其中base为Miniconda3默认环境，py3mol是TCB集群提供给多用户共享的分子模拟计算环境，使用Python 3.12.1环境，安装了openmm和ase等软件包（使用conda env export目录查看已安装软件列表），使用这个共享环境可以节省其他用户安装软件的空间和时间，激活即可用，缺点就是此环境对普通用户为只读，不可往里面安装新软件包。如新软件包有多人使用的可能，也可以建议系统管理员安装在系统的py3mol环境。
py3mol是个系统范围的env，通过conda内置安装了Pytorch 2.3.1和CUDA 12.1，这两个软件包大约6 GB，普通用户不用在本地安装这么大的软件包。
普通用户使用Pytorch时，不需要module load cuda/12.5环境，只需要conda激活/opt/local/miniconda3/envs/py3mol环境，这个环境内含CUDA 12.1环境。任务运行在GPU节点torch.cuda.is_available()返回True，运行在CPU节点上返回False，不影响多节点共享使用。
在GPU节点
(py3mol) [xushun@compute-g-0 ~]$ conda activate /opt/local/miniconda3/envs/py3mol
(py3mol) [xushun@compute-g-0 ~]$ python
Python 3.12.3 | packaged by Anaconda, Inc. | (main, May 6 2024, 19:46:43) [GCC 11.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import torch
>>> torch.cuda.is_available()
True
>>> device = torch.device("cuda")
>>> tensor = torch.rand(3, 3).to(device)
>>> print(tensor)
tensor([[0.0808, 0.4274, 0.9824],
[0.1571, 0.3024, 0.9997],
[0.3124, 0.2524, 0.1844]], device='cuda:0')
>>> exit()
在CPU节点
[xushun@login ~]$ conda activate /opt/local/miniconda3/envs/py3mol
(py3mol) [xushun@login ~]$ python
Python 3.12.3 | packaged by Anaconda, Inc. | (main, May 6 2024, 19:46:43) [GCC 11.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import torch
>>> torch.cuda.is_available()
False
使用本地env
如要安装新软件包，用户可以在本地创建新env，并激活它。
这里以创建环境名py3ai为例
module load miniconda3/2024.6
conda create -n py3ai python=3
conda activate py3ai
#source activate py3ai
conda env list
where pip
conda deactivate
#conda remove -n py3ai --all #删除py3ai环境
有了自己本地环境（如py3ai）就可以在本地安装所需的软件，如果安装的是python软件库，建议使用pip安装，不用conda install方式
module load miniconda3/2024.6
conda activate py3ai
pip install numpy scipy sympy matplotlib pandas #任何python软件包
#conda env export > env_py3mol.yaml
安装过几个必要软件之后，可用看到~/.conda空间使用量还不少，因此如果不安装新软件，首选使用系统提供的env。
作业提交与管理
分区队列说明
TCB集群作业调度采用主流的Slurm作业调度系统，Slurm系统在国内外超级计算机上广泛使用。Slurm中作业队列称为分区（Partition）。
TCB当前作业分区有3个：
- normal分区，（星号标识为默认分区）使用infiniband快速网络互联的CPU节点区，适合跨节点大规模并行任务（大型任务）
- single分区，使用以太网络互联的CPU节点区，适合单节点多线程并行任务（中型任务）
- gpu分区，使用以太网互联的GPU节点区，包括V100、RTX4080和RTX4090多种类型卡，适合单节点多GPU卡异构加速任务（中大型任务）
使用sinfo命令查看分区（队列）的配置情况，当前配置如
[xushun@login ~]$ sinfo
PARTITION AVAIL TIMELIMIT NODES STATE NODELIST
single up infinite 16 idle compute-0-[20,22-23,27,29-36,39-42]
normal* up infinite 8 idle compute-0-[2,13-14,16-18,21,26]
gpu up infinite 5 idle compute-g-[0-2,4-5]
另外TCB集群提供特有的sinfo2扩展命令，它汇总了节点分区信息，统计idle、down等数量，以及每个队列的节点数，还包括每个分区的属性。sinfo2是从另一个统计视角查看分区状态，特别适合有成百千上节点的大规模集群。
[xushun@login ~]$ sinfo2
PARTITION AVAIL TIMELIMIT NODES STATE
single up infinite 16 idle
normal* up infinite 8 idle
gpu up infinite 4 mix
gpu up infinite 1 idle
mix : 4
idle : 25
gpu : 5
single : 16
normal* : 8
Total = 29
PartitionName=single
MaxNodes=UNLIMITED MaxTime=UNLIMITED MinNodes=0 LLN=NO MaxCPUsPerNode=UNLIMITED MaxCPUsPerSocket=UNLIMITED
PartitionName=normal
MaxNodes=UNLIMITED MaxTime=UNLIMITED MinNodes=0 LLN=NO MaxCPUsPerNode=UNLIMITED MaxCPUsPerSocket=UNLIMITED
PartitionName=gpu
MaxNodes=UNLIMITED MaxTime=UNLIMITED MinNodes=0 LLN=NO MaxCPUsPerNode=UNLIMITED MaxCPUsPerSocket=UNLIMITED
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)
在normal分区，都为24核CPU节点，节点间通过infiniband联网在同一个域中。
在single分区，包括了24核和32核的CPU节点，可以通过设置srun和sbatch的输入选项--cores-per-socket，来挑选哪类CPU节点。
- 选项–cores-per-socket=6 选取24核的CPU节点
- 选项–cores-per-socket=8 选取32核的CPU节点
在gpu分区，包括4卡V100节点、10卡RTX4080和8卡RTX4090节点，它们用的CUDA SDK和Driver都是一个版本，Driver是安装每台GPU节点上，而CUDA SDK存放在/opt/local/cuda中各GPU共享调用，因此运行应用程序的兼容性较好。
以上选项配置适用于TCB集群，其他集群中的CPU类型可能需要修改选项。
例如申请一个节点，并指定其具有的CPU核数：
srun -N 1 -p single --cores-per-socket=6 lscpu #申请一个24核的CPU节点
srun -N 1 -p single --cores-per-socket=8 lscpu #申请一个32核的CPU节点
如果不指定CPU核数，则由Slurm分配，可能为24核也可能为32核的节点，这样不利于充分利用多核资源。可以通过scontrol命令查看节点的资源属性，如查看compute-0-20节点资源配置
[xushun@login ~]$ scontrol show node compute-0-20
NodeName=compute-0-20 Arch=x86_64 CoresPerSocket=6
CPUAlloc=0 CPUEfctv=24 CPUTot=24 CPULoad=0.00
AvailableFeatures=(null)
ActiveFeatures=(null)
Gres=(null)
NodeAddr=compute-0-20 NodeHostName=compute-0-20 Version=23.11.6
OS=Linux 5.14.0-427.18.1.el9_4.x86_64 #1 SMP PREEMPT_DYNAMIC Mon May 27 16:35:12 UTC 2024
RealMemory=31793 AllocMem=0 FreeMem=29985 Sockets=2 Boards=1
State=IDLE ThreadsPerCore=2 TmpDisk=0 Weight=1 Owner=N/A MCS_label=N/A
Partitions=single
BootTime=2024-06-03T18:40:30 SlurmdStartTime=2024-06-05T22:34:03
LastBusyTime=2024-06-11T23:27:09 ResumeAfterTime=None
CfgTRES=cpu=24,mem=31793M,billing=24
AllocTRES=
CapWatts=n/a
CurrentWatts=0 AveWatts=0
ExtSensorsJoules=n/a ExtSensorsWatts=0 ExtSensorsTemp=n/a
如果要通过salloc分配某个计算节点并ssh登录它，可使用/opt/local/etc/profile.d/snode脚本快速完成，snode命令不带参数，表示在默认队列分配一个节点并ssh登录它，如
[xushun@login ~]$ /opt/local/etc/profile.d/snode
salloc: Granted job allocation 277
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)
277 normal interact xushun R 0:00 1 compute-0-2
Last login: Thu Jun 13 07:28:50 2024 from 192.168.0.254
[xushun@compute-0-2 ~]$
其中会调用salloc和squeue命令联合完成。
也可以指定salloc参数，如指定分区和节点，如
snode用于分配排他性的计算节点，方便调试程序。
CPU作业提交
Slurm作业管理系统支持srun和sbatch提交用户作业，前者是交互式，后者是批处理方式。推荐sbatch方式，运行更可靠。TCB集群中配置了 OpenMPI 5.0.6，和OpenMPI 4系列不同的在于：使用UCX来支持infiniband连接，而且废弃了pmi2，起而代之为性能更好的pmix连接方式。
作为测试，TCB集群中提供Intel MPI benchmark测试集，被安装到了/opt/local/openmpi-5.0.6/bin路径，用户直接调用即可，写一个Sbatch作业提交脚本test_mpi.sh，如
[xushun@login ~]$ cat test_mpi.sh
#!/bin/bash
#SBATCH -J mpi
#SBATCH -o %x-%j.log
#env|grep SLURM
module add openmpi/5.0.6
mpirun /opt/local/openmpi-5.0.6/bin/IMB-MPI1 pingpong
该脚本没有指定partition和申请的节点核数，这些参数从sbatch命令行输入。其中module add openmpi/5.0.6可放到Bash命令行端执行。test_mpi.sh执行时会识别（带入）执行环境中定义的PATH、LD_LIBRARY_PATH等变量。
注意在test_mpi.sh中mpirun的调用没有指定-np或-n参数，因为这里mpirun可自动识别Slurm设置好的环境变量，包括节点和核数申请配置情况。
通过sbatch选项控制申请的节点数和进程间通信模式，如
sbatch -p normal -N 2 -n 2 ./test_mpi.sh #申请两节点，每个节点启动1个进程，进程跨节点以infiniband通信
sbatch -p normal -N 1 -n 2 ./test_mpi.sh #申请一节点，该节点启动2个进程，进程在CPU核之间通信
sbatch -p single -N 2 -n 2 ./test_mpi.sh #申请两节点，每个节点启动1个进程，进程跨节点以以太网通信
sbatch -p single -N 1 -n 2 ./test_mpi.sh #申请一节点，该节点启动2个进程，进程在CPU核之间通信
查询运行结果如下，可以发现mpi-162.log日志对应的进程跨节点是以太网通信方式，相对慢很多，另外normal和single节点内进程通信代价较一致，这种情况是符合预期的。
[xushun@login ~]$ grep -E "4194304|repetitions" mpi-*.log
mpi-160.log:# Maximum message length in bytes: 4194304
mpi-160.log: #bytes #repetitions t[usec] Mbytes/sec
mpi-160.log: 4194304 10 1087.76 3855.90
mpi-161.log:# Maximum message length in bytes: 4194304
mpi-161.log: #bytes #repetitions t[usec] Mbytes/sec
mpi-161.log: 4194304 10 1520.23 2758.99
mpi-162.log:# Maximum message length in bytes: 4194304
mpi-162.log: #bytes #repetitions t[usec] Mbytes/sec
mpi-162.log: 4194304 10 35852.53 116.99
mpi-163.log:# Maximum message length in bytes: 4194304
mpi-163.log: #bytes #repetitions t[usec] Mbytes/sec
mpi-163.log: 4194304 10 1363.84 3075.36
Slurm使用openMP并行的配置脚本实例：
#!/bin/bash
#SBATCH -J hwm
#SBATCH -p normal
# Number of (MPI) tasks
#SBATCH -n 1
# Number of cores per task
#SBATCH -c 32
#SBATCH --gres=gpu:4
#SBATCH -o %x-%j.log
export UCX_LOG_LEVEL=error
export CMD_PATH=$HOME/hwmetric/build
export NAME_PREFIX=${SLURM_JOB_NAME}-${SLURM_JOBID}-${SLURM_NTASKS}n${SLURM_NNODES}N
# Set OMP_NUM_THREADS to the same value as -c
# with a fallback in case it isn't set.
# SLURM_CPUS_PER_TASK is set to the value of -c, but only if -c is explicitly set
if [ -n "$SLURM_CPUS_PER_TASK" ]; then
omp_threads=$SLURM_CPUS_PER_TASK
else
omp_threads=1
fi
export OMP_NUM_THREADS=$omp_threads
date
srun --cpu_bind=cores ${CMD_PATH}/cpu_flops
关键在于设置OMP_NUM_THREADS和使用--cpu_bing=cores性能会更好。
GPU作业提交
GPU任务可提交到gpu分区，首先需要用module加载cuda环境，或者直接激活系统conda环境/opt/local/miniconda3/envs/py3mol，它提供Pytorch和Cuda 12.1环境。
在/opt/local/cuda-12.5软件工具下提供了几个实用测试程序deviceQuery和bandwidthTest，前者可用查询GPU属性，后者可用测试GPU通信带宽。
[xushun@login ~]$ cat test_cuda.sh
#!/bin/bash
#SBATCH -J gpu
#SBATCH -p gpu
#SBATCH -n 1
#SBATCH -o %x-%j.log
env|grep SLURM
module add cuda/12.5
/opt/local/cuda-12.5/extras/demo_suite/deviceQuery
/opt/local/cuda-12.5/extras/demo_suite/bandwidthTest
以上test_cuda.sh中指定了gpu分区和申请核数为1。
TCB集群上GPU节点是多GPU卡节点，如果想独占某台GPU节点，可用以下设置
这样就不会有其他作业被调度到当前计算节点，因此当前用户程序可用满节点上的所有GPU卡。
提交命令
不用在命令行指定申请资源的参数，所需资源申请都写在脚本中。
使用squeue和sinfo2查看作业状态。
如果想多个作业分用单节点的多GPU卡，可以使用Gres=gpu:n或者Gres=gpu:type:n指定单节点上申请的GPU卡数，其中type当前可取v100s、rtx_4080和rtx_4090三种值。 以下脚本实现申请一块RTX 4080或RTX 4090 GPU卡计算，而不用compute-g-0上的V100 GPU卡
#SBATCH -p gpu
#SBATCH -n 1
#SBATCH --mem=96610M
#SBATCH --gres=gpu:1
#SBATCH --exclude compute-g-0
#SBATCH --exclusive
使用scontrol show node命令查看某个节点上Gres=gpu指示的可用GPU卡数，关于Gres资源使用见文后 “LAMMPS作业” 提交说明。
[xushun@login ~]$ scontrol show node compute-g-0
NodeName=compute-g-0 Arch=x86_64 CoresPerSocket=16
CPUAlloc=0 CPUEfctv=64 CPUTot=64 CPULoad=0.12
AvailableFeatures=(null)
ActiveFeatures=(null)
Gres=gpu:v100s:4(S:0)
NodeAddr=compute-g-0 NodeHostName=compute-g-0 Version=24.11.0
OS=Linux 5.14.0-503.15.1.el9_5.x86_64 #1 SMP PREEMPT_DYNAMIC Tue Nov 26 17:24:29 UTC 2024
RealMemory=191535 AllocMem=0 FreeMem=125974 Sockets=2 Boards=1
State=IDLE ThreadsPerCore=2 TmpDisk=0 Weight=1 Owner=N/A MCS_label=N/A
Partitions=gpu
BootTime=2024-12-07T00:44:33 SlurmdStartTime=2024-12-07T10:57:35
LastBusyTime=2024-12-07T10:57:48 ResumeAfterTime=None
CfgTRES=cpu=64,mem=191535M,billing=64
AllocTRES=
CurrentWatts=0 AveWatts=0
OpenMM作业
OpenMM软件已安装在Conda系统级env：/opt/local/miniconda3/envs/py3mol
只要激活它就可使用
在不同的环境（GPU节点或纯CPU节点），OpenMM会识别可用的（Platform）平台
(py3mol) [xushun@compute-g-0 ~]$ python -m openmm.testInstallation #4 Platforms available，包括OpenCL
(py3mol) [xushun@login examples]$ python -m openmm.testInstallation #2 Platforms available
为了测试OpenMM，下载实例
(py3mol) [xushun@login ~]$ git clone https://gitlab.com/orise/openmm-dcu.git
(py3mol) [xushun@login ~]$ cd openmm-dcu/examples
先在V100 GPU上（compute-g-0）测试OpenMM在OpenCL、CUDA和CPU平台的性能
在OpenCL平台测试
(py3mol) [xushun@compute-g-0 examples]$ python3 benchmark.py --test apoa1rf --platform OpenCL --seconds 20
...
platform: OpenCL
platform_properties: {'DeviceIndex': '0', 'DeviceName': 'Tesla V100S-PCIE-32GB', 'OpenCLPlatformIndex': '0', 'OpenCLPlatformName': 'NVIDIA CUDA', 'Precision': 'single', 'UseCpuPme': 'false', 'DisablePmeStream': 'false'}
steps: 25338
elapsed_time: 20.18081
ns_per_day: 433.9178060741862
在CUDA平台测试
(py3mol) [xushun@compute-g-0 examples]$ python3 benchmark.py --test apoa1rf --platform CUDA --seconds 20
...
platform: CUDA
platform_properties: {'DeviceIndex': '0', 'DeviceName': 'Tesla V100S-PCIE-32GB', 'UseBlockingSync': 'false', 'Precision': 'single', 'UseCpuPme': 'false', 'CudaCompiler': '', 'TempDirectory': '/tmp', 'CudaHostCompiler': '', 'DisablePmeStream': 'false', 'DeterministicForces': 'false'}
steps: 30135
elapsed_time: 19.820686
ns_per_day: 525.4437712196237
在CPU平台测试
(py3mol) [xushun@compute-g-0 examples]$ python3 benchmark.py --test apoa1rf --platform CPU --seconds 20
...
platform: CPU
platform_properties: {'Threads': '64', 'DeterministicForces': 'false'}
steps: 649
elapsed_time: 18.793854
ns_per_day: 11.934454742491878
可见V100 CUDA比OpenCL快525.44/433.91=1.21倍，CUDA比CPU 快525.44/11.93=44.05倍。
在RTX 4080上测试
为了对比V100卡，在RTX 4080卡做同样的测试
(py3mol) [xushun@compute-g-1 examples]$ python3 benchmark.py --test apoa1rf --platform CUDA --seconds 20
...
platform: CUDA
platform_properties: {'DeviceIndex': '0', 'DeviceName': 'NVIDIA GeForce RTX 4080', 'UseBlockingSync': 'false', 'Precision': 'single', 'UseCpuPme': 'false', 'CudaCompiler': '', 'TempDirectory': '/tmp', 'CudaHostCompiler': '', 'DisablePmeStream': 'false', 'DeterministicForces': 'false'}
steps: 50817
elapsed_time: 19.618112
ns_per_day: 895.2112823089193
可见CUDA平台在RTX 4080卡比V100卡快895.21/525.44=1.7倍。
正式使用OpenMM 需要写成Slurm脚本形式，如test_openmm.slurm
#!/bin/bash
#SBATCH -J mm
#SBATCH -p gpu
#SBATCH -N 1
#SBATCH -o %x-%j.log
module load miniconda3/2024.6
source activate /opt/local/miniconda3/envs/py3mol
python3 benchmark.py --test apoa1rf --platform CUDA --seconds 20
python3 benchmark.py --test apoa1rf --platform OpenCL --seconds 20
python3 benchmark.py --test apoa1rf --platform CPU --seconds 20
注意conda报错
该脚本中source activate不能写成conda activate，否则报错CondaError: Run 'conda init' before 'conda activate'
默认sbatch随机分配gpu分区上的GPU节点，可以使用sbatch指定节点（即选择不同的GPU卡）
也可以通过–gres参数直接指定GPU型号
LAMMPS作业
当前TCB集群提供LAMMPS三种编译版本
- app/lammps/17Apr2024 ：多分区（队列）通用版本， MPI编译，支持KOKKOS-openmp 多核并行加速包
- app/lammps/17Apr2024-gpu ：gpu分区专用版，CUDA 12.5+MPI编译，支持KOKKOS-cuda、GPU-cuda两个GPU异构计算加速包
- app/lammps/17Apr2024-torch ：gpu分区专用版，基于Conda系统env（py3mol）中的Cuda 12.1和pytorch，支持KOKKOS-cuda、GPU-cuda和Allegro机器学习势模型
LAMMPS编译版本说明
由于LAMMPS CUDA加速版依赖CUDA的驱动模块libcuda.so，导致在没有安装CUDA驱动的CPU节点上无法运行CUDA加速版。因此将LAMMPS编译成适配于gpu分区（队列）的版本app/lammps/17Apr2024-gpu （依赖/opt/local/cuda-12.5），app/lammps/17Apr2024-torch （依赖/opt/local/miniconda3/envs/py3mol及其中pytorch）和适配通用CPU的版本app/lammps/17Apr2024，后者可以运行在gpu队列，但不能调用GPU加速。
使用module add app/lammps/17Apr2024、app/lammps/17Apr2024-gpu或app/lammps/17Apr2024-torch会自动加载依赖库。首先确认下当前LAMMPS编译版本信息，有利于我们对测试结果的性能分析。
[xushun@login ~]$ module add app/lammps/17Apr2024-cpu
[xushun@login ~]# srun -p normal -n 1 mpirun -n 1 lmp_mpi -h
Large-scale Atomic/Molecular Massively Parallel Simulator - 17 Apr 2024
Git info (build-cpu / patch_17Apr2024)
Usage example: lmp_mpi -var t 300 -echo screen -in in.alloy
List of command line options supported by this LAMMPS executable:
-echo none/screen/log/both : echoing of input script (-e)
-help : print this help message (-h)
-in none/filename : read input from file or stdin (default) (-i)
-kokkos on/off ... : turn KOKKOS mode on or off (-k)
-log none/filename : where to send log output (-l)
-mdi '<mdi flags>' : pass flags to the MolSSI Driver Interface
-mpicolor color : which exe in a multi-exe mpirun cmd (-m)
-cite : select citation reminder style (-c)
-nocite : disable citation reminder (-nc)
-nonbuf : disable screen/logfile buffering (-nb)
-package style ... : invoke package command (-pk)
-partition size1 size2 ... : assign partition sizes (-p)
-plog basename : basename for partition logs (-pl)
-pscreen basename : basename for partition screens (-ps)
-restart2data rfile dfile ... : convert restart to data file (-r2data)
-restart2dump rfile dgroup dstyle dfile ...
: convert restart to dump file (-r2dump)
-reorder topology-specs : processor reordering (-r)
-screen none/filename : where to send screen output (-sc)
-skiprun : skip loops in run and minimize (-sr)
-suffix gpu/intel/kk/opt/omp: style suffix to apply (-sf)
-var varname value : set index style variable (-v)
OS: Linux "Rocky Linux 9.5 (Blue Onyx)" 5.14.0-503.15.1.el9_5.x86_64 x86_64
Compiler: GNU C++ 11.5.0 20240719 (Red Hat 11.5.0-2) with OpenMP 4.5
C++ standard: C++17
MPI v3.1: Open MPI v5.0.6, package: Open MPI root@login Distribution, ident: 5.0.6, repo rev: v5.0.6, Nov 15, 2024
Accelerator configuration:
KOKKOS package API: OpenMP Serial
KOKKOS package precision: double
Kokkos library version: 4.3.0
OPENMP package API: OpenMP
OPENMP package precision: double
OpenMP standard: OpenMP 4.5
FFT information:
FFT precision = double
FFT engine = mpiFFT
FFT library = FFTW3
KOKKOS FFT engine = mpiFFT
KOKKOS FFT library = KISS
#以下省略
lj实例测试
测试输入文件in.lj 内容如
# 3d Lennard-Jones melt
variable x index 1
variable y index 1
variable z index 1
variable xx equal 40*$x
variable yy equal 40*$y
variable zz equal 40*$z
units lj
atom_style atomic
lattice fcc 0.8442
region box block 0 ${xx} 0 ${yy} 0 ${zz}
create_box 1 box
create_atoms 1 box
mass 1 1.0
velocity all create 1.44 87287 loop geom
pair_style lj/cut 2.5
pair_coeff 1 1 1.0 1.0 2.5
neighbor 0.3 bin
neigh_modify delay 5 every 1
fix 1 all nve
run 1000
CPU节点提交脚本lj_cpu.slurm
#!/bin/bash
#SBATCH -J lj
#SBATCH -p normal
#SBATCH -N 1
#SBATCH --ntasks-per-node=4
#SBATCH --cpus-per-task=6
#SBATCH --exclusive
#SBATCH -o %x-%j.log
#env|grep SLURM
module add app/lammps/17Apr2024
export NAME_PREFIX=${SLURM_JOB_NAME}-${SLURM_JOBID}-${SLURM_NTASKS}n${SLURM_NNODES}N
export OMP_NUM_THREADS=6
#use kokkos-openmp
date
mpirun -n ${SLURM_NTASKS} lmp_mpi -nocite -var x 4 -var y 4 -var z 4 -k on -sf kk -in in.lj -log ${NAME_PREFIX}-kk-omp.log
#CPU normal mode
date
mpirun -n ${SLURM_NTASKS} lmp_mpi -nocite -var x 4 -var y 4 -var z 4 -in in.lj -log ${NAME_PREFIX}-cpu.log
以上展示了两种CPU运行方式，选择一个比较快的就行.
提交命令sbatch lj_cpu.slurm
GPU节点提交脚本lj_gpu.slurm
#!/bin/bash
#SBATCH -J lj
#SBATCH -p gpu
#SBATCH -N 1
#SBATCH --ntasks-per-node=4
#SBATCH --cpus-per-task=6
#SBATCH --exclusive
#SBATCH -o %x-%j.log
#env|grep SLURM
echo "CUDA_VISIBLE_DEVICES = $CUDA_VISIBLE_DEVICES"
module add app/lammps/17Apr2024-gpu
export NAME_PREFIX=${SLURM_JOB_NAME}-${SLURM_JOBID}-${SLURM_NTASKS}n${SLURM_NNODES}N
export OMP_NUM_THREADS=6
#use gpu package
date
mpirun -n ${SLURM_NTASKS} lmp_mpi -nocite -var x 4 -var y 4 -var z 4 -sf gpu -pk gpu 4 -in in.lj -log ${NAME_PREFIX}-gpu.log
#use kokkos-cuda
date
mpirun -n ${SLURM_NTASKS} lmp_mpi -nocite -var x 4 -var y 4 -var z 4 -k on g 4 -sf kk -in in.lj -log ${NAME_PREFIX}-kk.log
以上展示了两种GPU运行方式，选择其中之一即可。提交命令sbatch lj_gpu.slurm
gpu package的性能日志
Loop time of 243.022 on 24 procs for 1000 steps with 16384000 atoms
Performance: 1777.617 tau/day, 4.115 timesteps/s, 67.418 Matom-step/s
143.1% CPU use with 4 MPI tasks x 6 OpenMP threads
kokkos-cuda的性能日志
Loop time of 138.941 on 4 procs for 1000 steps with 16384000 atoms
Performance: 3109.244 tau/day, 7.197 timesteps/s, 117.921 Matom-step/s
98.0% CPU use with 4 MPI tasks x 1 OpenMP threads
更多LAMMPS性能测试可参考https://gitlab.com/orise/lammps-hip
多作业分用GPU卡
当前TCB集群gpu分区支持单个job使用部分GPU卡，多个job可以共享一个GPU节点，分用单节点上的多块GPU卡。
测试实例，提交两个作业到同一个gpu分区节点，每个作业分开使用2块GPU卡。将lj_gpu.slurm改写如下，去除了–exclusive选项，并将CUDA_VISIBLE_DEVICES环境变量输出
#!/bin/bash
#SBATCH -J lj
#SBATCH -p gpu
#SBATCH --ntasks-per-node=2
#SBATCH --cpus-per-task=1
#SBATCH -o %x-%j.log
env|grep SLURM
echo "CUDA_VISIBLE_DEVICES = $CUDA_VISIBLE_DEVICES"
module add app/lammps/17Apr2024-gpu
export NAME_PREFIX=${SLURM_JOB_NAME}-${SLURM_JOBID}-${SLURM_NTASKS}n${SLURM_NNODES}N
export OMP_NUM_THREADS=6
#use gpu package
date
mpirun -n ${SLURM_NTASKS} lmp_mpi -nocite -var x 4 -var y 4 -var z 4 -sf gpu -pk gpu 2 -in in.lj -log ${NAME_PREFIX}-gpu.log
#use kokkos-cuda
date
mpirun -n ${SLURM_NTASKS} lmp_mpi -nocite -var x 4 -var y 4 -var z 4 -k on g 2 -sf kk -in in.lj -log ${NAME_PREFIX}-kk.log
提交命令如，可以提交两次，第一次使用GPU ID=0,1，第二次使用GPU ID=2,3
sbatch -n 2 -c 1 --gres=gpu:2 --mem=95765M lj_gpu.slurm
sbatch -n 2 -c 1 --gres=gpu:2 --mem=95765M lj_gpu.slurm
其中-n 2表示开启2个task（任务），-c 1表示每个任务1个CPU核(–cpus-per-task=1)，–gres=gpu:2表示每个节点申请2块GPU卡，GPU节点compute-g-0内存大小为191546MB，如果不指定申请的内存，则会使用所有内存，导致后面的作业因内存不足无法共享节点，而不是因为GPU卡数不足的原因。这里设置--mem=95765M大致为节点总内存的一半。通过以上设置就可以实现两个job共享一个GPU节点，但分开调用不同的GPU卡；也可以指定申请的GPU类型来分配不同的计算节点。
sbatch -n 2 -c 1 --gres=gpu:v100s:2 --mem=95765M lj_gpu.slurm
sbatch -n 2 -c 1 --gres=gpu:rtx_4080:2 --mem 154570M lj_gpu.slurm
sbatch -n 2 -c 1 --gres=gpu:rtx_4090:2 --mem 193200M lj_gpu.slurm
以上实例，使用nvidia-smi可监视到全部4块GPU卡都在工作
改变–gres=gpu:n的值，可以实现更多作业组合运行在同一台GPU节点上。但注意compute-g-0只安装4块GPU，–gres=gpu:n的n最大只能取4。
可用使用scontrol命令查看某个节点Gres中GPU卡可用数：
[xushun@login ~]$ scontrol show node compute-g-0|grep Gres
Gres=gpu:4(S:0)
[xushun@login ~]$ scontrol show node compute-0-2|grep Gres
Gres=(null)
Torch版作业
使用LAMMPS Torch版本，提交一个基于Allegro机器学习作用势模型的实例，在module加载app/lammps/17Apr2024-torch之后，还需要source activate系统env：/opt/local/miniconda3/envs/py3mol才可以正常使用lmp_mpi。
脚本名设为allegro.slurm
#!/bin/bash
#SBATCH -J allegro
#SBATCH -p gpu
#SBATCH --ntasks-per-node=2
#SBATCH --cpus-per-task=4
#SBATCH --gres=gpu:2
#SBATCH -o %x-%j.log
#env|grep SLURM
echo "CUDA_VISIBLE_DEVICES = $CUDA_VISIBLE_DEVICES"
module add app/lammps/17Apr2024-torch
source activate /opt/local/miniconda3/envs/py3mol
export NAME_PREFIX=${SLURM_JOB_NAME}-${SLURM_JOBID}-${SLURM_NTASKS}n${SLURM_NNODES}N
export OMP_NUM_THREADS=4
export OMP_PROC_BIND=true
date
#mpirun -n ${SLURM_NTASKS} lmp_mpi -nocite -h | grep -i -E "Kokkos|allegro"
mpirun -n ${SLURM_NTASKS} lmp_mpi -nocite -sf kk -k on g 2 t ${OMP_NUM_THREADS} -pk kokkos newton on neigh full -log ${NAME_PREFIX}-kk.log -in input.lammps
使用sbatch allegro.slurm提交。其中input.lammps内容如
units metal
boundary p p p
atom_style atomic
newton on
thermo 1
read_data 333.lammps
neighbor 1.0 bin
neigh_modify every 10 delay 0 check no
pair_style allegro3232
pair_coeff * * ./deployed.pth Ag
dump myDump all custom 10 xyz.lammpstrj id element x y z
dump_modify myDump sort id element Ag
thermo_style custom step time pe
#thermo_style custom step time pe ke etotal temp press vol density
thermo 10
velocity all create 1000.0 12138
fix NVT all nvt temp 1000 1000 0.1
run 1000
write_data contcar_nvt.lammps
其中pair_style allegro3232表示32位浮点精度（单精度）输入和32位浮点精度输出，默认pair_style allegro为输入32位浮点精度，输出64位浮点精度（双精度）。精度的选择取决于Allegro模型配置（这里为deployed.pth）。
GROMACS作业
当前TCB集群提供GROMACS两种编译版本
- app/gromacs/2024.2 ：多分区（队列）通用版本， CUDA 12.5+MPI+HWLOC版本，使用AVX_256 SIMD
- app/gromacs/2024.2-gpu ：gpu分区专用版，CUDA 12.5+MPI+HWLOC版本，使用AVX2_256 SIMD
GROMACS编译版本说明
由于gpu分区（队列）CPU型号比single、normal分区中CPU型号更高级，支持AVX512 SIMD，而GROMACS会采用自动选择更高级SIMD编译代码，导致gpu分区上编译的版本，无法运行在single和normal分区中。而反过来由于兼容的原因，在single、normal和login等节点上编译的GROMACS可用运行在gpu队列，即app/gromacs/2024.2可以运行在gpu分区的CPU上（不调用GPU卡）。
使用module add app/gromacs/2024.2或app/gromacs/2024.2-gpu会自动加载依赖库。一般情况使用前者app/gromacs/2024.2即可。首先确认下当前Gromacs编译版本信息，有利于我们对测试结果的性能分析。
[xushun@login ~]$ module add app/gromacs/2024.2
Loading app/gromacs/2024.2
Loading requirement: cuda/12.5 openmpi/5.0.6 lib/fftw/3.3.10 lib/openblas/0.3.26
[xushun@login ~]$ gmx_mpi -quiet -version
:-) GROMACS - gmx_mpi, 2024.2 (-:
Executable: /opt/local/gromacs-2024.2/bin/gmx_mpi
Data prefix: /opt/local/gromacs-2024.2
Working dir: /opt/home1/xushun
Command line:
gmx_mpi -quiet -version
GROMACS version: 2024.2
Precision: mixed
Memory model: 64 bit
MPI library: MPI
MPI library version: Open MPI v5.0.6, package: Open MPI root@login Distribution, ident: 5.0.6, repo rev: v5.0.6, Nov 15, 2024
OpenMP support: enabled (GMX_OPENMP_MAX_THREADS = 128)
GPU support: CUDA
NBNxM GPU setup: super-cluster 2x2x2 / cluster 8
SIMD instructions: AVX_256
CPU FFT library: fftw-3.3.10-sse2-avx
GPU FFT library: cuFFT
Multi-GPU FFT: none
RDTSCP usage: enabled
TNG support: enabled
Hwloc support: hwloc-2.7.1
Tracing support: disabled
C compiler: /usr/bin/cc GNU 11.5.0
C compiler flags: -fexcess-precision=fast -funroll-all-loops -mavx -Wno-missing-field-initializers -O3 -DNDEBUG
C++ compiler: /usr/bin/c++ GNU 11.5.0
C++ compiler flags: -fexcess-precision=fast -funroll-all-loops -mavx -Wno-missing-field-initializers -Wno-cast-function-type-strict -fopenmp -O3 -DNDEBUG
BLAS library: External - detected on the system
LAPACK library: External - detected on the system
CUDA compiler: /opt/local/cuda-12.5/bin/nvcc nvcc: NVIDIA (R) Cuda compiler driver;Copyright (c) 2005-2024 NVIDIA Corporation;Built on Wed_Apr_17_19:19:55_PDT_2024;Cuda compilation tools, release 12.5, V12.5.40;Build cuda_12.5.r12.5/compiler.34177558_0
CUDA compiler flags:-std=c++17;--generate-code=arch=compute_50,code=sm_50;--generate-code=arch=compute_52,code=sm_52;--generate-code=arch=compute_60,code=sm_60;--generate-code=arch=compute_61,code=sm_61;--generate-code=arch=compute_70,code=sm_70;--generate-code=arch=compute_75,code=sm_75;--generate-code=arch=compute_80,code=sm_80;--generate-code=arch=compute_86,code=sm_86;--generate-code=arch=compute_89,code=sm_89;--generate-code=arch=compute_90,code=sm_90;-Wno-deprecated-gpu-targets;--generate-code=arch=compute_53,code=sm_53;--generate-code=arch=compute_80,code=sm_80;-use_fast_math;-Xptxas;-warn-double-usage;-Xptxas;-Werror;-D_FORCE_INLINES;-Xcompiler;-fopenmp;-fexcess-precision=fast -funroll-all-loops -mavx -Wno-missing-field-initializers -Wno-cast-function-type-strict -fopenmp -O3 -DNDEBUG
CUDA driver: 0.0
CUDA runtime: 12.50
[xushun@login ~]$ srun -p gpu gmx_mpi -quiet -version|grep "CUDA driver"
CUDA driver: 12.50
从以上日志可见：该版本（app/gromacs/2024.2）在login节点CUDA driver 0.0，即无GPU卡支持，但程序可运行起来，而在gpu 分区上可识别CUDA driver为正常值。因此该版本可在所有Slurm分区上运行，并会自动GPU卡加速。app/gromacs/2024.2-gpu只能提交多到gpu分区，为了可能的性能提升。
实例测试
下载测试实例
[xushun@login ~]$ git clone --depth 1 https://gitlab.com/orise/gromacs-hip.git
[xushun@login ~]$ cd gromacs-hip/examples/
[xushun@login examples]$ ls
cyp2c9_warfarin lysozyme_water protein_membrane water_opls
gromacs-hip项目是适配国产GPU的测试实例，提供4个Gromacs测试实例，这里选择lysozyme_water测试实例。为了适配TCB集群环境，只需要修改作业提交脚本lysozyme_water/run_slurm.sh如下
[xushun@login lysozyme_water]$ cat run_slurm.sh
#!/bin/bash
#SBATCH -J lysozyme
#SBATCH -p normal
#SBATCH -N 1
#SBATCH --ntasks-per-node=4
#SBATCH --exclusive
#SBATCH -o %x-%j.log
env|grep SLURM
export NAME_PREFIX=${SLURM_JOB_NAME}-${SLURM_JOBID}-${SLURM_NTASKS}n${SLURM_NNODES}N
export OMP_NUM_THREADS=6 #${SLURM_CPUS_PER_TASK}
module purge
module add app/gromacs/2024.2
if [ ! -f run.tpr ] ; then
gmx_mpi grompp -f md.mdp -c npt.gro -p topol.top -po md-out.mdp -o run.tpr
fi
date
mpirun --bind-to core -report-bindings gmx_mpi mdrun -v -dlb yes -pin on -deffnm ${NAME_PREFIX} -s run.tpr -nsteps 100000
rm -f \#*\#
#grep -E "Core|Atoms" -A 4 *-*-*.log
#sbatch this.sh
建议删除旧的run.tpr文件，让Gromacs软件自动生成最新版本的run.tpr文件。其他的Gromacs作业可以 仿照其写提交脚本。
该配置脚本默认每个节点开启4个MPI rank（–ntasks-per-node=4），每个mpi rank使用6个OpenMP线程并行（OMP_NUM_THREADS=6）。使用sbatch提交时，可重载脚本内的配置参数。
#sbatch run_slurm.sh #默认配置
sbatch -p gpu -N 1 run_slurm.sh #在gpu分区，使用1个节点并行
sbatch -p normal -N 1 run_slurm.sh #在normal分区，使用1个节点并行
sbatch -p normal -N 2 run_slurm.sh #在normal分区，使用2个节点并行
sbatch -p normal -N 3 run_slurm.sh #在normal分区，使用3个节点并行
sbatch -p normal -N 4 run_slurm.sh #在normal分区，使用4个节点并行
sbatch -p single -N 1 run_slurm.sh #在single分区，使用2个节点并行
sbatch -p single -N 2 run_slurm.sh #在single分区，使用2个节点并行
sbatch -p single -N 3 run_slurm.sh #在single分区，使用3个节点并行
sbatch -p single -N 4 run_slurm.sh #在single分区，使用4个节点并行
使用提取命令查看性能日志
[xushun@login lysozyme_water]$ grep -E "Core|SLURM_JOB_PARTITION" -A 4 *-*[[:digit:]].log
lysozyme-186.log:SLURM_JOB_PARTITION=gpu
lysozyme-186.log-SLURM_JOB_NUM_NODES=1
lysozyme-186.log-SLURM_JOBID=186
lysozyme-186.log-SLURM_PROCID=0
lysozyme-186.log-SLURM_NTASKS=4
--
lysozyme-186.log: Core t (s) Wall t (s) (%)
lysozyme-186.log- Time: 2272.803 94.704 2399.9
lysozyme-186.log- (ns/day) (hour/ns)
lysozyme-186.log-Performance: 182.465 0.132
lysozyme-186.log-
--
lysozyme-187.log:SLURM_JOB_PARTITION=normal
lysozyme-187.log-SLURM_JOB_NUM_NODES=1
lysozyme-187.log-SLURM_JOBID=187
lysozyme-187.log-SLURM_PROCID=0
lysozyme-187.log-SLURM_NTASKS=4
--
lysozyme-187.log: Core t (s) Wall t (s) (%)
lysozyme-187.log- Time: 15362.366 640.100 2400.0
lysozyme-187.log- (ns/day) (hour/ns)
lysozyme-187.log-Performance: 26.996 0.889
lysozyme-187.log-
--
lysozyme-188.log:SLURM_JOB_PARTITION=normal
lysozyme-188.log-SLURM_JOB_NUM_NODES=2
lysozyme-188.log-SLURM_JOBID=188
lysozyme-188.log-SLURM_PROCID=0
lysozyme-188.log-SLURM_NTASKS=8
--
lysozyme-188.log: Core t (s) Wall t (s) (%)
lysozyme-188.log- Time: 17890.063 372.712 4800.0
lysozyme-188.log- (ns/day) (hour/ns)
lysozyme-188.log-Performance: 46.363 0.518
lysozyme-188.log-
--
lysozyme-189.log:SLURM_JOB_PARTITION=normal
lysozyme-189.log-SLURM_JOB_NUM_NODES=3
lysozyme-189.log-SLURM_JOBID=189
lysozyme-189.log-SLURM_PROCID=0
lysozyme-189.log-SLURM_NTASKS=12
--
lysozyme-189.log: Core t (s) Wall t (s) (%)
lysozyme-189.log- Time: 21381.331 296.965 7200.0
lysozyme-189.log- (ns/day) (hour/ns)
lysozyme-189.log-Performance: 58.189 0.412
lysozyme-189.log-
--
lysozyme-190.log:SLURM_JOB_PARTITION=normal
lysozyme-190.log-SLURM_JOB_NUM_NODES=4
lysozyme-190.log-SLURM_JOBID=190
lysozyme-190.log-SLURM_PROCID=0
lysozyme-190.log-SLURM_NTASKS=16
--
lysozyme-190.log: Core t (s) Wall t (s) (%)
lysozyme-190.log- Time: 38140.654 397.300 9600.0
lysozyme-190.log- (ns/day) (hour/ns)
lysozyme-190.log-Performance: 43.494 0.552
lysozyme-190.log-
--
lysozyme-191.log:SLURM_JOB_PARTITION=single
lysozyme-191.log-SLURM_JOB_NUM_NODES=1
lysozyme-191.log-SLURM_JOBID=191
lysozyme-191.log-SLURM_PROCID=0
lysozyme-191.log-SLURM_NTASKS=4
--
lysozyme-191.log: Core t (s) Wall t (s) (%)
lysozyme-191.log- Time: 14945.552 622.733 2400.0
lysozyme-191.log- (ns/day) (hour/ns)
lysozyme-191.log-Performance: 27.749 0.865
lysozyme-191.log-
--
lysozyme-192.log:SLURM_JOB_PARTITION=single
lysozyme-192.log-SLURM_JOB_NUM_NODES=2
lysozyme-192.log-SLURM_JOBID=192
lysozyme-192.log-SLURM_PROCID=0
lysozyme-192.log-SLURM_NTASKS=8
--
lysozyme-192.log: Core t (s) Wall t (s) (%)
lysozyme-192.log- Time: 49187.843 1024.748 4800.0
lysozyme-192.log- (ns/day) (hour/ns)
lysozyme-192.log-Performance: 16.863 1.423
lysozyme-192.log-
--
lysozyme-193.log:SLURM_JOB_PARTITION=single
lysozyme-193.log-SLURM_JOB_NUM_NODES=3
lysozyme-193.log-SLURM_JOBID=193
lysozyme-193.log-SLURM_PROCID=0
lysozyme-193.log-SLURM_NTASKS=12
--
lysozyme-193.log: Core t (s) Wall t (s) (%)
lysozyme-193.log- Time: 71138.919 988.042 7200.0
lysozyme-193.log- (ns/day) (hour/ns)
lysozyme-193.log-Performance: 17.489 1.372
lysozyme-193.log-
--
lysozyme-194.log:SLURM_JOB_PARTITION=single
lysozyme-194.log-SLURM_JOB_NUM_NODES=4
lysozyme-194.log-SLURM_JOBID=194
lysozyme-194.log-SLURM_PROCID=0
lysozyme-194.log-SLURM_NTASKS=16
--
lysozyme-194.log: Core t (s) Wall t (s) (%)
lysozyme-194.log- Time: 64843.394 675.453 9600.0
lysozyme-194.log- (ns/day) (hour/ns)
lysozyme-194.log-Performance: 25.583 0.938
lysozyme-194.log-
可见gpu分区182.465 ns/day，而normal单节点只有26.996 ns/day，使用normal多节点性能有所提升，但到4节点并行时，性能开始下降； 而在single分区作业多节点运行反而不如单节点运行性能，因为single分区节点之间通过相对慢的以太网连接，跨节点MPI网络通信是很大瓶颈；而normal分区节点之间通过infiniband高速互联，跨节点MPI通信使用ConnectX-3的4X10.0 Gbps 速率相对以太网还是快不少。
Slurm系统使用参考资料