shellScriptSD_PV2026.1

.TH
ShellScript 1 "jan2026" "1.0" "prog verão LNCC"

.SH 
Programação em Shell Script - Escola Santos Dumont 2026 

.SH 
Eduardo Garcia - LNCC - bidu@lncc.br 


.SH
Inicio 

.SH 
PROCESSSO DE APRENDIZAGEM

    Lembrando: o objetivo de um curso é transmitir um conhecimento entre uma pessoa com experiência para uma outra com menos experiência em um topico expecifico.

    Durante o curso são utilizados materiais: ferramentas e casos de uso, para situações com escopo limitado e bem definido de maneira que o aprendiz possa se capacitar e se motivar a usar o aprendizado em situações gerais e complexas, se tornando uma pessoa mais experiente e com vontade de formar novos aprendizes.

.SH 
DESCRIÇÃO

Shell script é um programa, formato por uma sequência de comandos do sistema operacional UNIX, colocados em um arquivo de texto, com objetivo de:

.IP "1. " 4
Realizar tarefas frequentes da computação científica

.IP "2. " 4
Executar programas no computador Santos Dumont de acesso remoto

.RE


.SH Um shell script, como um programa em geral, pode conter:

.IP "1. " 4
Instruções simples formadas pelos comandos.
Os comandos são acessiveis atraves do nome, uma palavra, sequencia de letras,
geralmente em minusculas, consignificado em ingles ou abreviaturas de expressoes.
Podem ter o comportamento alterado atraves de parametros e argumentos, por exemplo:

.RS  4 
 pwd
 date
 ls 

 ls *.sh

 ls -l

 ls -d */

 cat submeterJobSD.sh
 cat -n submeterJobSD.sh

 head submeterJobSD.sh
 head -n 5 submeterJobSD.sh

 grep SBATCH submit_expMPI01.sh

 ls | grep sh 
 ls | grep -v sh 

 ls -p | grep -v /     # somente arquivos

 ls -d */              # somente diretorios

.RE


.IP "2." 4
Variáveis.

Variáveis são usadas para armazenar valores que podem ser reutilizados ao longo de um script. Elas permitem parametrizar comandos, controlar o fluxo de execução e adaptar o comportamento do script ao ambiente onde ele é executado. Cada variável possui um escopo, que define onde ela é visível e pode ser utilizada: local e de ambiente ou sistema.

Em shell script, variáveis não possuem tipo explícito e são tratadas, por padrão, como texto. O escopo de uma variável pode ser local ao script ou função, ou global quando definida como variável de ambiente.

.RS 4
Locais:
NP
horaInicial
horaFinal
meuRandom

De ambiente ou sistema:
São usadas para configuração do sistema operacional e dos programas instalados.

.RS 4

OMP_NUM_THREADS
Define o número de threads utilizadas por programas paralelos baseados em OpenMP.

PATH
Define os diretórios onde o sistema procura programas executáveis.

HOME
Indica o diretório pessoal do usuário no sistema.

USER
Identifica o nome do usuário logado.

RANDOM
.RE


.RE

.SS VARIÁVEIS DE AMBIENTE NO SD
No supercomputador Santos Dumont (SD), variáveis de ambiente são fundamentais para controlar o comportamento de aplicações paralelas, bibliotecas científicas e do próprio sistema de filas.

Essas variáveis possuem escopo global, sendo herdadas por processos filhos e programas executados a partir do shell.

Alguns exemplos:

.RS 4

SLURM_JOB_ID
	The unique ID assigned to the job allocation.

SLURM_SUBMIT_DIR
	The directory from which sbatch was originally invoked.

SLURM_JOB_NODELIST
	A list of nodes allocated to the job (e.g., node[01-04]).
sdumont[6155-6156]

SLURM_NNODES
	Total number of different nodes in the job's resource allocation.

SLURM_NTASKS
	Total number of tasks (processes) for the job.

SLURM_CPUS_PER_TASK
	Number of CPUs requested per task (set only if --cpus-per-task is used).

SLURM_ARRAY_TASK_ID
	The specific job index within a job array.

