节点状态查看

1. 用sinfo可以查看现有的节点、分区、可用状态、作业时间限制、节点数量

root@ceph01:~# sinfo
PARTITION AVAIL  TIMELIMIT  NODES  STATE NODELIST
cpu          up   infinite      3   idle ceph[01-03]
gpu          up   infinite      3   idle ceph[01-03]
memory       up   infinite      3   idle ceph[01-03]
关键词含义
PARTITION分区名，大型集群为了方便管理，会将节点划分为不同的分区设置不同权限
AVAIL可用状态：up 可用；down 不可用
TIMELIMIT该分区的作业的最大运行时长限制，30:00 表示30分钟，如果是2-00:00:00表示2天，如果是infinite表示不限时间
NODES节点数量
STATE状态：drain: 排空状态，表示该类结点不再分配到其他；idle: 空闲状态；alloc: 被分配状态；mix: 部分被占用，但是仍有可用资源
NODELIST分区中的节点列表。ceph[01-03] 表示 ceph01, ceph02, ceph03 这三个节点

2. 查看分区的状态信息

2.1 查看全部分区状态信息

root@ceph01:~# scontrol show partition
PartitionName=cpu
   AllowGroups=ALL AllowAccounts=ALL AllowQos=ALL
   AllocNodes=ALL Default=NO QoS=N/A
   DefaultTime=NONE DisableRootJobs=NO ExclusiveUser=NO GraceTime=0 Hidden=NO
   MaxNodes=UNLIMITED MaxTime=UNLIMITED MinNodes=0 LLN=NO MaxCPUsPerNode=UNLIMITED
   Nodes=ceph[01-03]
   PriorityJobFactor=1 PriorityTier=1 RootOnly=NO ReqResv=NO OverSubscribe=NO
   OverTimeLimit=NONE PreemptMode=OFF
   State=UP TotalCPUs=24 TotalNodes=3 SelectTypeParameters=NONE
   JobDefaults=(null)
   DefMemPerNode=UNLIMITED MaxMemPerNode=UNLIMITED

PartitionName=gpu
   AllowGroups=ALL AllowAccounts=ALL AllowQos=ALL
   AllocNodes=ALL Default=NO QoS=N/A
   DefaultTime=NONE DisableRootJobs=NO ExclusiveUser=NO GraceTime=0 Hidden=NO
   MaxNodes=UNLIMITED MaxTime=UNLIMITED MinNodes=0 LLN=NO MaxCPUsPerNode=UNLIMITED
   Nodes=ceph[01-03]
   PriorityJobFactor=1 PriorityTier=1 RootOnly=NO ReqResv=NO OverSubscribe=NO
   OverTimeLimit=NONE PreemptMode=OFF
   State=UP TotalCPUs=24 TotalNodes=3 SelectTypeParameters=NONE
   JobDefaults=(null)
   DefMemPerNode=UNLIMITED MaxMemPerNode=UNLIMITED

PartitionName=memory
   AllowGroups=ALL AllowAccounts=ALL AllowQos=ALL
   AllocNodes=ALL Default=NO QoS=N/A
   DefaultTime=NONE DisableRootJobs=NO ExclusiveUser=NO GraceTime=0 Hidden=NO
   MaxNodes=UNLIMITED MaxTime=UNLIMITED MinNodes=0 LLN=NO MaxCPUsPerNode=UNLIMITED
   Nodes=ceph[01-03]
   PriorityJobFactor=1 PriorityTier=1 RootOnly=NO ReqResv=NO OverSubscribe=NO
   OverTimeLimit=NONE PreemptMode=OFF
   State=UP TotalCPUs=24 TotalNodes=3 SelectTypeParameters=NONE
   JobDefaults=(null)
   DefMemPerNode=UNLIMITED MaxMemPerNode=UNLIMITED

2.2 查看单个分区的状态信息

root@ceph01:~# scontrol show partition cpu
PartitionName=cpu
   AllowGroups=ALL AllowAccounts=ALL AllowQos=ALL
   AllocNodes=ALL Default=NO QoS=N/A
   DefaultTime=NONE DisableRootJobs=NO ExclusiveUser=NO GraceTime=0 Hidden=NO
   MaxNodes=UNLIMITED MaxTime=UNLIMITED MinNodes=0 LLN=NO MaxCPUsPerNode=UNLIMITED
   Nodes=ceph[01-03]
   PriorityJobFactor=1 PriorityTier=1 RootOnly=NO ReqResv=NO OverSubscribe=NO
   OverTimeLimit=NONE PreemptMode=OFF
   State=UP TotalCPUs=24 TotalNodes=3 SelectTypeParameters=NONE
   JobDefaults=(null)
   DefMemPerNode=UNLIMITED MaxMemPerNode=UNLIMITED

