SLURM permite que jobs usando mais CPUs do que o solicitado iniciem

Question

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

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

Em um servidor com 32 CPUs, se eu iniciar 5 vezes esse script com sbatch test.sh , 4 delas começarão a ser executadas imediatamente e a última aparecerá como pendente, conforme mostrado pelo comando 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

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

Alguns detalhes úteis sobre meu arquivo 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

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

Muito obrigado antecipadamente pela sua ajuda!

    

Answer 1

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

A melhor abordagem aqui será usar qualquer um dos plugins de afinidade do Slurm para evitar que os jobs usem mais recursos do que o solicitado. Esses plugins ligam um job 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 sobre os trabalhos de outros usuários.

Isso não impedirá que seu sistema pareça estar sobrecarregado, mas os usuários "ruins" só afetarão a si mesmos.

    

Answer 2

Seguindo nossa discussão sobre o SO I Tenho tentado usar o argumento --exclusive para conseguir isso. Minha arquitetura é diferente da sua (eu 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 executando

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

me dá 6% de processosstress:

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, neste caso, usar srun -n 2 faz com que o mesmo processo seja iniciado duas vezes. A mesma coisa 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

i.e. O SLURM sabe que esse script em lote tem duas tarefas, então ele permitirá 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 em sua pergunta.

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