SLURM_JOB_PARTITION
	Name of the partition in which the job is running.

.RE



A correta definição dessas variáveis permite otimizar desempenho, garantir reprodutibilidade de execuções e adaptar scripts ao ambiente do SD.



.IP "3. " 4
Operadores: logicos, aritmeticos, relacionais
.RE

.IP "4. " 4
Estrutruras de controle de fluxo: desvios e repetições, por exemplo:

.RS  4
 if then else
 case
 for
 while
.RE

.IP "5. " 4
Funções de usuários. Não possui funções intrinsecas, somente comandos.

Comandos são programas. Estes podem ser internos ou externos. Internos estão na memoria RAM e externos estão em unidades solidas: discos.

.RE


.SH Geralmente possuem nome com terminação .sh
.br
por exemplo: compilarPrograma.sh, submeterJobSD.sh

.SH 3 formas de executar:
   
.IP "1. " 4
Forma clássica: o arquivo deve ter permissão de execução

.RS  4
$./compilarPrograma.sh 

$./rodarMeuProgramaMPI.sh 4 
.RE

Permissões ou atributos: de 3 em 3, read, write, execute, para o dono, grupo do dono, todos

-rwxrwxrwx 1 bidu bidu   60 Jan 26 11:08 compilarPrograma.sh
.RE

.IP "2. " 4
Uso do comando source para atribuir valores a variaveis de ambiente

.RS  4
$source configEnvSD.sh 
.RE
.IP "3. " 4
De forma identica a anterior mas abreviado com um ponto

.RS  4
$. configEnvSD.sh 
.RE

.SH EXEMPLOS SHELL SCRIPRT

.B os de configuração:
   ~/.bashrc
   ~/.profile

.B os de trabalho:
 $./meuShellScript_PV2026.sh [\fIargs\fR]  # uso classico 
 $sbatch submeterJobMPI_PV2026.sh          # uso em subcomputadores 
 $./rodarExperimento.sh 5                  # uso classico com argumentos 
 $cat -n rodarExperimento.sh

#!/usr/bin/bash

function executionDrive(){ 
  tempoProcFiciticio="2"                           #codigo morto
  tempoProcFiciticio=${1:-"2"}
  echo -e "em $PWD \n"
  comandoRUN="sleep        ${tempoProcFiciticio}"  #codigo morto
  comandoRUN="meuSleep.exe ${tempoProcFiciticio}"
  echo -e "linha de comando: " $comandoRUN "\n"
  eval $comandoRUN  
}

main(){
  dataInicio=$(date)
    start_time="$(date -u +%s)"
      executionDrive $@
      end_time="$(date -u +%s)"
  dataFinal=$(date)

  echo repetindo a apresentação do comando:
  echo -e $comandoRUN "\n"
  elapsed="$(($end_time-$start_time))"
  echo "Total of $elapsed seconds elapsed"
  echo " +++ inicio dA rodada: $dataInicio"
  echo " +++ fim .. dA rodada: $dataFinal "
  echo -e "\n\n\n"
  return
}

main $@

.RE


.SH 
PARA O CASO DO SUPERCOMPUTADOR:

 Um programa rodando ou esperando para ser executado em um supercomputador é geralmente chamado de JOB.

 Para esta utilização do supercomputador, são necessarias algumas instruções especificas que definem a quantidade e a forma de utilização dos recursos que são solicitados para execução de um programa, JOB: quantidade de nucleos, quantidade de memoria, tempo estimado de processamento

 O computador Santos Dumont usa um programa especifico do gerenciador de JOBs chamado: SLURM, que possui varios comandos em linha.  Para solitar que um JOB seja executado é usado o comando: sbatch

   Por exemplo: sbatch submeterJobMPI.sh

  'Submeter em batch' é um nome classico da tarefa de submeter um pedido  para execução de um programa no supercomputador, sem o usuario estar iteragindo durante a execução.

.SH Voltando a shell script 

 Um shell script é um programa com muita semelhança com programas da linguagem C: 

.TP
 1. Uso de variaveis escalares e vetores (arrays)
.TP
 2. Entrada e saida, 