3. 查看节点的状态信息

3.1 查看全部节点状态信息

root@ceph01:~# scontrol show node
NodeName=ceph01 Arch=x86_64 CoresPerSocket=1 
   CPUAlloc=0 CPUTot=8 CPULoad=0.09
   AvailableFeatures=(null)
   ActiveFeatures=(null)
   Gres=(null)
   NodeAddr=ceph01 NodeHostName=ceph01 Version=19.05.5
   OS=Linux 5.4.0-182-generic #202-Ubuntu SMP Fri Apr 26 12:29:36 UTC 2024 
   RealMemory=15996 AllocMem=0 FreeMem=8953 Sockets=8 Boards=1
   State=IDLE ThreadsPerCore=1 TmpDisk=0 Weight=1 Owner=N/A MCS_label=N/A
   Partitions=cpu,gpu,memory 
   BootTime=2024-06-05T08:52:18 SlurmdStartTime=2024-06-07T09:25:25
   CfgTRES=cpu=8,mem=15996M,billing=8
   AllocTRES=
   CapWatts=n/a
   CurrentWatts=0 AveWatts=0
   ExtSensorsJoules=n/s ExtSensorsWatts=0 ExtSensorsTemp=n/s
   

NodeName=ceph02 Arch=x86_64 CoresPerSocket=1 
   CPUAlloc=0 CPUTot=8 CPULoad=0.08
   AvailableFeatures=(null)
   ActiveFeatures=(null)
   Gres=(null)
   NodeAddr=ceph02 NodeHostName=ceph02 Version=19.05.5
   OS=Linux 5.4.0-182-generic #202-Ubuntu SMP Fri Apr 26 12:29:36 UTC 2024 
   RealMemory=15996 AllocMem=0 FreeMem=9258 Sockets=8 Boards=1
   State=IDLE ThreadsPerCore=1 TmpDisk=0 Weight=1 Owner=N/A MCS_label=N/A
   Partitions=cpu,gpu,memory 
   BootTime=2024-06-05T08:50:50 SlurmdStartTime=2024-06-07T09:25:07
   CfgTRES=cpu=8,mem=15996M,billing=8
   AllocTRES=
   CapWatts=n/a
   CurrentWatts=0 AveWatts=0
   ExtSensorsJoules=n/s ExtSensorsWatts=0 ExtSensorsTemp=n/s
   

NodeName=ceph03 Arch=x86_64 CoresPerSocket=1 
   CPUAlloc=0 CPUTot=8 CPULoad=0.02
   AvailableFeatures=(null)
   ActiveFeatures=(null)
   Gres=(null)
   NodeAddr=ceph03 NodeHostName=ceph03 Version=19.05.5
   OS=Linux 5.4.0-176-generic #196-Ubuntu SMP Fri Mar 22 16:46:39 UTC 2024 
   RealMemory=15996 AllocMem=0 FreeMem=263 Sockets=8 Boards=1
   State=IDLE ThreadsPerCore=1 TmpDisk=0 Weight=1 Owner=N/A MCS_label=N/A
   Partitions=cpu,gpu,memory 
   BootTime=2024-04-09T17:59:54 SlurmdStartTime=2024-06-07T09:25:04
   CfgTRES=cpu=8,mem=15996M,billing=8
   AllocTRES=
   CapWatts=n/a
   CurrentWatts=0 AveWatts=0
   ExtSensorsJoules=n/s ExtSensorsWatts=0 ExtSensorsTemp=n/s

3.2 查看单个节点状态信息

