SLURM允许作业使用的CPU数量超过启动请求的数量

我面临的SLURM问题可以总结如下。考虑一个bash脚本test.sh，该脚本请求8个CPU，但实际上使用10个CPU启动作业：

#!/bin/sh
#SBATCH --ntasks=8
stress -c 10

在具有32个CPU的服务器上，如果我用来启动此脚本5次sbatch test.sh，则其中的4个立即开始运行，最后一个显示为待处理，如squeue命令所示：

JOBID PARTITION     NAME     USER ST       TIME  NODES NODELIST(REASON)
    5      main  test.sh     jack PD       0:00      1 (Resources)
    1      main  test.sh     jack  R       0:08      1 server
    2      main  test.sh     jack  R       0:08      1 server
    3      main  test.sh     jack  R       0:05      1 server
    4      main  test.sh     jack  R       0:05      1 server

问题在于这4个作业实际上正在使用40个CPU，并使系统过载。相反，我希望SLURM要么不启动实际使用的资源超出用户要求的资源的作业，要么不等待它们，直到有足够的资源来启动它们为止。

有关我的slurm.conf文件的一些有用的详细信息：

# SCHEDULING                                                                       
#DefMemPerCPU=0                                                                    
FastSchedule=1                                                                     
#MaxMemPerCPU=0                                                                    
SchedulerType=sched/backfill                                                       
SchedulerPort=7321                                                                 
SelectType=select/cons_res                                                         
SelectTypeParameters=CR_CPU
# COMPUTE NODES                                                                 
NodeName=server CPUs=32 RealMemory=10000 State=UNKNOWN                   
# PARTITIONS                                                                    
PartitionName=main Nodes=server Default=YES Shared=YES MaxTime=INFINITE State=UP

我只是从SLURM开始，对此行为感到困惑。如何确保服务器的用户不会启动使用过多CPU的作业？我阅读了手册，并花了很多时间在论坛上寻找信息，但不幸的是，我发现没有任何帮助。

在此先感谢您的帮助！

Slurm不知道一个脚本要创建多少个进程/线程。它只能依赖请求的资源，因此，它就是用来调度作业的资源。

最好的方法是使用Slurm中的任何相似性插件，以防止作业使用比请求更多的资源。该插件将作业绑定到请求的cpus。（相关性文档）

显然，您无法控制用户在其脚本中启动多少个进程/线程，但是限制作业可以使用的核心数量将减少不受控制的用户可能对其他用户作业造成的影响。

这不会阻止您的系统出现过载，但是“不良”用户只会影响自己。

下面我们讨论过在SO我一直在试图用--exclusive参数来实现这一目标。我的体系结构与您的体系结构不同（我有7个可用的处理器），但这是我做的：

#!/bin/sh
#SBATCH --ntasks=2    
srun -n 2 --exclusive stress -c 1

然后运行

sbatch test.sh ; sbatch test.sh ; sbatch test.sh ; sbatch test.sh

给我6个stress过程：

15050 tom       20   0    7308    212    108 R 100.0  0.0   1:47.46 stress                                                                                                              
15054 tom       20   0    7308    208    108 R 100.0  0.0   1:47.47 stress                                                                                                              
15063 tom       20   0    7308    208    108 R 100.0  0.0   1:47.47 stress                                                                                                              
15064 tom       20   0    7308    212    108 R 100.0  0.0   1:47.47 stress                                                                                                              
15080 tom       20   0    7308    208    108 R 100.0  0.0   1:47.46 stress                                                                                                            
15076 tom       20   0    7308    212    108 R  99.7  0.0   1:47.45 stress      

最后一个在队列中等待：

     JOBID PARTITION     NAME     USER ST       TIME  NODES NODELIST(REASON)
      2368       Tom  test.sh      tom PD       0:00      1 (Resources)
      2365       Tom  test.sh      tom  R       5:03      1 Tom
      2366       Tom  test.sh      tom  R       5:03      1 Tom
      2367       Tom  test.sh      tom  R       5:03      1 Tom

因此，在这种情况下，使用srun -n 2会使同一进程启动两次。如果我使用同一件事

#!/bin/sh
#SBATCH --ntasks=2
srun -n 1 --exclusive stress -c 1 &
srun -n 1 --exclusive stress -c 1 &
srun -n 1 --exclusive stress -c 1 &
wait

即SLURM知道此批处理脚本有两个任务，因此它将使两个任务同时运行；第三者必须“等待轮到”。

另一方面

#!/bin/sh
#SBATCH --ntasks=1
srun -n 1 --exclusive stress -c 2

给我您在问题中描述的行为。

不知道这是否能100％回答，但也许会有所帮助。