HPC超算系列4——官方指南文档

/lustre 目录挂载的为 HPC+AI平台集群（除思源一号外）中的主文件系统，共 13.1P，用户的个人目录即位于该目录。

主文件系统主要使用 HDD 盘搭建，旨在提供大容量、高可用、较高性能的存储供用户使用。搭建过程中，使用 RAID 保障硬盘级别的数据安全，使用 HA（High Availability） 保障服务器级别的高可用。

用户的主要工作、重要数据都应该发生和存储在主文件系统。

用户通过个人账户登录计算节点（包括登录节点）之后，默认进入主文件系统，即 HOME 目录。可以在以下路径找到 /lustre 提供给用户的空间：

/lustre/home/acct-xxxx/yyyy

其中acct-xxxx代表计费帐号（课题组帐号），yyyy代表个人帐号。

通过 cd cd $HOME cd ~ 等方式都可进入主目录。

/scratch 目录挂载的为 HPC+AI平台集群（除思源一号外）的全闪存并行文件系统，共 108T 容量，可用作用户的临时工作目录。

全闪存文件系统使用全套的 SSD（NVMe协议） 硬盘搭建，旨在提供高性能的存储供用户使用，可更好地支持 IO 密集型作业。对系统来说，单客户端最大读带宽达 5.7GB/s，最大写带宽达 10GB/s；4k 小文件读 IOPS 达 170k，写 IOPS 达 126k。但同时，由于成本问题，系统提供的容量较小；在搭建时也未设置高可用和数据备份，存在数据存储安全性不高等问题。

基于该套系统的特性，推荐用户将其作为临时工作目录，可用于

1. 存储计算过程中产生的临时文件
2. 保存读写频率高的文件副本

注意：为了保持全闪存文件系统的稳定可用，/scratch 目录每 3 个月会进行一次清理。因此，请务必及时将重要数据保存回 /lustre 目录。

用户可以在以下路径找到 /scratch 提供的暂存空间： /scratch/home/acct-xxxx/yyyy

其中acct-xxxx代表计费帐号（课题组帐号），yyyy代表个人帐号。

为了快捷访问，我们已经为用户设置好环境变量，cd $SCRATCH 即可进入该临时工作目录。

我们使用生信 WES 分析流程为例，该流程从测序文件开始，经 bwa 比对、samtools处理，然后用 GATK 检测变异（部分步骤）。 原代码如下：

#!/bin/bash

#SBATCH --job-name=WES
#SBATCH --partition=cpu
#SBATCH --output=%j.out
#SBATCH --error=%j.err
#SBATCH -N 1
#SBATCH --ntasks-per-node=40
#SBATCH --exclusive

echo "##### 加载相关软件 #####"
module load bwa samtools
module load miniconda3 && source activate 10_24  # gatk-4.1.9.0

echo "##### 设置变量 #####"
REFDIR=$HOME/med/annotation/gatk/hg19  # 参考基因组和注释文件目录
SAMPLEDIR=$HOME/med/testnor  # 样本目录

WORKDIR=$HOME/WES_TEST  # 工作目录
TMPDIR=$WORKDIR/tmpdir  # 临时缓存目录
mkdir -p $WORKDIR
mkdir -p $TMPDIR

SampleID=test  # 样本名

cd $WORKDIR

echo "##### bwa 比对 #####"
bwa mem -M -t 40 \
${REFDIR}/ucsc.hg19.fasta \
${SAMPLEDIR}/${SampleID}_1.fastq.gz \
${SAMPLEDIR}/${SampleID}_2.fastq.gz \
| gzip -3 > ${SampleID}_mem.sam

echo "##### samtools 生成bam #####"
samtools view -@ 40 -bS ${SampleID}_mem.sam \
| samtools sort -@ 40 > ${SampleID}_mem.sorted.bam

samtools index ${SampleID}_mem.sorted.bam

echo "##### gatk 检测变异 #####"
gatk ReorderSam \
-I ${SampleID}_mem.sorted.bam \
-O ${SampleID}_mem.sorted.reorder.bam \
-R ${REFDIR}/ucsc.hg19.fasta \
--TMP_DIR ${TMPDIR} \
--VALIDATION_STRINGENCY LENIENT \
--SEQUENCE_DICTIONARY ${REFDIR}/ucsc.hg19.dict \
--CREATE_INDEX true

gatk MarkDuplicates \
-I ${SampleID}_mem.sorted.reorder.bam \
-O ${SampleID}_mem.sorted.reorder.rmdup.bam \
--TMP_DIR ${TMPDIR} \
--REMOVE_DUPLICATES false \
--ASSUME_SORTED true \
--METRICS_FILE ${SampleID}_mem.sorted.reorder.markduplicates_metrics.txt \
--OPTICAL_DUPLICATE_PIXEL_DISTANCE 2500 \
--VALIDATION_STRINGENCY LENIENT \
--CREATE_INDEX true

