提交作业

提交作业的命令主要有salloc、sbatch与srun，其多数参数、输入输出变量等都是 一样的。

1. 主要参数

2. 交互式提交并行作业：srun

srun可以交互式提交运行并行作业，提交后，作业等待运行，等运行完毕后，才返 回终端。语法为：

srun \[OPTIONS...\] executable \[args...\]

常见例子

示例一：使用8个CPU核(­n8)运行作业，并在标准输出上显示任务号(­l)：

srun -p pocg ­-n8 -­l hostname

输出结果：

0:node0
1:node0
2:node1
3:node1
4:node2
5:node2
6:node3
7:node3

示例二：在脚本中使用-­r2参数使其在第2号（分配的节点号从0开始）开始的两个节点上运行，并采用实时分配模式而不是批处理模式运行：

脚本test.sh内容：

 \#!/bin/sh
 echo $SLURM\_NODELIST
 srun -lN2 -r2 hostname
 srun -lN2 hostname

运行：

salloc -p pocg ­-N4 test.sh

输出结果：

 dev\[7-10\]
 0: node9
 1: node10
 0: node7
 1: node8

示例三：在分配的节点上并行运行两个作业步：

脚本test.sh内容：

\#!/bin/bash
srun -lN2 -n4 -r 2 sleep 60 &
srun -lN2 -r 0 sleep 60 &
sleep 1 squeue
squeue -s
wait

运行：

salloc -p pocg -­N4 test.sh

输出结果：

JOBID PARTITION NAME USER ST TIME NODES NODELIST65641 batch test.sh grondo R 0:01 4 dev\[7-10\]
STEPID PARTITION USER TIME NODELIST
65641.0 batch grondo 0:01 dev\[7-8\]
65641.1 batch grondo 0:01 dev\[9-10\]

示例四：运行MPICH作业：

脚本test.sh内容：

\#!/bin/sh
MACHINEFILE="nodes.$SLURM_JOB_ID"
\#生成MPICH所需的包含节点名的machinfile文件
srun -l /bin/hostname \| sort -n \| awk ’{print $2}’ > $MACHINEFILE
\#运行MPICH作业
mpirun -np $SLURM\_NTASKS -machinefile $MACHINEFILE mpi-app
rm $MACHINEFILE

采用2个节点（­-N2）共4个CPU核（-­n4）运行：

salloc ­-p pocg -N2 ­-n4 test.sh

示例五：利用不同节点号（SLURM_NODEID）运行不同作业，节点号从0开始：

脚本test.sh内容：

case $SLURM\_NODEID in 
    0) echo "I am running on " 
        hostname ;; 
    1) hostname 
    echo "is where I am running" ;;
esac

运行：

srun -p pocg ­-N2 test.sh

输出结果：

dev0
is where I am running
I am running on
ev1

示例六： 利用多核选项控制任务执行：

采用2个节点（­N2），每节点4颗CPU每颗CPU 2颗CPU核（­B 4­4:2­2），运行作业：

srun ­-p pocg -N2 ­-B 4­-4:2-­2 a.out

示例七：运行GPU作业：

脚本gpu.script内容：

#!/bin/bash
srun -n1 -p GPU-V100 -{}-gres=gpu:v100:2 prog1 &
wait

-­p GPU­V-100指定采用GPU队列GPU-­V100，--­­gres=gpu:v100:2指明每个节点使用2块NVIDIA V100 GPU卡。

示例八：排它性独占运行作业：

脚本my.script内容：

\#!/bin/bash
srun -{}-exclusive -n4 prog1 &
srun -{}-exclusive -n3 prog2 &
srun -{}-exclusive -n1 prog3 &
srun -{}-exclusive -n1 prog4 &
wait

3. 批处理方式提交作业：sbatch

Slurm支持利用sbatch命令采用批处理方式运行作业，sbatch命令在脚本正确传递给作业调度系统后立即退出，同时获取到一个作业号。作业等所需资源满足后开始运行。

sbatch提交一个批处理作业脚本到Slurm。批处理脚本名可以在命令行上通过传递0给sbatch，如没有指定文件名，则sbatch从标准输入中获取脚本内容。

脚本文件基本格式：

• 第一行以#!/bin/sh等指定该脚本的解释程序，/bin/sh可以变为/bin/bash、/bin/csh等。

• 在可执行命令之前的每行“#SBATCH”前缀后跟的参数作为作业调度系统参数。在任何非注释及空白之后的“#SBATCH”将不再作为Slurm参数处理。

默认，标准输出和标准出错都定向到同一个文件slurm­%j.out，“%j”将被作业号代替。

脚本myscript内容：

#!/bin/sh
#SBATCH -{}-time=1
#SBATCH -p pocgt
srun hostname |sort

采用4个节点（­N4）运行：

sbatch ­-p pocg -­N4 myscript

在这里，虽然脚本中利用“#SBATCH ­-p pocgt”指定了使用pocgt队列，但命令行中的-­p pocg优先级更高，因此实际提交到pocg队列。

提交成功后有类似输出：

salloc: Granted job allocation 65537