.TP
 3. Operacoes aritimeticas, relacionais e logicas, 
.TP
 4. Estruturas de controle de fluxo: laço, desvio, conrolado (for, if, case) 
.TP
 5. Modularização com funções e arquivos separados 

.TP
 Não é compilado como em C e sua execução é feita atraves\
 de um programa que faz a interpretação dos comandos, \
 chamado de shell, como em python, perl. 
   exemplo de um interpretador: bash  
   está no diretorio: /usr/bin 

.TP
 O interpretador de comandos funciona de forma implicita no terminal\
   de comandos, e pode funcionar de forma explicita para o usuárioo.

   em forma de comandos, não de shell scripts

.B   implicitamente:
     $ls -ltr
 
.B   explicitamente:
     $bash -c "ls -ltr"

     Esta forma explicita pode ser comparada com uma forma de utilização 
 da linguagem Python, que é uma linguagem interpretada como o shell script

     $python -c "print(2+3)"
     $python -c "A=2;B=3;print(A,"+",B,"=",A+B);"
  
   neste ultimo com 3 instruções, separadas por ';'i, em uma mesma linha

.TP
 Os arquivos de shell script Iniciam com uma linha especificando o interpretador de comandos, embora não seja obrigatorio em muitos casos 
#!/usr/bin/bash 

.SH NOTE: UM SHELL SCRIPT É UM PROGRAMA

.TP
Um programa é um arquivo na memoria ou no disco
.TP
Um arquivo possui artributos e permissões
exemplo de atributos:
 nome, data de alteração, tamanho em bytes, dono e permissões o: escrita, leitura, execução

por exemplo:
-rwxr-xr-x 1 bidu bidu     82 Jan 17 17:02 compilar.sh
.br
 rwx       readable, writable and executable para o dono do arquivo    
.br
    r-x    readable           and executable para o grupo do dono do arquivo
.br
       r-x readable           and executable para toda a comunidade do sistema de arquivo
.br

.TP
No computador Santos Dumont shell script terá mais uma utilização que é um script de configuração de job de submissão através do programa de gerencia e uso do supercomputador chamado SLURM

	sbatch submeterJobMPI_PV2026.sh

.SH COMANDOS:

 Instruções dadas ao sistema operacional através do teclado na linha de comando
 
 O local do terminal onde se inicia a digitação do comando é chamado de PROMPT e geralmente inicial com o simbolo '$'

 Comando são acionados por um nome e possuem um funcionamento basico

 exemplo: ls

 Podem ser seguidos de parametros e argumentos que modificam o funcionamento basico

 exemplo: ls -ltr

 Alguns não exigem parametros nem argumentos:

   ls, pwd, cd, date, tree, echo, hostname

 mas podem usar:

   ls                  : lista o conteudo do diretorio atual
             mostra arquivos e diretorios
   ls -l               : lista o conteudo do diretorio atual
             no formato longo mostrando atributos e permissões
   hostname            : mostra o nome da maquina
   hostname -i         : mostra o endereço ip

 Outros exigem parametros e argumentos:
   file, cat, size, wc, touch, chmod, less, head, tail,
   time

   sleep 2                        # executa um programa sem consumo de recurso computacional 
   date                           # mostra informacoes sobre o tempo:dia,mes,ano,hora
   date -u +%s                    # mostra informação sobre tempo em segundos  
   wc       rodarExperimento.sh.c # mostra o numero de linhas, palavras e caracteres
   wc -l    rodarExperimento.sh.c # mostra o numero de linhas
   wc -w    rodarExperimento.sh.c # mostra o numero de palavras
   cat      rodarExperimento.sh.c # mostra o conteudo do todo o arquivo
   cat -n   rodarExperimento.sh.c # mostra o conteudo do todo o arquivo incluindo os numeros das linhas
   head     rodarExperimento.sh.c # mostra as 10    primeiras linhas do arquivo
   head -n2 rodarExperimento.sh.c # mostra as duas  primeiras linhas do arquivo
   tail     rodarExperimento.sh.c # mostra as dez   ultimas linhas do arquivo
   tail -n2 rodarExperimento.sh.c # mostra as duas  ultimas linhas do arquivo
   mkdir  verao2026         #cria um diretorio com o nome verao2026 e     da erro se existir
   mkdir  verao2026 -p      #cria um diretorio com o nome verao2026 e não da erro se existir
   mv compilar.sh           ../verao2026 # troca o arquivo de diretorio
   mv rodarExperimento.sh.c ../verao2026 # troca o arquivo de diretorio
   cd verao2026                          # troca de diretorio de trabalho
   grep    mpi rodarExperimento.sh.c           #mostra as linhas onde ocorrem a  palavra  'mpi' 
   grep -i mpi rodarExperimento.sh.c           #mostra as linhas onde ocorrem as palavras 'mpi' e 'MPI'

 O comando 'man  ls', exibe paginas de manual deste comando

 O comando 'info ls', exibe paginas de manual deste comando

 O nome comando seguido de '--help' mostra uma lista de parametros que modificam o
    funcionamento do comando

 Os comandos podem ser classificados como:
   internos (built in): programas cujo o arquivo estão na memoria principal: RAM
    por exemplo: ls, cd
   externos:            programas cujo o arquivo estão em memoria secundaria: disco
    por exemplo: file, cat, bash

  Em comando externos o sistema precisa saber onde se localizam de forma explicita
          isso é feito usando a variavel PATH

          PATH contem uma lista de diretorios onde o sistema procura pelos comandos

          $echo $PATH    : este comando mostra o conteudo da variavel PATH