root@ceph01:~# scontrol show node ceph01
NodeName=ceph01 Arch=x86_64 CoresPerSocket=1 
   CPUAlloc=0 CPUTot=8 CPULoad=0.05
   AvailableFeatures=(null)
   ActiveFeatures=(null)
   Gres=(null)
   NodeAddr=ceph01 NodeHostName=ceph01 Version=19.05.5
   OS=Linux 5.4.0-182-generic #202-Ubuntu SMP Fri Apr 26 12:29:36 UTC 2024 
   RealMemory=15996 AllocMem=0 FreeMem=8951 Sockets=8 Boards=1
   State=IDLE ThreadsPerCore=1 TmpDisk=0 Weight=1 Owner=N/A MCS_label=N/A
   Partitions=cpu,gpu,memory 
   BootTime=2024-06-05T08:52:18 SlurmdStartTime=2024-06-07T09:25:25
   CfgTRES=cpu=8,mem=15996M,billing=8
   AllocTRES=
   CapWatts=n/a
   CurrentWatts=0 AveWatts=0
   ExtSensorsJoules=n/s ExtSensorsWatts=0 ExtSensorsTemp=n/s

4. 查看指定显卡的信息

srun -p gpu --gres=gpu:volta:2 nvidia-smi

srun: Slurm 命令，用于提交和运行作业。
-p gpu: 指定分区为 gpu。这意味着作业将被分配到 gpu分区中的节点上运行。
--gres=gpu:volta:2: 请求资源，gres代表通用资源（generic resources），gpu:volta:2 具体表示请求两块名为 volta的 GPU。
以下是 --gres 的细分解释：
gpu: 资源类型是 GPU。
volta: GPU 的型号或类型，这里表示 Volta 架构的 GPU。
2: 请求两块 Volta GPU。
nvidia-smi: 要在节点上运行的命令。nvidia-smi 是 NVIDIA 提供的实用工具，用于管理和监控 GPU 状态。

追踪任务

1. 查看作业列表

squeue来查看当前username下面所有运行的项目：
语法格式：

squeue -u username

示例：

root@ceph01:~# squeue -u root
             JOBID PARTITION     NAME     USER ST       TIME  NODES NODELIST(REASON)

JOBID: 作业的唯一标识符。每个作业都有一个唯一的 ID。
PARTITION: 作业提交的分区名称。分区是集群中用于组织资源的逻辑分组。
NAME: 作业的名称。通常是提交作业时指定的作业名。
USER: 提交作业的用户名。在这里是 root 用户。
ST: 作业的状态。可能的状态包括：
PD (Pending): 作业正在等待资源分配。
R (Running): 作业正在运行。
CG (Completing): 作业正在完成。
CD (Completed): 作业已经完成。
F (Failed): 作业失败。
TO (Timeout): 作业超时。
CA (Canceled): 作业被取消。
NF (Node Failure): 节点故障。
PR (Preempted): 作业被抢占。
TIME: 作业已经运行的时间。格式为 days-hours:minutes:seconds。
NODES: 作业分配的节点数量。
NODELIST(REASON): 分配给作业的节点列表，或者如果作业处于待定状态，显示作业等待的原因。

如果作业处于待定状态（PD），NODELIST(REASON) 列会显示等待的原因。常见的原因包括：
Priority: 优先级较低，等待资源。
Resources: 等待资源分配。
Dependency: 依赖其他作业的完成。
QOSGrpCpuLimit: 超过了分配的 QOS (Quality of Service) CPU 限制。
JobHeldAdmin: 作业被管理员保持。
BeginTime：未到用户所指定的任务开始时间。
Dependency：该作业所依赖的作业尚未完成。
InvalidAccount：用户的 Slurm 账号无效。
InvalidQOS：用户指定的 QoS 无效。
ParitionTimeLimit：用户申请的时间超过该分区时间上限。
QOSMaxCpuPerUserLimit： 超过当前 QoS 用户最大 CPU 限制。
QOSMaxGRESPerUser： 超过当前 QoS 用户最大 GRES(GPU) 限制。
Priority：存在一个或多个更高优先级的任务，该任务需要等待。
ReqNodeNotAvail: 所申请的部分节点不可用。
Resources:暂无闲置资源，该任务需等待其他任务完成。

2. 查看作业信息

其中JOBID是执行squeue得到的

root@ceph01:~# scontrol show job JOBID

会显示很多信息，其中值得注意的有
NumNodes=1 NumCPUs=12 NumTasks=1 CPUs/Task=12 TRES=cpu=12,mem=120G,node=1 MinCPUsNode=12 MinMemoryCPU=10G
这些显示的是这个程序占用的资源

3. 查看历史作业

