O SLURM permite trabalhos usando mais CPUs do que o solicitado para iniciar

O problema que estou enfrentando com o SLURM pode ser resumido da seguinte forma. Considere um script bash test.shque solicite 8 CPUs, mas na verdade inicia um trabalho usando 10 CPUs:

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

Em um servidor com 32 CPUs, se eu iniciar 5 vezes esse script sbatch test.sh, 4 deles começarão a ser executados imediatamente e o último aparecerá como pendente, conforme mostrado pelo squeuecomando:

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

O problema é que esses 4 trabalhos estão realmente usando 40 CPUs e sobrecarregam o sistema. Eu, pelo contrário, esperaria que o SLURM não iniciasse os trabalhos que estão realmente usando mais recursos do que o solicitado pelo usuário ou os retivesse até que houvesse recursos suficientes para iniciá-los.

Alguns detalhes úteis sobre o meu slurm.confarquivo:

# 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

Estou apenas começando com SLURM e estou intrigado com esse comportamento. Como posso garantir que os usuários do meu servidor não iniciem trabalhos que usam muitas CPUs? Li o manual e passei muito tempo procurando informações nos fóruns, mas infelizmente não achei nada útil.

Muito obrigado antecipadamente por sua ajuda!

Slurm não pode saber quantos processos / threads um script irá criar. Ele pode confiar apenas nos recursos solicitados e, portanto, é isso que ele usa para agendar trabalhos.

A melhor abordagem aqui será usar qualquer um dos plugins de afinidade no Slurm para impedir que os trabalhos usem mais recursos do que o solicitado. Esses plugins vinculam um trabalho ao cpus solicitado. ( Documentação de afinidade )

Obviamente, você não pode controlar quantos processos / threads um usuário inicia em seu script, mas limitar a quantidade de núcleos que um trabalho pode usar, reduzirá o impacto que um usuário não controlado pode causar nos trabalhos de outros usuários.

Isso não impedirá que o seu sistema pareça estar sobrecarregado, mas os usuários "ruins" somente se afetarão.

Após nossa discussão na SO, tentei usar o --exclusiveargumento para conseguir isso. Minha arquitetura é diferente da sua (tenho 7 processadores disponíveis para slurm), mas aqui está o que eu fiz:

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

e depois correndo

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

me dá 6 stressprocessos:

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      

com o último esperando na fila:

     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

Portanto, nesse caso, o uso srun -n 2faz com que o mesmo processo seja iniciado duas vezes. O mesmo acontece se eu usar

#!/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

isto é, o SLURM sabe que esse script em lote possui duas tarefas, permitindo que duas sejam executadas simultaneamente; o terceiro tem que "esperar a sua vez".

Por outro lado

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

me dá o comportamento que você descreve na sua pergunta.

Não tenho certeza se isso responde 100%, mas talvez ajude um pouco.