/home/bidu/.local/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/lib/wsl/lib:/snap/bin:./


          $which cat     : mostra o diretório onde o arquivo se encontra

          /usr/bin/cat

          $export PATH=$PATH:~/meusScripts  : o sinal de igual significa uma atribuição. neste caso PATH será modificado

          $echo $PATH    

/home/bidu/.local/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/lib/wsl/lib:/snap/bin:~/meusScripts

         Programas executaveis: podem ser arquivos compilados ou shell scripts que possuem o atributo de execução ligados

        $ls -ltr |tail -2
        -rw-rw-rw- 1 bidu bidu     77 Jan 21 16:36 aloSD.c
        -rw-rw-rw- 1 bidu bidu     77 Jan 21 14:37 compilar.sh

        $cat -n compilar.sh

     	1  #!/usr/bin/bash
     	2  gcc -c aloSD.c
     	3  gcc    aloSD.o -o aloSD.exe

        Modificar o atributo do arquivo compilar.sh para torná-lo executavel

        $chmod +x compilar.sh

        $ls -ltr |tail -2
        -rw-rw-rw- 1 bidu bidu     77 Jan 21 16:36 aloSD.c
        -rwxrwxrwx 1 bidu bidu     77 Jan 21 14:37 compilar.sh
         
        Executar um arquivo shell script, com o comando externo, com o atributo executavel:

        $./compilar.sh

        $ls -ltr |tail -2
        -rw-rw-rw- 1 bidu bidu     77 Jan 21 16:36 aloSD.c
        -rwxrwxrwx 1 bidu bidu     77 Jan 21 14:37 compilar.sh
        -rwxrwxrwx 1 bidu bidu     77 Jan 21 16:38 aloSD.exe

          executar um arquivo compilado, criado pelo compilador, gcc, com o comando externo,
  com o atributo executavel:

         $./aloSD.exe
      
         alo SDumont!

.TP Shell script de configuração: .bashrc

.SH  AMBIENTE

.SH SISTEMA DE ARQUIVOS

.SH DiRETORIOS

 Diretorio ou pasta é uma estrutura de organização hierarquica dos arquivos locais nomeados

 Hierarquica em camadas, um dentro do outro. 

$du -h verao2026  
.br
36K     verao2026/expSD/scripts 
.br
0       verao2026/expSD/sequana 
.br
112K    verao2026/expSD 
.br
16K     verao2026/lib 
.br
496K    verao2026 
.br

 $tree -d verao2026

verao2026
.br
├── expSD
.br
│   ├── scripts
.br
│   └── sequana
.br
└── lib
.br

