$ tempo que significa ao usar o processamento paralelo em um cluster científico?

Estou executando meu programa de diferenças finitas em um cluster científico na minha escola. O programa usa o openmpi para paralelizar o código.

Quando o tempo do programa em série eu recebo:

real    78m40.592s
user    78m34.920s
sys     0m0.999s

Quando eu corro com processadores de 8 mpi eu recebo:

real    12m45.929s
user    101m9.271s
sys     0m29.735s

Quando eu corro com processadores de 16 mpi eu recebo:

real    4m46.936s
user    37m30.000s
sys     0m1.150s

Então, a minha pergunta é: se o tempo do usuário é o tempo total da CPU, por que os tempos do usuário são tão diferentes uns dos outros para diferentes números de processadores?

Obrigado,

Anthony G.

2
Veja as respostas aqui: stackoverflow.com/questions/20094547/& hellip; Para programas MPI use mpi_wtime()
adicionado o autor High Performance Mark, fonte

2 Respostas

Em série, seu código é executado em 78m40s e real e user são quase idênticos.

Quando você executa com 8 processos, que eu assumi que estão todos executando na mesma máquina (nó), o tempo total da CPU é 101m9. É muito maior, eu acho que você encontrou sobrecarga do nó ou superconsumimento de memória. Mas como você está usando 8 núcleos, o tempo total do relógio de parede é 101m9/8 = 12m45. Você poderia tentar executar novamente o teste e observar o que acontece.

Quando você executa com 16 processos, que assumi serem despachados em dois nós, o tempo real é 4m46, que é aproximadamente 78m40/16. Mas o tempo real é o tempo de CPU acumulado de todo o processamento em execução no mesmo nó que o mpirun ; o comando time não tem como saber sobre processos mpi sendo executados em outros nós; 37m30 é aproximadamente 78m40/2.

3
adicionado
Eu não percebi que o tempo do usuário era apenas para um nó. Sua resposta foi realmente útil. Eu executei novamente alguns dos meus códigos e o (tempo do usuário) * (# nós) foi aproximadamente o mesmo para todas as configurações do processador.
adicionado o autor Anthony, fonte
Eu escrevi o que pensei sobre os resultados no meu relatório. Link para o relatório
adicionado o autor Anthony, fonte
"É muito maior, eu acho que você encontrou sobrecarga do nó ou superconsumo de memória." Eu diria que ele preferiu Lei de Amdahl .
adicionado o autor Hristo Iliev, fonte
@HristoIliev foi o que eu pensei no início, mas depois eu vi o segundo exemplo com 16 núcleos de escalas quase perfeitamente, então ele também deve escalar com 8 procs. E OP confirma novos timings mais próximos do escalonamento linear do que o inicialmente reportado (veja o comentário acima).
adicionado o autor damienfrancois, fonte

Normalmente existem duas noções diferentes de tempo em um sistema de computador.

  1. Hora do relógio (vamos chamá-la T): Este é o tempo que passa no seu relógio, enquanto o seu programa está sendo executado.
  2. Tempo de CPU (vamos chamá-lo de C): esse é o tempo acumulativo que todas as CPUs trabalhando em seu programa gastaram executando seu código.

Para um código paralelo ideal rodando em CPUs P, T = C/P. Isso significa que, se você executar o código em oito CPUs, o código será oito vezes mais rápido, mas o trabalho foi distribuído para oito CPUs, que precisam ser executadas para C/P segundos/minutos.

In reality, there's often overhead in the execution. With MPI, you've got communication overhead. This usually cause a situation where T>C/P. The higher T becomes, the less efficient the parallel code is.

Um sistema operacional como o Linux pode lhe dizer mais coisas do que apenas a hora do relógio na parede. Geralmente, informa o horário do usuário e do sistema. O tempo do usuário é o tempo de CPU (não exatamente, mas por enquanto razoável) que o aplicativo gasta em seu código. Hora do sistema é a hora no kernel do Linux.

Felicidades,         -Michael

2
adicionado