SLURM `srun` vs` sbatch` e seus parâmetros

Estou tentando entender qual é a diferença entre SLURM srune sbatchcomandos. Ficarei feliz com uma explicação geral, ao invés de respostas específicas para as seguintes perguntas, mas aqui estão alguns pontos específicos de confusão que podem ser um ponto de partida e dar uma ideia do que estou procurando.

De acordo com a documentação , sruné para enviar trabalhos, e sbatché para enviar trabalhos para execução posterior, mas a diferença prática não é clara para mim, e o comportamento deles parece ser o mesmo. Por exemplo, tenho um cluster com 2 nós, cada um com 2 CPUs. Se eu executar srun testjob.sh &5x seguidas, ele enfileira perfeitamente o quinto trabalho até que uma CPU fique disponível, assim como a execução sbatch testjob.sh.

Para tornar a pergunta mais concreta, acho que um bom lugar para começar pode ser: Quais são algumas coisas que posso fazer com um e não posso fazer com o outro, e por quê?

Muitos dos argumentos para ambos os comandos são os mesmos. Os que parecem as mais relevantes são --ntasks, --nodes, --cpus-per-task, --ntasks-per-node. Como eles estão relacionados entre si e como eles diferem em relação a srunvs sbatch?

Uma diferença em particular é que sruncausará um erro se testjob.shnão tiver permissão de executável, ou seja, chmod +x testjob.shquando sbatcho executará sem problemas. O que está acontecendo "por baixo do capô" que faz com que isso seja o caso?

A documentação também menciona que sruné comumente usado dentro de sbatchscripts. Isso leva à questão: como eles interagem entre si e qual é o caso de uso "canônico" para cada um deles? Especificamente, eu usaria srunsozinho?

A documentação diz

srun is used to submit a job for execution in real time

enquanto

sbatch is used to submit a job script for later execution.

Ambos aceitam praticamente o mesmo conjunto de parâmetros. A principal diferença é que sruné interativo e bloqueador (você obtém o resultado em seu terminal e não pode escrever outros comandos até que seja concluído), enquanto sbatché processamento em lote e não bloqueia (os resultados são gravados em um arquivo e você pode enviar outros comandos Imediatamente).

Se você usar srunem segundo plano com o &sinal, remove o recurso de 'bloqueio' srun, que se torna interativo, mas não bloqueia. Porém, ainda é interativo, o que significa que a saída irá bagunçar seu terminal, e os srunprocessos estão vinculados ao seu terminal. Se você se desconectar, perderá o controle sobre eles, ou eles podem ser mortos (dependendo se eles usam stdoutou não basicamente). E eles serão eliminados se a máquina à qual você se conecta para enviar trabalhos for reinicializada.

Se você usar sbatch, você envia seu trabalho e é tratado por Slurm; você pode desconectar, matar seu terminal, etc. sem conseqüências. Seu trabalho não está mais vinculado a um processo em execução.

Quais são algumas coisas que posso fazer com um e não posso fazer com o outro, e por quê?

Um recurso que está disponível para sbatche não sruné arrrays trabalho . Como srunpode ser usado em um sbatchscript, não há nada que você não possa fazer sbatch.

Como eles estão relacionados entre si e como eles diferem para srun vs sbatch?

Todos os parâmetros --ntasks, --nodes, --cpus-per-task, --ntasks-per-nodetêm o mesmo significado em ambos os comandos. Isso é verdade para quase todos os parâmetros, com a notável exceção de --exclusive.

O que está acontecendo "por baixo do capô" que faz com que isso seja o caso?

srunexecuta imediatamente o script no host remoto, enquanto sbatchcopia o script em um armazenamento interno e o carrega no nó de computação quando o trabalho é iniciado. Você pode verificar isso modificando seu script de envio após ele ter sido enviado; as mudanças não serão levadas em consideração (veja isto ).

Como eles interagem entre si, e qual é o caso de uso "canônico" para cada um deles?

Você normalmente usa sbatchpara enviar um trabalho e srunno script de envio para criar etapas de trabalho como Slurm as chama. sruné usado para iniciar os processos. Se o seu programa for um programa MPI paralelo, srunse encarregue de criar todos os processos MPI. Caso contrário, srunexecutará seu programa quantas vezes forem especificadas pela --ntasksopção. Existem muitos casos de uso, dependendo se seu programa é paralelo ou não, tem um longo tempo de execução ou não, é composto de um único executável ou não, etc. A menos que especificado de outra forma, srunherda por padrão as opções pertinentes do sbatchou do sallocqual ele executa abaixo ( daqui ).

Especificamente, eu usaria o srun sozinho?

Exceto para pequenos testes, não. Um uso comum é srun --pty bashobter um shell em um trabalho de computação.

Na verdade, isso não responde totalmente à pergunta, mas aqui estão mais algumas informações que descobri que podem ser úteis para alguém no futuro:

De um tópico relacionado que encontrei com uma pergunta semelhante:

Resumindo, sbatch e salloc alocam recursos para o trabalho, enquanto srun inicia tarefas paralelas entre esses recursos. Quando chamado dentro de uma alocação de trabalho, srun iniciará tarefas paralelas em alguns ou todos os recursos alocados. Nesse caso, srun herda por padrão as opções pertinentes do sbatch ou salloc sob o qual é executado. Você pode então (normalmente) fornecer várias opções diferentes que irão substituir o que recebe por padrão. Cada chamada de srun dentro de um trabalho é conhecida como uma etapa do trabalho.

srun também pode ser chamado fora de uma alocação de trabalho. Nesse caso, srun solicita recursos e, quando esses recursos são concedidos, lança tarefas entre esses recursos como um único trabalho e etapa de trabalho.

Há uma página da web relativamente nova que fornece mais detalhes sobre as opções -B e --exclusive.

doc / html / cpu_management.shtml

Informações adicionais na página de FAQ do SLURM .

O comando srun possui dois modos diferentes de operação. Primeiro, se não for executado em um trabalho existente (ou seja, não dentro de uma alocação de trabalho Slurm criada por salloc ou sbatch), então ele criará uma alocação de trabalho e gerará um aplicativo. Se executado dentro de uma alocação existente, o comando srun apenas gera o aplicativo. Para esta questão, abordaremos apenas o primeiro modo de operação e compararemos a criação de uma alocação de trabalho usando os comandos sbatch e srun.

O comando srun é projetado para uso interativo, com alguém monitorando a saída. A saída do aplicativo é vista como saída do comando srun, normalmente no terminal do usuário. O comando sbatch é projetado para enviar um script para execução posterior e sua saída é gravada em um arquivo. As opções de comando usadas na alocação de trabalho são quase idênticas. A diferença mais notável nas opções é que o comando sbatch suporta o conceito de matrizes de tarefas, enquanto srun não. Outra diferença significativa está na tolerância a falhas. As falhas que envolvem trabalhos sbatch normalmente resultam em que o trabalho seja enfileirado e executado novamente, enquanto as falhas envolvendo srun normalmente resultam em uma mensagem de erro sendo gerada com a expectativa de que o usuário responderá de maneira apropriada.

Outra conversa relevante aqui