历史作业可以用sacct来查看，默认情况下，用户仅能查看属于 自己的历史作业。直接使用 sacct 命令会输出从当天 00:00:00 起到当前时间的全部作业
使用 sacct的前提条件是需要为slurm配置后端数据库，配置完成后才可以正常使用否则会有以下报错

root@ceph01:~# sacct
Slurm accounting storage is disabled

如果配置的有后端数据库，执行结果应类似以下格式

root@ceph01:~# sacct
       JobID    JobName  Partition    Account  AllocCPUS      State ExitCode
------------ ---------- ---------- ---------- ---------- ---------- --------
104                bash        gpu       root          1  COMPLETED      0:0
140                test        cpu       root         12  COMPLETED      0:0
141                test        cpu       root         12 CANCELLED+      0:0
141.batch         batch                  root         12  CANCELLED     0:15
141.extern       extern                  root         12  COMPLETED      0:0
142               lllll        cpu       root          1     FAILED      2:0
142.extern       extern                  root          1  COMPLETED      0:0
142.0             lllll                  root          1     FAILED      2:0

如果用sacct -S MMDD，则会输出从 MM 月 DD 日起的所有历史作业。默认情况会输出作业 ID，作业名，分区，账户，分配的 CPU，任务结束状态，返回码。

root@ceph01:~# sacct --format=jobid,user,alloccpu,allocgres,state%15,exitcode
       JobID      User  AllocCPUS    AllocGRES           State ExitCode
------------ --------- ---------- ------------ --------------- --------
104              liuhy          1        gpu:1       COMPLETED      0:0
104.extern                      1        gpu:1       COMPLETED      0:0
105              liuhy          1                    COMPLETED      0:0
140.batch                      12                    COMPLETED      0:0
141.batch                      12                    CANCELLED     0:15
141.extern                     12                    COMPLETED      0:0
142              liuhy          1                       FAILED      2:0
142.0                           1                       FAILED      2:0

运行任务

1.srun

其中一些比较有用的参数有：

参数用法含义
-p cpu指定分区为CPU
--nodes=N指定使用的节点数量
--nodelist=comput1指定特定节点
--cpus-per-task=4指定 CPU 核心数量
--mem-per-cpu=10G指定每个CPU核心的内存
--gres=gpu:1指定GPU卡数
--ntasks=ntasks指定运行的任务个数

2.使用示例

2.1 用12个cpu核并行运行一个单任务、总内存大小是120G

srun --mem-per-cpu=10G --cpus-per-task=12 --nodes=1 --ntasks=1

2.2 提交作业

首先，需要有一个 SLURM 作业脚本。假设我们有一个简单的 Bash 脚本 run_my_job.sh，它在 SLURM 系统中运行一个多进程的 Python 程序：

cat > my_multi_process_script.py << EOF
import multiprocessing
import time

def compute_fibonacci(number):
    """计算 Fibonacci 序列的指定项"""
    if number <= 1:
        return number
    else:
        return compute_fibonacci(number-1) + compute_fibonacci(number-2)

def worker_task(process_id):
    print(f"Process {process_id} started.")
    start_time = time.time()
    
    # 计算一个较大的 Fibonacci 数，你可能需要根据你的系统性能调整这个值
    fib_number = compute_fibonacci(35 + process_id)  # process_id 用来确保每个进程计算的值略有不同
    
    end_time = time.time()
    print(f"Process {process_id} finished. Fibonacci number: {fib_number}. Time taken: {end_time - start_time} seconds.")

def main():
    # 获取系统的 CPU 核心数量
    num_cores = multiprocessing.cpu_count()
    print(f'Number of CPU cores: {num_cores}')

    # 创建进程池
    with multiprocessing.Pool(processes=num_cores) as pool:
        # 创建进程ID列表
        process_ids = list(range(num_cores))

        # 并行运行工作任务
        pool.map(worker_task, process_ids)

if __name__ == '__main__':
    main()
EOF

脚本首先获取系统的 CPU 核心数量，然后创建一个进程池，其中每个进程执行 worker_task 函数。在这个例子中，我们计算Fibonacci(35)作为任务列表。

cat > run_my_job.sh << EOF
#!/bin/bash
#SBATCH --job-name=multi_process_python
#SBATCH --cpus-per-task=4
#SBATCH --nodes=1
#SBATCH --ntasks=1
#SBATCH --time=00:10:00
#SBATCH --output=job_output_%j.txt