4 directories

   Dois diretorios especiais sem nome:
   .       diretorio atual

   ..      diretorio anterior 

    o diretório verao2026 é anterior, é pai de expSD e lib

    o diretório expSD é anterior, é pai de script e sequana 

    São localizações, caminhos relativos a um outro diretorio

    Um diretorio que inicia com '/' define um caminho absoluto, não 
 possui pai  

.SH
 Comunicação entre comandos com o operador | , pipe

.TP
 Comando executados em sequencia. A saida do do primeiro é a entrada para o segundo 

$du -h verao2026 | sort -n
.br
0       verao2026/expSD/sequana
.br
16K     verao2026/lib
.br
36K     verao2026/expSD/scripts
.br
112K    verao2026/expSD
.br
496K    verao2026
.br

 $ps -le | head -1
 $ps -le | tail -8

 xterm: é uma janela de interface com o sistema operacional
    possui uma formatação de texto baseado na tabela ASCII
    está ligada diretamente ao teclado e mouse
    abriga o interpretador de comandos: /usr/bin/bash

.SH
 VARIÁVEIS LOCAIS

   A=10
   numLinhas="wc -l expMPI.c" 

  o simbolo $ na frente do nome permite acessar o conteudo
  echo A=$A
  echo numLinhas=$numLinhas

   VARIAVEIS DE NOMES FIXOS, PREDEFINIDAS 

   por exemplo:
     $$ -> PID : numero do processo
     !$ -> argumento do ultimo comando
     $? -> codigo de erro retornado do ultimo comando 

   dentro dos shell scripts
   vindas da linha de comando na execução: $1, $2, ...
   
   podem ser passadas para os shell scripts por argumento na linha de comando
     estas possuem nomes que usam digitos numericos: $1, $2, $3

   cat soma.sh
  #!/usr/bin/bash
  A=${1:-"7"}
  B=${2:-"5"}
  echo $A + $B "=" $((A+B)) 
  echo $B + $A "=" $((B+A)) 

3.3 Utilização
  para alterar o conteudo o simbolo não é utilizado
  export PATH=$PATH:~/meusScripts

1.2 Variaveis de ambiente: servem para configurar o funcionamento do sistema

   SHELL 
   USER, PWD, HOME, SCRATCH
   PATH, PS1, LIBRARY_PATH, LD_LIBRARY_PATH
   DISPLAY
   PID, PPID 

    São atribuidas usando o comando 'export'

    $export PATH=$PATH:~/meusScripts
    $export PS1='${debian_chroot:+($debian_chroot)}\[\033[01;32m\]\u@\h\[\033[00m\]:\[\033[01;34m\]\W\[\033[00m\]\$ ' 

 Uso em um script de compilação de programa:

    $cat -n compilarC.sh
.br
	1 #!/usr/bin/bash
.br
	2 gcc -c aloC.c 
.br
	3 gcc -c escreverMSG.c -fpic
.br
	3 gcc -c lerMSG.c      -fpic
.br
	4 gcc -shared -o lib/libBD.so escreverMSG.o lerMSG.o
.br
	5 gcc  aloC.o     -lBD -o aloC.exe

    $./compilarB.sh 
.br
/usr/bin/ld: cannot find -lBD
.br
collect2: error: ld returned 1 exit status

    $export  LIBRARY_PATH=/mnt/c/Users/bidu/OneDrive/aLncc/aCursoProgramacao/verao2026/lib
.br
    $./compilarB.sh 
.br
    $./aloSD.exe
.br
./aloSD.exe: error while loading shared libraries: libBD.so: cannot open shared object file: No such file or directory
.br
    $export LD_LIBRARY_PATH=/mnt/c/Users/bidu/OneDrive/aLncc/aCursoProgramacao/verao2026/lib
.br
    $./aloC.exe
.br
Ola C!!!
.br
Sun Jan 21 21:13:16 -03 2026
.br
/mnt/c/Users/bidu/OneDrive/aLncc/aCursoProgramacao/verao2026
.br
pc013047
.br

    $export PATH=$PATH:./
.br
    $compilarC.sh && aloC.exe
.br
    $nm -D -l lib/libBD.so --print-file-name