过程中，会产生许多中间文件和临时文件。因此，可利用 $SCRATCH作为临时目录，加快分析过程。只需要把脚本中的‘WORKDIR=$HOME/WES_TEST修改为WORKDIR=$SCRATCH/WES_TEST`即可。

在 data （data.hpc.sjtu.edu.cn） 节点的目录 /archive 下挂载了挂挡存储，共 3P 容量，用来存储用户的不常用数据。

归档文件系统主要使用机械硬盘搭建，可提供大容量、高可用的存储供用户使用。搭建过程中，使用 RAID 保障硬盘级别的数据安全，使用 HA（High Availability） 保障服务器级别的高可用。归档文件系统作为主文件系统的一个补充，主要提供给用户存储不常用的数据（冷数据），从而释放主文件系统的存储空间、缓解主文件系统的存储压力。

** 注意：和主文件系统以及全闪存文件系统不同，归档文件系统只能在 data 节点访问，无法在计算节点和登录节点访问，也就是说保存在该文件系统的数据不能在计算节点读取并参与计算，因此只推荐保存不常使用的数据。**

1. 登录 data 节点

# ssh $USER@data.hpc.sjtu.edu.cn

1. 进入归档文件系统

用户可以在以下路径找到 /archive 提供的个人存储空间: /archive/home/acct-xxxx/yyyy

其中 acct-xxxx 代表计费帐号（课题组帐号），yyyy 代表个人帐号。

为了快捷访问，我们已经为用户设置好环境变量，cd $ARCHIVE 即可进入。

1. 将不常用文件移动到 $ARCHIVE

# rsync -avh -P --append-verify $DATA $ARCHIVE

推荐使用 rsync 移动数据，详细参数含义可使用 man rsync 命令查看。

在浏览器中，打开：https://studio.hpc.sjtu.edu.cn

小技巧

浏览器需为Chrome，Firefox或Edge。

点击图标Files下拉菜单Home Directory即可进入文件管理界面

文件管理包含以下功能：

点击Jobs->Active Jobs，查看队列中的作业。在右上角的Your Jobs/All Jobs中选择要查看的任务类型。

点击作业项前的箭头查看作业详情。

点击Jobs->Job Composer，打开新建作业选项卡。

点击左上角New Job（1）按钮，选择模板，点击submit（2）按钮提交作业。

同时HPC Studio提供了在线文本编辑功能，在右侧底部的Submit Script选项卡中，点击Open Editor按钮，即可打开文本编辑器。

点击 Clusters->sjtu Shell Access ,打开在线终端。

远程桌面打开方式需先提交一个空的作业取得计算节点的控制权（此操作会计入机时）。

点击Interactive Apps->Desktop按钮，进入作业提交页面。

Number of hours 默认是 1，然后点击 launch 即可进入桌面选项卡。

待选项卡显示作业在running的状态时,点击launch即可进入远程桌面。

2022 春季用户培训之HPC Studio

https://vshare.sjtu.edu.cn/play/f8e22f383e28d22acd6d556f913886b7

另外一个可视化平台就是Jupyter了，Julia+Python+R，可以参考我之前的博客，我经常使用。

Jupyter是一个非营利组织，旨在“为数十种编程语言的交互式计算开发开源软件，开放标准和服务”。2014年由Fernando Pérez从IPython中衍生出来，Jupyter支持几十种语言的执行环境。

Jupyter Project的名称是对Jupyter支持的三种核心编程语言的引用，这三种语言是Julia、Python和R，也是对伽利略记录发现木星的卫星的笔记本的致敬。Jupyter项目开发并支持交互式计算产品Jupyter Notebook、JupyterHub和JupyterLab，这是Jupyter Notebook的下一代版本。

登录HPC Studio平台后，可以在内置应用中选择Jupyter或Jupyer (GPU)，均支持Jupyter Notebook和JupyterLab。

已有三个预置环境，可供用户使用：

新建环境（或使用已有环境）:

$ module load miniconda3
$ conda create -n test-env
$ source activate test-env

安装并注册为jupter kernel：

(test-env) $ conda install ipykernel
(test-env) $ python -m ipykernel install --user --name test-env --display-name "Test Environment"

然后可以在Jupyter中选择名为Test Environment的Kernel进行计算。

如果环境需要依赖NVIDIA CUDA Toolkit或NVIDIA cuDNN，可以使用conda进行安装：

(test-env) $ conda install cudatoolkit=10.1 cudnn

新建环境（或使用已有环境）:

$ module load miniconda3
$ conda create -n r-test-env
$ source activate r-test-env
$ (r-test-env) $ conda install -c r r-essentials

安装并注册为jupter kernel：

(test-env) $ R
> install.packages('IRkernel')
> IRkernel::installspec(name = 'r-test-env', displayname = 'R 3.6.1')

然后可以在Jupyter中选择名为R 3.6.1的Kernel进行计算。

• Jupyter Wikepedia
• Jupyter Home

除了最常用的Jupyter notebook，我本科时候第2常用的就是Rstudio server了。

RStudio是一个集成开发环境，主要支持R编程语言，专用于统计计算和图形。它包括一个控制台，支持代码执行的语法编辑器，以及用于绘制，调试和管理工作区的工具。

使用超算的账号及密码登录 HPC Studio ，在导航栏 Interactive Apps 中选择 RStudio Server ，如下图：

点击后会出现相关的启动界面，可以设置作业时间，资源情况，软件版本。设置完成后 Launch 即可运行：

小技巧

π2.0 集群和思源一号的数据不互通，注意区分。

待界面从排队变成 Running 后，可通过 Connect to RStudio Server 连接到 Rstudio Server ：

所需的 R 依赖包需要自行安装：

# Upload library
library(circlize)
circos.par("track.height" = 0.4)

# Create data
data = data.frame(
  factor = sample(letters[1:8], 1000, replace = TRUE),
  x = rnorm(1000),
  y = runif(1000)
)

# Step1: Initialise the chart giving factor and x-axis.
circos.initialize( factors=data$factor, x=data$x )

# Step 2: Build the regions.
circos.trackPlotRegion(factors = data$factor, y = data$y, panel.fun = function(x, y) {
  circos.axis()
})

# Step 3: Add points
circos.trackPoints(data$factor, data$x, data$y, col="#69b3a2")

——》该部分的常见问题：

经过安全升级后，超算平台不再支持传统的公私钥免密，将公钥写入个人家目录的 ~/.ssh/authorized_keys 不会 再赋予您免密登录的权限。

如果您希望继续进行SSH免密登录，需要从 超算账号管理平台 申请免密证书。以RSA密钥为例，公私钥免密和证书免密的区别如下表所示。

申请免密证书的方法请参阅 账号安全信息管理 的相关章节。

此章节同样适用于原生linux环境进行免密登录。

将下载得到的证书文件存放到 ~/.ssh/ 目录，同时您原有的或者下载得到的私钥文件也应该存在于此目录，并与证书文件名保持上表所示的匹配关系。如果您不确定Mobaxterm将个人家目录映射到了哪里，请打开 settings - configurations 检查下图所示的路径配置。

Mobaxterm查看个人目录映射位置¶

之后在免密有效期内发起ssh连接即可实现免密登录。

经过安全升级后，超算平台不再支持传统的公私钥免密，将公钥写入个人家目录的 ~/.ssh/authorized_keys 不会 再赋予您免密登录的权限。

如果您希望继续进行SSH免密登录，需要从 超算账号管理平台 申请免密证书。以RSA密钥为例，公私钥免密和证书免密的区别如下表所示。

申请免密证书的方法请参阅 账号安全信息管理 的相关章节。

此章节同样适用于原生linux环境进行免密登录。

将下载得到的证书文件存放到 ~/.ssh/ 目录，同时您原有的或者下载得到的私钥文件也应该存在于此目录，并与证书文件名保持上表所示的匹配关系。如果您不确定Mobaxterm将个人家目录映射到了哪里，请打开 settings - configurations 检查下图所示的路径配置。

Mobaxterm查看个人目录映射位置¶

之后在免密有效期内发起ssh连接即可实现免密登录。

（在集群上）$ rm -f ~/.ssh/authorized_keys             # 清除服务器上原有的 authorized_keys
（在自己电脑上）$ rm  ~/.ssh/id*                           # 清除本地 .ssh 文件夹中的密钥对
（在自己电脑上）$ ssh-keygen -t rsa                        # 在本地重新生成密钥对。第二个问题，设置密码短语 (passphrase)，并记住密码短语
（在自己电脑上）$ ssh-keygen -R sylogin.hpc.sjtu.edu.cn    # 清理本地 known_hosts 里关于集群的条目
（在自己电脑上）$ ssh-copy-id YOUR_USERNAME@TARGET_IP      # 将本地新的公钥发给服务器，存在服务器的 authorized_keys 文件里

若遇到上方图片中的问题，请重置 known_hosts，命令如下：

（在自己电脑上）$ ssh-keygen -R sylogin.hpc.sjtu.edu.cn

如果 SSH 客户端长时间静默后，SSH 服务器端会自动断开相关会话。要解决这个，需要调整 SSH 的 keepalive 值，设置一个较长的静默时长阈值。

对于 Mac/Linux 用户，并且使用操作系统原生的终端 (terminal)，需要修改 $HOME/.ssh/config。具体的，在文件中添加如下内容：

Host pi-sjtu-login:
    HostName sylogin.hpc.sjtu.edu.cn
    ServerAliveInterval 240

其中 ServerAliveInterval 后的值即为阈值，单位为秒，用户可根据需要自行调整。

或者为了对所有的服务器设置长静默阈值：

Host *
    ServerAliveInterval 240

之后保持 config文件为只可读：

chmod 600 ~/.ssh/config

演示如下：
我们依据习惯，设置该值为30mins，也就是30*60=1800s

vim $HOME/.ssh/config

# 修改为：

Host *
    ServerAliveInterval 1800

# 然后
chmod 600 ~/.ssh/config

当然，上面只是简单配置，具体细节部分参考：https://linux.die.net/man/5/ssh_config

集群中已经默认安装了Tmux，无须操作。如果您需要在自己的服务器上安装Tmux，请参考以下指令：

# Ubuntu 或 Debian
$ sudo apt-get install tmux

# CentOS 或 Fedora
$ sudo yum install tmux

# Mac
$ brew install tmux

直接在终端中键入tmux指令，即可进入Tmux窗口。

$ tmux

上面命令会启动 Tmux 窗口，底部有一个状态栏。状态栏的左侧是窗口信息（编号和名称），右侧是系统信息。

按下Ctrl+d或者显式输入exit命令，就可以退出 Tmux 窗口。

$ exit

Tmux有大量的快捷键。所有的快捷键都要使用Ctrl+b作为前缀唤醒。我们将会在后续章节中讲解快捷键的具体使用。

第一个启动的会话名为0，之后是1、2一次类推。

但是有时候我们希望为会话起名以方便区分。

$ tmux new -s SESSION_NAME

以上指令启动了一个名为SESSION_NAME的会话。

如果我们想离开会话，但又不想关闭会话，有两种方式。按下Ctrl+b d或者tmux detach指令，将会分离会话与窗口

$ tmux detach

后面一种方法要求当前会话无正在运行的进程，即保证终端可操作。我们更推荐使用前者。

要查看当前已有会话，使用tmux ls指令。

$ tmux ls

tmux attach命令用于重新接入某个已存在的会话。

# 使用会话编号
$ tmux attach -t 0

# 使用会话名称
$ tmux attach -t SESSION_NAME

tmux kill-session命令用于杀死某个会话。

# 使用会话编号
$ tmux kill-session -t 0

# 使用会话名称
$ tmux kill-session -t SESSION_NAME

tmux switch命令用于切换会话。

# 使用会话编号
$ tmux switch -t 0

# 使用会话名称
$ tmux switch -t SESSION_NAME

Ctrl+b s可以快捷地查看并切换会话

tmux rename-session命令用于重命名会话。

# 将0号会话重命名为SESSION_NAME
$ tmux rename-session -t 0 SESSION_NAME

对应快捷键为Ctrl+b $。

Tmux可以将窗口分成多个窗格（window），每个窗格运行不同的命令。以下命令都是在Tmux窗口中执行。

tmux split-window命令用来划分窗格。

# 划分上下两个窗格
$ tmux split-window

# 划分左右两个窗格
$ tmux split-window -h

对应快捷键为Ctrl+b "和Ctrl+b %

tmux select-pane命令用来移动光标位置。

# 光标切换到上方窗格
$ tmux select-pane -U

# 光标切换到下方窗格
$ tmux select-pane -D

# 光标切换到左边窗格
$ tmux select-pane -L

# 光标切换到右边窗格
$ tmux select-pane -R

对应快捷键为Ctrl+b ↑、Ctrl+b ↓、Ctrl+b ←、Ctrl+b →。

$ Ctrl+b %：划分左右两个窗格。
$ Ctrl+b "：划分上下两个窗格。
$ Ctrl+b <arrow key>：光标切换到其他窗格。<arrow key>是指向要切换到的窗格的方向键，比如切换到下方窗格，就按方向键↓。
$ Ctrl+b ;：光标切换到上一个窗格。
$ Ctrl+b o：光标切换到下一个窗格。
$ Ctrl+b {：当前窗格左移。
$ Ctrl+b }：当前窗格右移。
$ Ctrl+b Ctrl+o：当前窗格上移。
$ Ctrl+b Alt+o：当前窗格下移。
$ Ctrl+b x：关闭当前窗格。
$ Ctrl+b !：将当前窗格拆分为一个独立窗口。
$ Ctrl+b z：当前窗格全屏显示，再使用一次会变回原来大小。
$ Ctrl+b Ctrl+<arrow key>：按箭头方向调整窗格大小。
$ Ctrl+b q：显示窗格编号。

下图为 Pi 2.0、思源一号集群目前的存储架构，展示了各节点可以访问到的存储系统。

文件系统可以管理数据和访问数据，不同的文件系统具有不同的特点。下面的表格介绍了超算平台使用的文件系统的特征。

• Lustre/GPFS 文件系统：提供了大容量、高可用、较高性能的存储，是 Pi2.0、思源一号集群的主要存储系统，是用户通过登录节点后默认进入的文件系统。用户的主要工作和常用数据都位于该文件系统。用户通过 cd $HOME 可以跳转到 Lustre/GPFS 下自己的目录。
• 全闪存文件系统：使用全套 NVMe SSD 搭建的高性能存储可以更好地支持 I/O 密集作业。该系统容量较小，同时未设置高可用，会定期清理数据，推荐将其作为临时工作目录使用。用户通过 cd $SCRATCH 可以跳转到全闪存文件系统下自己的目录。
• 冷存储系统：作为 Lustre/GPFS 文件系统的补充，提供大容量、高可用的存储，只能在传输节点访问，主要给用户存放不常用的数据。冷存储系统具有快照功能，快照可以恢复用户误删除的数据。用户通过 cd $ARCHIVE 可以跳转到冷存储下自己的目录。

此处演示如下：

每个文件系统的应用场景如下：

因为存储介质、搭建方法不同，文件系统有各自适用的使用场景。

场景一：将数据从用户本地传输到 Pi 2.0 集群，再提交作业处理数据

1. 用户从本地终端，使用 scp/rsync 等命令向 data 传输节点发起数据传输
2. 用户登录 Pi 2.0 登录节点，此时可以访问到之前传输的数据，然后用户提交 Slurm 作业

可以参考：

• 数据传输方法
• 通过远程挂载读写超算平台的数据

——》这个是最常用的！！！

场景二：使用全闪存文件系统作为临时目录

1. 在 Slurm 脚本中，自定义一个目录 $SCRATCH/tmp_dir 作为临时目录存放中间文件，加快计算过程
2. 计算完成后，将计算结果及时从 Scratch 转移到 Lustre/GPFS 系统

可以参考：

• 如何使用全闪存文件系统

场景三：将 Lustre 文件系统中不常用的数据迁移到冷存储

1. 用户登录到 data 传输节点，通过 rsync 等命令向冷存储迁移数据
2. 通过数据校验，确认数据完整迁移到了冷存储
3. 清理原文件，释放存储空间

可以参考：

• 科学数据平台（冷存储系统）数据使用指南

场景四：将数据集发布在科学数据平台

科学数据平台 致力打造科学数据全生命周期管理平台，具有发布数据、共享数据、下载公共数据功能的数据平台，您可以将公开数据集发布在平台上。

数据平台简明使用指南可以参考：

• 科学数据平台使用指南

另外我们需要关注的是对整个文件系统的选择：

https://docs.hpc.sjtu.edu.cn/transport/transportsolution.html

少量的数据直接使用具有SFTP功能的ssh客户端进行传输，或者使用linux数据传输工具，建议在数据传输节点进行操作，不要在登入节点操作！！！

思源一号集群设置以下队列，使用限制与说明如下

该集群另外设置了调试队列 debug64c512g 和 debuga100 ，仅用于短时间测试，请勿批量投递作业进行完整计算。 debug64c512g 作业最多申请2节点，运行60分钟。 debuga100 作业最多申请1节点，运行20分钟。

π 2.0 和 AI 集群设置以下队列，使用限制与说明如下

π 2.0集群也设置了 debug 队列用于短时间测试，作业最多申请2节点，最长运行时间为20分钟。

ARM 集群设置以下队列，使用限制与说明如下

以上信息在各集群登录界面均有展示。

huge 和 192c6t 队列默认的作业运行最长时间为 2 天，其余队列默认的作业运行最长时间为 7 天。

若预计超出 7 天，需提前 2 天发邮件告知用户名和 jobID 以便延长时限。延长后的作业最长运行时间不超过 14 天。

节点状态包括：

drain(节点故障)，alloc(节点在用)，idle(节点可用)，down(节点下线)，mix(节点部分占用，但仍有剩余资源）。

查看总体资源信息：

$ sinfo
PARTITION AVAIL  TIMELIMIT  NODES  STATE NODELIST
cpu         up  7-00:00:0    656   idle cas[001-656]
dgx2        up  7-00:00:0      8   idle vol[01-08]

作业状态包括R(正在运行)，PD(正在排队)，CG(即将完成)，CD(已完成)。

默认情况下，squeue只会展示在排队或在运行的作业。

$ squeue
JOBID PARTITION     NAME     USER ST       TIME  NODES NODELIST(REASON)
18046      dgx2   ZXLing     eenl  R    1:35:53      1 vol04
17796      dgx2   python    eexdl  R 3-00:22:04      1 vol02

显示您自己账户下的作业：

squeue
JOBID PARTITION     NAME     USER ST       TIME  NODES NODELIST(REASON)
17923      dgx2     bash    hpcwj  R 1-12:59:05      1 vol05

-l选项可以显示更细节的信息。

squeue
JOBID PARTITION     NAME     USER    STATE       TIME TIME_LIMI  NODES NODELIST(REASON)
17923      dgx2     bash    hpcwj  RUNNING 1-13:00:53 30-00:00:00    1 vol05

准备作业脚本然后通过sbatch提交是 Slurm 的最常见用法。 为了将作业脚本提交给作业系统，Slurm 使用

$ sbatch jobscript.slurm

Slurm 具有丰富的参数集。 以下最常用的。

这是一个名为cpu.slurm的作业脚本，该脚本向cpu队列申请1个节点40核，并在作业完成时通知。在此作业中执行的命令是/bin/hostname。

#!/bin/bash

#SBATCH --job-name=hostname
#SBATCH --partition=cpu
#SBATCH -N 1
#SBATCH --mail-type=end
#SBATCH --mail-user=YOU@EMAIL.COM
#SBATCH --output=%j.out
#SBATCH --error=%j.err

/bin/hostname

用以下方式提交作业：

sbatch cpu.slurm

squeue可用于检查作业状态。用户可以在作业执行期间通过SSH登录到计算节点。输出将实时更新到文件[jobid] .out和[jobid] .err。

这里展示一个更复杂的作业要求，其中将启动80个进程，每台主机40个进程。

#!/bin/bash

#SBATCH --job-name=LINPACK
#SBATCH --partition=cpu
#SBATCH -n 80
#SBATCH --ntasks-per-node=40
#SBATCH --mail-type=end
#SBATCH --mail-user=YOU@EMAIL.COM
#SBATCH --output=%j.out
#SBATCH --error=%j.err

以下作业请求4张GPU卡，其中1个CPU进程管理1张GPU卡。

#!/bin/bash

#SBATCH --job-name=GPU_HPL
#SBATCH --partition=dgx2
#SBATCH -n 4
#SBATCH --ntasks-per-node=4
#SBATCH --gres=gpu:4
#SBATCH --mail-type=end
#SBATCH --mail-user=YOU@MAIL.COM
#SBATCH --output=%j.out
#SBATCH --error=%j.err

以下作业启动一个3任务序列（从0到2），每个任务需要1个CPU内核。关于集群上的Python，您可以查阅我们的Python文档。

#!/bin/bash

#SBATCH --job-name=python_array
#SBATCH --mail-user=YOU@MAIL.COM
#SBATCH --mail-type=ALL
#SBATCH --ntasks=1
#SBATCH --time=00:30:00
#SBATCH --array=0-2
#SBATCH --output=python_array_%A_%a.out
#SBATCH --output=python_array_%A_%a.err

module load miniconda2/4.6.14-gcc-4.8.5

source activate YOUR_ENV_NAME

echo "SLURM_JOBID: " $SLURM_JOBID
echo "SLURM_ARRAY_TASK_ID: " $SLURM_ARRAY_TASK_ID
echo "SLURM_ARRAY_JOB_ID: " $SLURM_ARRAY_JOB_ID

python < vec_${SLURM_ARRAY_TASK_ID}.py

srun可以启动交互式作业。该操作将阻塞，直到完成或终止。例如，在计算主机上运行hostname。

$ srun -N 1 -n 4 -p cpu hostname
cas006

启动远程主机bash终端：

srun -p cpu -n 4 --pty /bin/bash

或者，可以通过salloc请求资源，然后在获取节点后登录到计算节点：

salloc -N 1 -n 4 -p cpu
ssh casxxx

scontrol: 查看和修改作业参数

scontrol hold 命令可使排队中尚未运行的作业暂停被分配运行，被挂起的作业将不被执行。scontrol release 命令可取消挂起。

sacct 查看作业记录

默认情况下，sacct显示过去 24小时 的帐号作业信息。

$ sacct

查看更多的信息：

$ sacct --format=jobid,jobname,account,partition,ntasks,alloccpus,elapsed,state,exitcode -j 3224

查看平均作业内存消耗和最大内存消耗：

$ sacct --format="JobId,AveRSS,MaxRSS" -P -j xxx

2022 春季用户培训之slurm调度系统

• SLURM Workload Manager
• ACCRE’s SLURM Documentation
• Introduction to SLURM (NCCS lunchtime series)

根据集群的不同队列、不同应用软件，示例 slurm 作业脚本。

1. 编写作业脚本

vi test.slurm  # 根据需求，选择计算资源：CPU 或 GPU、所需核数、是否需要大内存

1. 提交作业

sbatch test.slurm

1. 查看作业和资源

squeue       # 查看正在排队或运行的作业

或

sacct        # 查看过去 24 小时内已完成的作业

集群资源实时状态查询

sinfo        # 若有 idle 或 mix 状态的节点，排队会比较快

cpu 队列 slurm 脚本示例：单节点不满核（例如20核），共享使用节点

#!/bin/bash

#SBATCH --job-name=test        # 作业名
#SBATCH --partition=cpu        # cpu 队列
#SBATCH -n 20                 # 总核数 20
#SBATCH --ntasks-per-node=20   # 每节点核数
#SBATCH --output=%j.out
#SBATCH --error=%j.err

cpu 队列 slurm 脚本示例：独占单节点不满核（20核），比如为了独占整个节点的大内存

#!/bin/bash

#SBATCH --job-name=test        # 作业名
#SBATCH --partition=cpu        # cpu 队列
#SBATCH -n 20                 # 总核数 20
#SBATCH --ntasks-per-node=20   # 每节点核数
#SBATCH --output=%j.out
#SBATCH --error=%j.err
#SBATCH --exclusive            # 独占节点（独占整个节点的大内存，按照满核计费）

cpu 队列 slurm 脚本示例：单节点满核（40 核）

#!/bin/bash

#SBATCH --job-name=test        # 作业名
#SBATCH --partition=cpu        # cpu 队列
#SBATCH -n 40                 # 总核数 40
#SBATCH --ntasks-per-node=40   # 每节点核数
#SBATCH --output=%j.out
#SBATCH --error=%j.err

cpu 队列 slurm 脚本示例：多节点（160 核）

#!/bin/bash

#SBATCH --job-name=test        # 作业名
#SBATCH --partition=cpu        # cpu 队列
#SBATCH -n 160                # 总核数 160
#SBATCH --ntasks-per-node=40   # 每节点核数
#SBATCH --output=%j.out
#SBATCH --error=%j.err

huge 队列 slurm 脚本示例：单节点（20 核，最高可用 80 核）

#!/bin/bash

#SBATCH --job-name=test         # 作业名
#SBATCH --partition=huge        # huge 队列
#SBATCH -n 20 # 总核数 20
#SBATCH --ntasks-per-node=20    # 每节点核数
#SBATCH --output=%j.out
#SBATCH --error=%j.err

192c6t 队列 slurm 脚本示例：单节点（96 核，最高可用 192 核）

#!/bin/bash

#SBATCH --job-name=test        # 作业名
#SBATCH --partition=192c6      # 192c6t 队列
#SBATCH -n 96                 # 总核数 96
#SBATCH --ntasks-per-node=96   # 每节点核数
#SBATCH --output=%j.out
#SBATCH --error=%j.err

dgx2 队列 slurm 脚本示例：单节点，分配 2 块 GPU，GPU:CPU 配比 1:6

#!/bin/bash

#SBATCH --job-name=test        # 作业名
#SBATCH --partition=dgx2       # dgx2 队列
#SBATCH -N 1
#SBATCH --ntasks-per-node=1
#SBATCH --cpus-per-task=12     # 1:6 的 GPU:CPU 配比
#SBATCH --gres=gpu:2           # 2 块 GPU
#SBATCH --output=%j.out
#SBATCH --error=%j.err

arm128c256g 队列 slurm 脚本示例：单节点60核

#!/bin/bash

#SBATCH --job-name=test
#SBATCH --partition=arm128c256g
#SBATCH -N 1
#SBATCH --ntasks-per-node=60
#SBATCH --output=%j.out
#SBATCH --error=%j.err

source /lustre/share/singularity/commercial-app/vasp/activate arm

mpirun -n $SLURM_NTASKS vasp_std

下面根据不同应用软件，示例 slurm 作业脚本

cpu 队列 slurm 脚本示例 LAMMPS

#!/bin/bash

#SBATCH --job-name=test         # 作业名
#SBATCH --partition=cpu         # cpu 队列
#SBATCH -n 80                  # 总核数 80
#SBATCH --ntasks-per-node=40    # 每节点核数
#SBATCH --output=%j.out
#SBATCH --error=%j.err

module load lammps

srun --mpi=pmi2 lmp -i YOUR_INPUT_FILE

cpu 队列 slurm 脚本示例 GROMACS

#!/bin/bash

#SBATCH --job-name=test         # 作业名
#SBATCH --partition=cpu         # cpu 队列
#SBATCH -n 80                  # 总核数 80
#SBATCH --ntasks-per-node=40    # 每节点核数
#SBATCH --output=%j.out
#SBATCH --error=%j.err

module load gromacs/2020-cpu

srun --mpi=pmi2 gmx_mpi mdrun -deffnm -s test.tpr -ntomp 1

cpu 队列 slurm 脚本示例 Quantum ESPRESSO

#!/bin/bash

#SBATCH --job-name=test         # 作业名
#SBATCH --partition=cpu         # cpu 队列
#SBATCH -n 80                  # 总核数 80
#SBATCH --ntasks-per-node=40    # 每节点核数
#SBATCH --output=%j.out
#SBATCH --error=%j.err

module load quantum-espresso

srun --mpi=pmi2 pw.x -i test.in

cpu 队列 slurm 脚本示例 OpenFoam

#!/bin/bash

#SBATCH --job-name=test         # 作业名
#SBATCH --partition=cpu         # cpu 队列
#SBATCH -n 80                  # 总核数 80
#SBATCH --ntasks-per-node=40    # 每节点核数
#SBATCH --output=%j.out
#SBATCH --error=%j.err

module load openfoam

srun --mpi=pmi2 icoFoam -parallel

gpu 队列 slurm 脚本示例 TensorFlow

#!/bin/bash

#SBATCH -J test
#SBATCH -p dgx2
#SBATCH -o %j.out
#SBATCH -e %j.err
#SBATCH -N 1
#SBATCH --ntasks-per-node=1
#SBATCH --cpus-per-task=12
#SBATCH --gres=gpu:2

module load miniconda3
source activate tf-env

python -c ’import tensorflow as tf; \
       print(tf.__version__); \
       print(tf.test.is_gpu_available());’

一批作业，若所需资源和内容相似，可借助 Job Array 批量提交。Job Array 中的每一个作业在调度时视为独立的作业。

cpu 队列 slurm 脚本示例 array

#!/bin/bash

#SBATCH --job-name=test           # 作业名
#SBATCH --partition=cpu           # cpu 队列
#SBATCH -n 1                      # 总核数 1
#SBATCH --ntasks-per-node=1       # 每节点核数
#SBATCH --output=array_%A_%a.out
#SBATCH --error=array_%A_%a.err
#SBATCH --array=1-20%10           # 总共 20 个子任务，每次最多同时运行 10 个

echo $SLURM_ARRAY_TASK_ID

–mail-type= 指定状态发生时，发送邮件通知: ALL, BEGIN, END, FAIL

cpu 队列 slurm 脚本示例：邮件提醒

#!/bin/bash

#SBATCH --job-name=test
#SBATCH --partition=cpu
#SBATCH -n 20
#SBATCH --ntasks-per-node=20
#SBATCH --output=%j.out
#SBATCH --error=%j.err
#SBATCH --mail-type=end           # 作业结束时，邮件提醒
#SBATCH --mail-user=XX@sjtu.edu.cn

可使用 seff jobid 命令查看单核所能使用的内存空间

[hpc@login2 data]$ seff 9709905
Job ID: 9709905
Cluster: sjtupi
User/Group: hpchgc/hpchgc
State: RUNNING
Nodes: 1
Cores per node: 40
CPU Utilized: 00:00:00
CPU Efficiency: 0.00% of 02:22:40 core-walltime
Job Wall-clock time: 00:03:34
Memory Utilized: 0.00 MB (estimated maximum)
Memory Efficiency: 0.00% of 160.00 GB (4.00 GB/core)              //(4.00 GB/core)
WARNING: Efficiency statistics may be misleading for RUNNING jobs.

当提交作业后，使用 squeue 命令查看作业使用的节点

[hpc@login2 test]$ squeue
             JOBID PARTITION     NAME     USER ST       TIME  NODES NODELIST(REASON)
           9709875       cpu  40cores      hpc  R       0:02      1 cas478

然后进入相关节点

ssh cas478

可根据用户名查看作业占用的存储空间

ps -u$USER -o %cpu,rss,args

示例如下： ps -uhpc -o %cpu,rss,args

%CPU    RSS COMMAND
98.5 633512 pw.x -i ausurf.in
98.5 652828 pw.x -i ausurf.in
98.6 654312 pw.x -i ausurf.in
98.6 652196 pw.x -i ausurf.in

RSS 表示单核所占用的存储空间，单位为KB，上述分析可得单核上运行作业占用的存储空间大约为650MB,40核的内存利用率大约为： (0.65G*40)/160G: 16%。

如果需要动态监测存储资源的使用，可进入计算节点后，输入top命令

PID USER      PR  NI    VIRT    RES    SHR S  %CPU %MEM     TIME+ COMMAND
428410 hpc       20   0 5989.9m 662.5m 168.6m R 100.0  0.3   0:22.67 pw.x
428419 hpc       20   0 5987.0m 658.9m 163.7m R 100.0  0.3   0:22.61 pw.x
428421 hpc       20   0 5984.6m 677.8m 180.1m R 100.0  0.4   0:22.66 pw.x
428433 hpc       20   0 6002.8m 661.7m 165.3m R 100.0  0.3   0:22.68 pw.x
428436 hpc       20   0 5986.0m 659.0m 165.4m R 100.0  0.3   0:22.66 pw.x

上述数据中的RES列数据表示运行作业所占用的存储资源，单核大约占用650m。

使用 seff jobid 命令

[hpc@login2 data]$ seff 9709905
Job ID: 9709905
Cluster: sjtupi
User/Group: hpchgc/hpchgc
State: COMPLETED (exit code 0)
Nodes: 1
Cores per node: 40
CPU Utilized: 06:27:20
CPU Efficiency: 99.15% of 06:30:40 core-walltime
Job Wall-clock time: 00:09:46
Memory Utilized: 23.33 GB
Memory Efficiency: 14.58% of 160.00 GB

下面介绍如何通过JOB ID获取GPU信息以及如何获取CUDA_VISIBLE_DEVICES变量并在程序中利用该变量

NVIDIA显卡的UUID（Universally Unique Identifier，通用唯一标识符）和BUS ID（总线标识符）是两个重要的标识符。

UUID（Universally Unique Identifier）：UUID是一个128位的唯一标识符，用于在系统中识别每个独立的NVIDIA显卡设备。每个显卡设备都有一个唯一的UUID，可以通过调用相关命令或API来获取它。UUID在不同系统和环境中是持久的，即使重新启动系统或重新插拔显卡，UUID也不会改变。

BUS ID（总线标识符）：BUS ID是用于标识系统中不同物理或逻辑总线上的NVIDIA显卡设备的标识符。BUS ID提供了关于显卡设备如何连接到系统总线的信息，如PCI总线等。BUS ID通常采用“domain🚌device.function”的形式表示，其中domain表示域，bus表示总线编号，device表示设备编号，function表示设备的功能编号。BUS ID主要用于管理和配置显卡设备，以及确定显卡在系统中的位置。

下面介绍如何通过jobid查询UUID及BUSID信息：

将下面脚本保存至getGPUInfo的文本中

#!/bin/bash
JOBID=$1
GPUNUMS=`scontrol show jobs ${JOBID}|grep "gres:gpu" |awk -F ':' '{print $3}'`
GPUHOST=`scontrol show jobs ${JOBID}|grep "NodeList="|sed -n '2p'|awk -F '=' '{print $2}'`
echo JobID: ${JOBID}
echo NodeHost: ${GPUHOST}
echo GPUNums: ${GPUNUMS}
echo Information of allocate GPUs:
ssh ${GPUHOST} "echo UUID: && nvidia-smi -L"
ssh ${GPUHOST} "echo BUS_ID: && nvidia-smi -q|grep 'Bus Id'|sed -e 's/^.*: //' -e 's/ $//'"

针对正在运行的作业，执行脚本加作业ID可获取正在运行作业的节点中的GPU信息

$ chmod +x getGPUInfo
$ ./getGPUInfo 27180318
JobID: 27180318
NodeHost: gpu09
GPUNums: 4
Information of allocate GPUs:
UUID:
GPU 0: NVIDIA A100-SXM4-40GB (UUID: GPU-5cd88acf-5391-8562-cd34-b543319224b4)
GPU 1: NVIDIA A100-SXM4-40GB (UUID: GPU-7bc1435d-37b5-d4b8-6ac1-df72927a54e0)
GPU 2: NVIDIA A100-SXM4-40GB (UUID: GPU-4dedf87e-d147-83cc-c5bd-ec16324afa15)
GPU 3: NVIDIA A100-SXM4-40GB (UUID: GPU-2bf8c199-1e4a-31cd-470b-4ba6329d9a60)
BUS_ID:
00000000:31:00.0
00000000:4B:00.0
00000000:CA:00.0
00000000:E3:00.0

CUDA_VISIBLE_DEVICES是一个环境变量，用于在使用CUDA编程时指定可见的GPU设备。它可以用来控制程序所使用的GPU设备的数量和顺序。

当用户申请有GPU卡的任务时，slurm系统会根据用户申请的GPU数量来设置CUDA_VISIBLE_DEVICES环境变量，只有相应编号的GPU设备会对程序可见，其他GPU设备则不可使用。

在srun申请交互式作业后，可在shell中直接输出$CUDA_VISIBLE_DEVICES变量

$  srun -n 8 -p dgx2 --gres=gpu:2 --pty /bin/bash
srun: job 27182411 queued and waiting for resources
srun: job 27182411 has been allocated resources
$ echo $CUDA_VISIBLE_DEVICES
0,1

也可以在作业脚本最前面输出$CUDA_VISIBLE_DEVICES变量

#!/bin/bash
#SBATCH -J test
#SBATCH -n 8
#SBATCH --gres=gpu:2
#SBATCH -p dgx2

echo $CUDA_VISIBLE_DEVICES
···

以下是一个简单的torch程序，展示了根据$CUDA_VISIBLE_DEVICES变量，设置程序使用的GPU

$ cat pytorch_test.py
import torch
from torch import nn
from torch.optim import Adam
from torch.nn.parallel import DataParallel
import os
class DEMO_model(nn.Module):
        def __init__(self, in_size, out_size):
                super().__init__()
                self.fc = nn.Linear(in_size, out_size)
        def forward(self, inp):
                outp = self.fc(inp)
                print(inp.shape, outp.device)
                return outp
model = DEMO_model(10, 5).to('cuda')

os.system("echo CUDA_VISIBLE_DEVICES: $CUDA_VISIBLE_DEVICES")
device_ids = os.environ.get('CUDA_VISIBLE_DEVICES')
device_ids = device_ids.split(',')
device_ids = [int(number) for number in device_ids]
model = DataParallel(model, device_ids=device_ids)
adam = Adam(model.parameters())
# 进行训练
for i in range(1):
        x = torch.rand([128, 10])
        y = model(x)
        loss = torch.norm(y)
        loss.backward()
        adam.step()

执行程序，需要加载torch环境

$ srun -n 8 -p dgx2 --gres=gpu:2 -w vol08 --pty /bin/bash
$ module load miniconda3
$ source activate
(base) $ conda activate pytorch-env
(pytorch-env) $ python pytorch_test.py
CUDA_VISIBLE_DEVICES: 0,1
torch.Size([64, 10]) cuda:0
torch.Size([64, 10]) cuda:1

其他队列的使用指南，参考：

https://docs.hpc.sjtu.edu.cn/app/module.html

集群软件以 module 形式供全局调用。常见的 module 命令如下

module load [MODULE]: 加载模块

module avail 或 module av : 列出所有模块

module av intel: 列出含有 intel 名字的所有模块

module list: 列出所有已加载的模块

module show [MODULE]: 列出该模块的信息，如路径、环境变量等

也可以一次加载或卸载多个模块。

$ module load gcc openmpi
$ module unload gcc openmpi

如果您喜欢最新的稳定版本，则可以忽略版本号（默认加载带有 D 标识的版本）。

下方两句命令效果一致：

$ module load gcc openmpi
$ module load gcc/9.3.0-gcc-4.8.5 openmpi/4.0.5-gcc-9.2.0

----------------------------------------------------- /lustre/share/spack/modules/cascadelake/linux-centos7-x86_64 -----------------------------------------------------
abinit/8.10.3-gcc-9.2.0-openblas-openmpi        hdf5/1.10.6-gcc-9.2.0-openmpi                            netcdf-fortran/4.5.2-intel-19.0.4-impi   (D)
alphafold/2-python-3.8                          hdf5/1.10.6-gcc-9.2.0                                    netlib-lapack/3.8.0-intel-19.0.4         (D)
bcftools/1.9-gcc-9.2.0                   (D)    hdf5/1.10.6-intel-19.0.4-impi                            nwchem/6.8.1-intel-19.0.4-impi
bedtools2/2.27.1-intel-19.0.4            (D)    hdf5/1.10.6-intel-19.0.5-impi                            openblas/0.3.7-gcc-9.2.0                 (D)
bismark/0.19.0-intel-19.0.4                     hdf5/1.10.6-intel-19.0.5-openmpi                  (D)    openjdk/1.8.0_222-b10-gcc-9.2.0
boost/1.70.0-gcc-9.2.0                          hisat2/2.1.0-intel-19.0.4                         (D)    openjdk/11.0.2-gcc-9.2.0
boost/1.70.0-intel-19.0.4                       hypre/2.20.0-gcc-9.2.0-openblas-openmpi           (D)    openjdk/11.0.2-intel-19.0.4              (D)
boost/1.70.0-intel-19.0.5                (D)    intel-mkl/2019.3.199-intel-19.0.4                        openmpi/3.1.5-gcc-9.2.0
bowtie/1.2.3-gcc-9.2.0                   (D)    intel-mkl/2019.5.281-intel-19.0.5                        openmpi/3.1.5-gcc-9.3.0
bowtie2/2.3.5.1-intel-19.0.4                    intel-mkl/2020.1.217-intel-19.1.1                 (D)    openmpi/3.1.5-intel-19.0.5
bwa/0.7.17-gcc-9.2.0                            intel-mpi/2019.4.243-intel-19.0.4                        openmpi/4.0.5-gcc-9.2.0                  (D)
bwa/0.7.17-intel-19.0.4                  (D)    intel-mpi/2019.6.154-gcc-9.2.0                           perl/5.30.0-gcc-9.2.0
cdo/1.9.8-gcc-9.2.0                             intel-mpi/2019.6.154-intel-19.0.5                 (D)    perl/5.30.0-gcc-9.3.0
cp2k/8.2-gcc-9.2.0-openblas              (D)    intel-parallel-studio/cluster.2019.4-intel-19.0.4        perl/5.30.0-intel-19.0.4
cuda/9.0.176-intel-19.0.4                       intel-parallel-studio/cluster.2019.5-intel-19.0.5        perl/5.30.0-intel-19.0.5
cuda/10.1.243-gcc-9.2.0                         intel-parallel-studio/cluster.2020.1-intel-19.1.1 (D)    perl/5.30.0-intel-19.1.1                 (D)
cuda/10.2.89-intel-19.0.4                (D)    jasper/2.0.16-gcc-9.2.0                                  picard/2.19.0-gcc-9.2.0
cufflinks/2.2.1-gcc-9.2.0                       jdk/12.0.2_10-gcc-9.2.0                                  picard/2.19.0-intel-19.0.4               (D)
cufflinks/2.2.1-intel-19.0.4             (D)    jdk/12.0.2_10-intel-19.0.4                        (D)    python/2.7.16-intel-19.0.4
eigen/3.3.7-gcc-9.2.0                    (D)    json-fortran/7.1.0-gcc-9.2.0                             python/2.7.16-intel-19.1.1
fastqc/0.11.7-gcc-9.2.0                         lammps/20200721-intel-19.0.5-openmpi                     python/3.7.4-gcc-9.2.0
fastqc/0.11.7-intel-19.0.4               (D)    lammps/20210310-intel-19.0.5-openmpi                     python/3.7.4-intel-19.0.4
fftw/3.3.8-gcc-9.2.0-openmpi                    lammps/20210702-intel-19.0.5-impi                        python/3.7.4-intel-19.0.5
fftw/3.3.8-gcc-9.2.0                            libxc/4.3.2-gcc-9.2.0                                    quantum-espresso/6.4.1-intel-19.0.4-impi
fftw/3.3.8-gcc-9.3.0-openmpi                    libxc/4.3.2-intel-19.0.4                          (D)    quantum-espresso/6.4.1-intel-19.0.5-impi
fftw/3.3.8-intel-19.0.4-impi                    lumpy-sv/0.2.13-gcc-9.2.0                                quantum-espresso/6.5-intel-19.0.4-impi
fftw/3.3.8-intel-19.0.5-impi                    mcl/14-137-gcc-9.2.0                                     quantum-espresso/6.5-intel-19.0.5-impi
fftw/3.3.8-intel-19.0.5-openmpi                 megahit/1.1.4-intel-19.0.4                        (D)    rna-seqc/1.1.8-gcc-9.2.0
fftw/3.3.8-intel-19.1.1-impi                    metis/5.1.0-gcc-9.2.0                             (D)    rna-seqc/1.1.8-intel-19.0.4              (D)
fftw/3.3.9-gcc-9.2.0-openmpi                    mpich/3.3.2-gcc-9.2.0                                    rosettafold/1-python-3.8
fftw/3.3.9-gcc-9.3.0                     (D)    mpich/3.3.2-intel-19.0.4                                 samtools/1.9-gcc-9.2.0
flash/1.2.11-gcc-9.2.0                   (D)    mpich/3.3.2-intel-19.0.5                          (D)    samtools/1.9-intel-19.0.4                (D)
fsl/6.0-fsl-gcc-4.8.5                           mvapich2/2.3.2-intel-19.0.5                       (D)    siesta/4.0.1-intel-19.0.4-impi
gatk/3.8-1-gcc-9.2.0                     (D)    namd/2.14-gcc-9.2.0-openmpi                              stream/5.10-intel-19.0.4
gromacs/2019.2-gcc-9.2.0-openmpi                nano/4.7-gcc-4.8.5                                       stream/5.10-intel-19.0.5                 (D)
gromacs/2019.4-gcc-9.2.0-openmpi                nektar/5.0.0-intel-19.0.4-impi                           sumo/1.10.0-sumo
gromacs/2020.2-gcc-9.2.0-openmpi                netcdf-c/4.7.3-gcc-9.2.0-openmpi                         sundials/3.1.2-gcc-9.2.0
gromacs/2021-gcc-9.3.0-openmpi                  netcdf-c/4.7.3-gcc-9.2.0                                 svaba/1.1.3-gcc-4.8.5
gsl/2.5-gcc-9.2.0                               netcdf-c/4.7.3-intel-19.0.4-impi                         tophat/2.1.2-intel-19.0.4
gsl/2.5-intel-19.0.4                            netcdf-c/4.7.3-intel-19.0.5-impi                         vsearch/2.4.3-intel-19.0.4               (D)
gsl/2.5-intel-19.0.5                     (D)    netcdf-c/4.7.3-intel-19.0.5-openmpi               (D)    wrf/4.2-gcc-9.2.0-openmpi
hdf5/1.10.5-intel-19.0.4-impi                   netcdf-fortran/4.5.2-gcc-9.2.0-openmpi

在SLURM上，我们应用了以下规则来选取最合适的模块。

1. 编译器：如果加载了gcc或icc，请根据相应的编译器加载已编译的模块。或在必要时加载默认的编译器gcc。
2. MPI库：如果已加载其中一个库（openmpi，impi，mvapich2，mpich），加载针对相应MPI编译的模块。在必要的时候,默认MPI lib中的openmpi将被装载。
3. Module版本：每个模块均有默认版本，如果未指定版本号，则将加载该默认版本。

• Lmod: A New Environment Module System https://lmod.readthedocs.io/en/latest/
• Environment Modules Project http://modules.sourceforge.net/
• Modules Software Environment on NERSC https://www.nersc.gov/users/software/nersc-user-environment/modules/

我么主要关注的就是其中的https://docs.hpc.sjtu.edu.cn/app/bioinformatics/index.html（生信软件）

A： 计算节点是通过proxy节点代理进行网络访问的，因此一些软件需要特定的代理设置。需要找到软件的配置文件，修改软件的代理设置。

1. git、wget、curl等软件支持通用变量，代理参数设置为：

# 思源一号计算节点通用代理设置
https_proxy=http://proxy2.pi.sjtu.edu.cn:3128
http_proxy=http://proxy2.pi.sjtu.edu.cn:3128
no_proxy=puppet,proxy,172.16.0.133,pi.sjtu.edu.cn

 # π2.0计算节点通用代理设置
http_proxy=http://proxy.pi.sjtu.edu.cn:3004/
https_proxy=http://proxy.pi.sjtu.edu.cn:3004/
no_proxy=puppet

1. Python、MATLAB、Rstudio、fasterq-dump等软件需要查询软件官网确定配置参数：

### fasterq-dump文件，配置文件路径 ~/.ncbi/user-settings.mkfg

# 思源一号节点代理设置
/tools/prefetch/download_to_cache = "true"
/http/proxy/enabled = "true"
/http/proxy/path = "http:/proxy2.pi.sjtu.edu.cn:3128"

# π2.0节点代理设置
/tools/prefetch/download_to_cache = "true"
/http/proxy/enabled = "true"
/http/proxy/path = "http://proxy.pi.sjtu.edu.cn:3004"

### Python需要在代码里面指定代理设置，不同Python包代理参数可能不同

# 思源一号节点代理设置
proxies = {
    'http': 'http://proxy2.pi.sjtu.edu.cn:3128',
    'https': 'http://proxy2.pi.sjtu.edu.cn:3128',
}
# π2.0节点代理设置
proxies = {
    'http': 'http://proxy.pi.sjtu.edu.cn:3004',
    'https': 'http://proxy.pi.sjtu.edu.cn:3004',
}

### MATLAB

# 思源一号节点代理设置
proxy2.pi.sjtu.edu.cn:3128

# π2.0节点代理设置
proxy.hpc.sjtu.edu.cn:3004

A： 用户家目录下的 ~/.bashrc 和 ~/.bash_profile 记录bash shell配置，若配置不当可能会导致无法找到可执行文件、无法在Studio中启动RSession等问题，需要重置这两个配置文件的内容。

重置 ~/.bashrc 操作流程如下，首先登录集群，然后备份现有配置文件，再调用 vim 或其他文本编辑器打开文件：

$ /bin/cp ~/.bashrc ~/.bashrc.bak
$ /bin/vim ~/.bashrc

将 ~/.bashrc 文件内容重置如下，保存后退出编辑器：

# .bashrc

# Source global definitions
if [ -f /etc/bashrc ]; then
        . /etc/bashrc
fi

类似地，在命令行中使用 /bin/cp ~/.bash_profile ~/.bash_profile.bak; /bin/vim ~/.bash_profile 将文件内容重置如下：

# .bash_profile

# Get the aliases and functions
if [ -f ~/.bashrc ]; then
        . ~/.bashrc
fi

# User specific environment and startup programs

PATH=$PATH:$HOME/.local/bin:$HOME/bin

export PATH

最后重新登录集群，确认重置配置文件后，先前的问题是否解决。 重置配置文件会导致您先前对bash shell的自定义配置失效，如果您仍需要保留这些自定义配置，建议您从bak备份文件中逐条转移这些配置，避免引入导致应用异常语句。