srun python my_multi_process_script.py
EOF

SLURM 脚本会请求 1 个任务和每个任务 4 个 CPU 核心来运行一个名为 my_multi_process_script.py 的 Python 脚本。
使用以下命令提交作业：

sbatch -p cpu run_my_job.sh

2.3 检查作业状态

使用 squeue 命令查看作业状态：

squeue -u your_username

显示当前用户所有在队列中的作业的状态。找到你刚提交的作业，并记下它的作业 ID。

2.4 登录到节点并检查进程

2.4.1 查找作业分配到的节点名

作业开始运行后，使用 scontrol show job 命令查找作业分配到的节点名：

scontrol show job <JobID>

查找输出中的 Nodes 字段，它会告诉你作业运行在哪个节点上。
示例：

root@ceph01:~/test# scontrol show job 4
JobId=4 JobName=multi_process_python
   UserId=root(0) GroupId=root(0) MCS_label=N/A
   Priority=4294901757 Nice=0 Account=(null) QOS=(null)
   JobState=COMPLETED Reason=None Dependency=(null)
   Requeue=1 Restarts=0 BatchFlag=1 Reboot=0 ExitCode=0:0
   RunTime=00:00:00 TimeLimit=00:10:00 TimeMin=N/A
   SubmitTime=2024-06-12T09:17:14 EligibleTime=2024-06-12T09:17:14
   AccrueTime=2024-06-12T09:17:14
   StartTime=2024-06-12T09:17:14 EndTime=2024-06-12T09:17:14 Deadline=N/A
   SuspendTime=None SecsPreSuspend=0 LastSchedEval=2024-06-12T09:17:14
   Partition=cpu AllocNode:Sid=ceph01:1933842
   ReqNodeList=(null) ExcNodeList=(null)
   NodeList=ceph01
   BatchHost=ceph01
   NumNodes=1 NumCPUs=8 NumTasks=1 CPUs/Task=4 ReqB:S:C:T=0:0:*:*
   TRES=cpu=8,node=1,billing=8
   Socks/Node=* NtasksPerN:B:S:C=0:0:*:* CoreSpec=*
   MinCPUsNode=4 MinMemoryNode=0 MinTmpDiskNode=0
   Features=(null) DelayBoot=00:00:00
   OverSubscribe=NO Contiguous=0 Licenses=(null) Network=(null)
   Command=/root/test/run_my_job.sh
   WorkDir=/root/test
   StdErr=/root/test/job_output_4.txt
   StdIn=/dev/null
   StdOut=/root/test/job_output_4.txt
   Power=

2.4.2 登录到该节点

ssh NodesNAME

2.4.3 验证作业是否被执行

使用 top 或 htop（如果可用）查看 CPU 的使用情况，或者直接使用 ps 命令查看你的 Python 脚本相关的进程

ps -l -u your.name | grep python

假设 my_multi_process_script.py 正在节点上运行，使用 ps 命令可能会显示如下信息

1 R  7051  444198  444125  9  80   0 - 57585 -      ?        00:00:02 python
1 R  7051  444199  444125  9  80   0 - 57585 -      ?        00:00:02 python
1 R  7051  444200  444125  9  80   0 - 57585 -      ?        00:00:02 python
1 R  7051  444201  444125  9  80   0 - 57585 -      ?        00:00:02 python
1 R  7051  444202  444125  9  80   0 - 57585 -      ?        00:00:02 python
1 R  7051  444203  444125  9  80   0 - 57585 -      ?        00:00:02 python
1 R  7051  444204  444125  9  80   0 - 57585 -      ?        00:00:02 python
1 R  7051  444205  444125  9  80   0 - 57585 -      ?        00:00:02 python

444125 是父进程的 PID，而 444198, 444200, 444204 是由主进程创建的子进程（如果脚本是多进程的），R表明多进程确实在运行中。以下是其他状态

R (running): 表示进程正在运行或在运行队列中等待。
S (sleeping): 表示进程处于休眠状态，等待某些事件或定时器。
D (disk sleep): 不可中断的休眠状态，通常在等待I/O操作。
T (stopped): 表示进程已停止执行，可能是被调试或控制。
Z (zombie): 表示进程已结束，但其父进程尚未通过调用 wait() 来读取其退出状态。

最后修改：2024 年 08 月 08 日
© 禁止转载
如果觉得我的文章对你有用，请随意赞赏