其中65537为分配的作业号。

程序结束后的作业日志文件slurm­65537.out显示：

node1
node2
node3
node4

常见例子

示例一：串行作业提交

对于串行程序，用户可类似下面两者之一：

1、直接采用sbatch -­n1 -­o job­%j.log -­e job­-%.err yourprog方式运行。

2、编写命名为pocg_job.sh（此脚本名可以按照用户喜好命名）的串行作业脚本，其 内容如下：

#!/bin/sh
#An example for serial job.
#SBATCH -J job\_name\#SBATCH -o job-%j.log
#SBATCH -e job-%j.errecho Running on hosts
echo Time is \`date\`
echo Directory is $PWD
echo This job runs on the following nodes:
echo $SLURM\_JOB\_NODELIST
module load intel/2019.update5
echo This job has allocated 1 cpu core.
./yourprog

必要时需在脚本文件中利用module命令设置所需的环境，如上面的module load intel/2019.update5

作业脚本编写完成后，可以按照下面命令提交作业：

hmli@login01:~/work$ sbatch ­-n1 -­p pocg pocg\_job.sh

示例二：OpenMP共享内存并行作业提交

对于OpenMP共享内存并行程序，可编写命名为omp_job.sh的作业脚本，内容如下：

#!/bin/sh
#An example for serial job.
#SBATCH -J job\_name
#SBATCH -o job-%j.log
#SBATCH -e job-%j.err
#SBATCH -­p pocg -N 1 -n 8
echo Running on hosts
echo Time is \`date\`
echo Directory is $PWD
echo This job runs on the following nodes:
echo $SLURM\_JOB\_NODELIST
module load intel/2016.3.210
echo This job has allocated 1 cpu core.
export OMP\_NUM\_THREADS=8
./yourprog

相对于串行作业脚本，主要增加export OMP_NUM_THREADS=8和#SBATCH -N 1 -n 8，表示使用一个节点内部的八个核，从而保证是在同一个节点内部， 需几个核就设置-­n为几。­-n后跟的不能超过单节点内CPU核数。

作业脚本编写完成后，可以按照下面命令提交作业：

hmli@login01:~/work$ sbatch omp\_job.sh

示例二：MPI并行作业提交

与串行作业类似，对于MPI并行作业，则需编写类似下面脚本mpi_job.sh：

#!/bin/sh
#An example for MPI job.
#SBATCH -J job\_name
#SBATCH -o job-%j.log
#SBATCH -e job-%j.err
#SBATCH -p pocg -N 1 -n 8echo Time is \`date\`
echo Directory is $PWD
echo This job runs on the following nodes:
echo $SLURM\_JOB\_NODELIST
echo This job has allocated $SLURM\_JOB\_CPUS\_PER\_NODE cpu cores.
module load intelmpi/5.1.3.210
#module load mpich/3.2/intel/2016.3.210
#module load openmpi/2.0.0/intel/2016.3.210
MPIRUN=mpirun \#Intel mpi and Open MPI
#MPIRUN=mpiexec \#MPICH
MPIOPT="-env I\_MPI\_FABRICS shm:ofa" \#Intel MPI 2018
#MPIOPT="-env I\_MPI\_FABRICS shm:ofi" \#Intel MPI 2019
#MPIOPT="-{}-mca plm\_rsh\_agent ssh -{}-mca btl self,openib,sm" \#Open MPI
#MPIOPT="-iface ib0" \#MPICH3
#目前新版的MPI可以自己找寻高速网络配置，可以设置MPIOPT为空，如去掉下行的
# MPIOPT=
$MPIRUN $MPIOPT ./yourprog

与串行程序的脚本相比，主要不同之处在于需采用mpirun或mpiexec的命令格式提 交并行可执行程序。采用不同MPI提交时，需要打开上述对应的选项。

与串行作业类似，可使用下面方式提交：

hmli@login01:~/work$ sbatch mpi\_job.sh

示例三：GPU作业提交

运行GPU作业，需要提交时利用­­gres=gpu等指明需要的GPU资源并用­p指明采用的GPU队列。

脚本gpu_job.sh内容：

#!/bin/sh
#An example for gpu job.
#SBATCH -J job\_name
#SBATCH -o job-%j.log
#SBATCH -e job-%j.err
#SBATCH -N 1 -n 8 -p GPU-V100 -{}-gres=gpu:v100:2./your-gpu-prog
wait

上面­p GPU-­V100 指定采用GPU队列GPU­-V100，--­­gres=gpu:v100:2指明每个节点使用2块NVIDIA V100 GPU卡。

示例四：作业获取的节点名及对应CPU核数解析

作业调度系统主要负责分配节点及该节点分配的CPU核数等， 在Slurm作业脚本中利用环境变量可以获取分配到的节点名(SLURM_JOB_NODELIST及对应核数(SLURM_JOB_CPUS_PER_NODE)或对应的任务数(SLURM_TASKS_PER_NODE)，然后根据自己程序原始的命令在Slurm脚本中进行修改就成。

SLURM_JOB_NODELIST及SLURM_TASKS_PER_NODE有一定的格式，以下为一个参考解析脚本，可以在自己的Slurm脚本中参考获取自己的节点等信息。

#!/bin/bash
#Auther HM\_Li
#SLURM\_JOB\_NODELIST=cnode\[001-003,005,440-441\]
BASENAME=${SLURM\_JOB\_NODELIST%\[\*}
LIST=${SLURM\_JOB\_NODELIST\#\*\[}
LIST=${LIST%\]}
IDLIST=''
for i in \`echo $LIST \| tr ',' ' '\`
do 
   if \[\[ $i =~ '-' \]\]; then 
       IDLIST=$IDLIST' '\`seq -w \`echo $i\| tr '-' ' '\`\` 
   else
       IDLIST=$IDLIST' '$i 
   fi
done
NODELIST=''
for i in $IDLIST
do
   NODELIST=$NODELIST" $BASENAME"$i
done
echo -e "Node list: \n\t"$NODELIST

#SLURM\_TASKS\_PER\_NODE='40\(x3\),23,20\(x2\)' 
#SLURM\_JOB\_CPUS\_PER\_NODE='40\(x3\),23,20\(x2\)'
CORELIST=''
for i in \`echo $SLURM\_JOB\_CUPS\_PER\_NODE\| tr ',' ' '\`
do
   if \[\[ $i =~ 'x' \]\]; then
       read CORES NODES <<<\`echo $i\| tr '\(x\)' ' '\` 
       for n in \`seq 1 $NODES\` 
       do 
           CORELIST=$CORELIST' '$CORES 
       done 
   else 
       CORELIST=$CORELIST' '$i 
   fi
done
echo -e "\nCPU Core list: \n\t$CORELIST"

echo -e "\nNode list with corresponding CPU Cores: "
CARR=\(${CORELIST}\)
i=0
for n in $NODELIST
do
    echo -e "\t"$n: ${CARR\[$i\]}
    i=$\(\($i+1\)\)
done

上面只是例子，要加在自己的Slurm脚本中，而不是先提交上面这个脚本获取节点名后放到slurm脚本中，其原因在于除非提交时指定节点名，否则每次提交后获取的节点名等是有可能变的。比如针对star­-cmm+软件，原来的方式是：

/STATCMM+PATH/bin/starccm+ ­-rsh ssh ­-batch ­-power -­on cnode400:40,cnode432:40 FireAndSmokeResampled.sim >residual.log

则可以改为下面脚本：

#!/bin/sh
#An example for MPI job.
#SBATCH -J job\_name
#SBATCH -o job-%j.log
#SBATCH -e job-%j.err
echo This job runs on the following nodes:
echo $SLURM\_JOB\_NODELIST
echo This job has allocated $SLURM\_JOB\_CPUS\_PER\_NODE cpu cores.

BASENAME=${SLURM\_JOB\_NODELIST%\[\*}
LIST=${SLURM\_JOB\_NODELIST\#\*\[}
LIST=${LIST%\]}
IDLIST=''
for i in \`echo $LIST \| tr ',' ' '\`
do 
    if \[\[ $i =~ '-' \]\]; then
        T=\`echo $i\| tr '-' ' '\` 
        IDLIST=$IDLIST' '\`seq -w $T\` 
    else 
        IDLIST=$IDLIST' '$i 
    fi
done
NODEOPT=''
for i in $IDLIST
do 
    NODEOPT=$NODEOPT,$BASENAME$i:40
done
NODEOPT=${NODEOPT:1} \#trim the first ,

/STARCMM+PATH/bin/starccm+ -rsh ssh -batch -power -on $NODEOPT  FireAndSmokeResampled.sim > residual.log

4. 分配式提交作业：salloc

salloc将获取作业的分配后执行命令，当命令结束后释放分配的资源。其基本语法为：

salloc \[options\] \[<command> \[command args\]\]

command可以是任何是用户想要用的程序，典型的为xterm或包含srun命令的shell。 如果后面没有跟命令，那么将执行Slurm系统slurm.conf配置文件中通过SallocDefaultCommand 设定的命令。如果SallocDefaultCommand没有设定，那么将执行用户的默认shell。 注意：salloc逻辑上包括支持保存和存储终端行设置，并且设计为采用前台方式执行。如果需要后台执行salloc，可以设定标准输入为某个文件，如：salloc -­n16 a.out </dev/null &。

常见例子

示例一：获取分配，并打开csh，以便srun可以交互式输入：

salloc ­-p pocg -N16 csh

将输出：

salloc: Granted job allocation 65537
(在此，将等待用户输入，csh退出后结束）
salloc: Relinquishing job allocation 65537

示例二：获取分配并并行运行应用：

salloc -p pocg ­-N5 srun ­-n10 myprogram

示例三：生成三个不同组件的异构作业，每个都是独立节点：

salloc ­-p pocg w node\[2­3\] : ­w node4 : ­w node\[5­7\] bash

将输出：

salloc: job 32294 queued and waiting for resources
salloc: job 32294 has been allocated resources
salloc: Granted job allocation 32294