.br
lib/libBD.so:                 w _ITM_deregisterTMCloneTable
.br
lib/libBD.so:                 w _ITM_registerTMCloneTable
.br
lib/libBD.so:                 w __cxa_finalize
.br
lib/libBD.so:                 w __gmon_start__
.br
lib/libBD.so:0000000000001119 T escreverMSG
.br
lib/libBD.so:0000000000001130 T lerMSG
.br
lib/libBD.so:                 U puts
.br

    O uso de shell script pode tornar uma tarefa mais segura por permitir
 incluir etapas que não seriam usadas se não fosse de forma automatica
    $cat -n compilarD.sh
.br
    1. #!/usr/bin/bash
.br
    2. nomeFonteMain=aloC
.br
    3. rm $nomeFonteMain.exe *.o lib/*
.br
    4. gcc -c $nomeFonteMain.c
.br
    5. gcc -pic -c escreverMSG.c -fpic
.br
    6. gcc -pic -c lerMSG.c ; if [ $? -eq 0 ];  then echo " criado: lerMSG.o "; else echo "erro em lerMSG.c"; fi
.br
    7. gcc -shared -o lib/libBD.so escreverMSG.o lerMSG.o \
.br
    8.  && gcc  $nomeFonteMain.o     -lBD -o $nomeFonteMain.exe
.br

.SH VOLTANDO AO EXEMPLO INICIAL:  scripts/rodarExperimento.sh
#!/usr/bin/bash
function executionDrive(){ 
  tempoProcFiciticio=${1:-"2"}
  echo -e "em $PWD \n"
  comandoRUN="sleep        ${tempoProcFiciticio}"  #codigo morto
  comandoRUN="meuSleep.exe ${tempoProcFiciticio}"
  echo -e "linha de comando: " $comandoRUN "\n"
  eval $comandoRUN  
  echo $PATH
  echo -e "\n\n\n"
  PATH=$PATH:./
  echo $PATH
  eval $comandoRUN  
  echo -e "\n\n\n"
}

main(){
  dataInicio=$(date)
    start_time="$(date -u +%s)"
      executionDrive $@
      end_time="$(date -u +%s)"
  dataFinal=$(date)

  echo repetindo a apresentação do comando:
  echo -e $comandoRUN "\n"
  elapsed="$(($end_time-$start_time))"
  echo "Total of $elapsed seconds elapsed"
  echo " +++ inicio dA rodada: $dataInicio"
  echo " +++ fim .. dA rodada: $dataFinal "
  echo -e "\n\n\n"
  return
}

main $@

.SH outro exemplo de script com laços e desvios

#!/bin/bash
while true
do
        read -p "insira um Numero: " numero
	echo numero lido: $numero
        if [[ $((numero % 2)) -eq 0 && $numero -lt 100 ]]
        then
                continue
        fi
        if [[ $((numero % 2)) -eq 0 && $numero -gt 100 ]]
        then
                echo $numero
                continue
        fi
        if [ $((numero % 2)) -ne 0 ]
        then
                echo $((numero * 2))
                continue
        fi
        if [ $numero -eq 100 ]
        then
                break
        fi
done 

.SH scripts do SANTOS DUMONT 

$cat submit_expMPI01.sh
.br
#!/bin/bash
.br
#SBATCH --nodes=1                  #Número de Nós
.br
#SBATCH --ntasks=4                #Numero total de tarefas MPI
.br
#SBATCH -p sequana_cpu_dev      #Fila (partition) a ser utilizada
.br
#SBATCH -J expMPI01               #Nome job
.br
#SBATCH --time=00:2:00            #Obrigatório
.br
####SBATCH --mem 1000000000
.br
NP=5
.br
   echo "linha de comando de submissão: $0 $@"
.br

.br
   EXEC_NAME=aloMPI.exe #meuSleep.exe
.br
   EXEC_DIR=bin
.br
   executable=$EXEC_DIR/$EXEC_NAME
.br

.br
   if [ -z "$SLURM_JOB_NAME" ]; then
.br
    SLURM_NTASKS=$NP 
.br
    echo "Execução interativa (linha de comando)"
.br
    comandoRUN="mpirun -n ${NP} $executable"
.br
    comandoRUN="mpirun -n ${SLURM_NTASKS} $executable"
.br
   else
.br
    echo "Execução via sbatch"
.br
    comandoRUN="srun  $executable"
.br
   fi
.br
.br

.br
   echo SLURM_NTASKS=$SLURM_NTASKS
.br

.br
   SLURM_JOB_NODELIST=${SLURM_JOB_NODELIST:-"$(hostname)"}
.br
   echo SLURM_JOB_NODELIST=${SLURM_JOB_NODELIST}
.br

.br
   SLURM_SUBMIT_DIR=${SLURM_SUBMIT_DIR:-$PWD}
.br
   echo SLURM_SUBMIT_DIR=${SLURM_SUBMIT_DIR}
.br
   cd  $SLURM_SUBMIT_DIR
.br

.br
   comando="module load openmpi/gnu/4.1.4_sequana"
.br
   echo $comando; eval $comando
.br

.br
   echo $comandoRUN; eval $comandoRUN
.br

$cat submit_expMPI05.sh
.br
#!/bin/bash
.br
#SBATCH --nodes=1                  #Número de Nós
.br
#SBATCH --ntasks=4                 #Numero total de tarefas MPI
.br
#SBATCH -p sequana_cpu_dev      #Fila (partition) a ser utilizada
.br
#SBATCH -J expMPI05                #Nome job
.br
#SBATCH --time=00:20:00            #Obrigatório
.br
# SBATCH --mem 1000000000000000000
.br

.br
function settings(){
.br
   echo "linha de coomando de submissão: $0 $@"
.br
   NP=5
.br
   EXEC_NAME=aloMPI.exe #meuSleep.exe
.br
   EXEC_NAME=${1:-"meuSleep.exe 2"}
.br
   EXEC_DIR=bin
.br
   executable=$EXEC_DIR/$EXEC_NAME
.br

.br
   if [ -z "$SLURM_JOB_NAME" ]; then
.br
    SLURM_NTASKS=$NP 
.br
    echo "Execução interativa (linha de comando)"
.br
    comandoRUN="mpirun -n ${NP} $executable"
.br
    comandoRUN="mpirun -n ${SLURM_NTASKS} $executable"
.br
   else
.br
    echo "Execução via sbatch"
.br
    comandoRUN="srun  $executable"
.br
   fi
.br
   echo SLURM_NTASKS=$SLURM_NTASKS
.br

.br
   SLURM_JOB_NODELIST=${SLURM_JOB_NODELIST:-"$(hostname)"}
.br
   echo SLURM_JOB_NODELIST=${SLURM_JOB_NODELIST}
.br

.br
   SLURM_SUBMIT_DIR=${SLURM_SUBMIT_DIR:-$PWD}
.br
   echo SLURM_SUBMIT_DIR=${SLURM_SUBMIT_DIR}
.br
}
.br
   
.br
function modulesLoad(){
.br
   cd $SLURM_SUBMIT_DIR
.br
   comando="module load openmpi/gnu/4.1.4_sequana"
.br
   echo $comando; eval $comando
.br
}
.br

.br
function executionProgram(){
.br
   echo $comandoRUN; eval $comandoRUN
.br
}
.br

function driver(){
.br
  dataInicio=$(date)
.br
  start_time="$(date -u +%s)"
.br
   settings $@
.br
   if [ "$(hostname|cut -c1-7)" == "sdumont" ] ; then 
.br
      modulesLoad
.br
   fi
.br
   executionProgram
.br
  end_time="$(date -u +%s)"
.br
  dataFinal=$(date)
.br

.br
  echo -e "$PWD \n"
.br
  echo repetindo a apresentação do comando:
.br
  echo -e $comandoRUN "\n"
.br
  elapsed="$(($end_time-$start_time))"
.br
  echo "Total of $elapsed seconds elapsed"
.br
  echo " +++ inicio dA simulacao: $dataInicio"
.br
  echo " +++ fim .. dA simulacao: $dataFinal "
.br
   return
.br
}
.br

.br
driver $@
.br