= Entête des jobs et commandes occigen =

Cette page décrit les entêtes des jobs sur occigen ainsi que les commandes à lancer pour avoir un exécutable simple ou un couplé (oasis ou XIOS).

[[PageOutline]]

== Un executable séquentiel ==
 * Entête du job
{{{
#!/bin/bash
#SBATCH -J job_name
#SBATCH -e job_name.e%j
#SBATCH -o job_name.o%j
#SBATCH --nodes=1
#SBATCH --ntasks=1
#SBATCH --ntasks-per-node=24
#SBATCH --threads-per-core=1
#SBATCH --time=00:10:00

}}}
 * Commande 
{{{
time ./mon_executable param1 param2 …
}}}

== Un executable parallélisé avec MPI seulement ==
 * Entête du job
{{{
#!/bin/bash
#SBATCH -J job_name
#SBATCH --nodes=2
#SBATCH --ntasks=48
#SBATCH --ntasks-per-node=24
#SBATCH --threads-per-core=1
#SBATCH --time=00:30:00
#SBATCH --output job_name.output
}}}
 * Commande 
{{{
module purge
module load intel/15.0.0.090
module load bullxmpi/1.2.8.3
time srun --mpi=pmi2 -K1 --resv-ports -n $SLURM_NTASKS ./mon_executable param1  param2 …
}}}

 * Résultat : srun lance 48 tâches MPI

== NEMO MPI seul et XIOS en mode serveur  ==
 * Merci à JMM, DRAKKAR et CINES
 * Entête du job
{{{
#!/bin/bash
#SBATCH --nodes=554
#SBATCH --ntasks=13296
#SBATCH --ntasks-per-node=24
#SBATCH --threads-per-core=1
#SBATCH -J nemo_occigen
#SBATCH -e nemo_occigen.e%j
#SBATCH -o nemo_occigen.o%j
#SBATCH --time=24:00:00
#SBATCH --exclusive
}}}quit
 * Commande (exemple) :
{{{
 time srun --mpi=pmi2  -m cyclic \
--cpu_bind=map_cpu:0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23\
    --multi-prog  ./ztask_file.conf
}}}
  * avec ./ztask_file.conf contenant, oasis en premier obligatoirement:
{{{
0-295   ./xios_server.exe
296-13295   ./opa
}}}
 * Résultat : srun lance 13296 processus : 13000 pour NEMO et 296 pour XIOS

== Couplage IPSL : LMDZ + NEMO + 1 XIOS en mode serveur  ==

 * ajouter dans le .bashrc ou au début du script slurm
{{{
ulimit -S -s unlimited  # stack
ulimit -S -d unlimited  # data area
ulimit -S -m unlimited  # memory
ulimit -S -c 20
ulimit -S -n unlimited  # memory
ulimit -S -q unlimited  # memory
}}}
 * script automatique de création du rankfile : create_rankfile_cyclic_nemo_16ppn.sh (notation logique avec BullxMPI sur noeuds HT)
{{{
MPI_LMDZ=$1
OMP_LMDZ=$2
PPN_LMDZ=$3
MPI_NEMO=$4
PPN_NEMO=$5
MPI_XIOS=$6
PPN_XIOS=$7

# ...........................................................

for i in $( nodeset -e $SLURM_NODELIST) ; do
  echo $i >> atos_host
  for j in {1..24}; do
  echo $i >> atos_host1
  done
done

rm -rf atos_lmdz_rankfile atos_xios_rankfile atos_nemo_rankfile

compt=1 # rang absolu 
go_nemo=0
go_xios=0

for node in $( nodeset -e $SLURM_NODELIST ) ; do boucle sur les noeuds présents dans la liste fournie par SLURM 
	compt1=1 # rang local pour LMDZ
	FIRST_CORE=0
	FIRST_CORE1=0
    while [[ $compt -le $MPI_LMDZ && $compt1 -le $PPN_LMDZ ]]; do

	if [ $compt1 -le $(( $PPN_LMDZ / 2 )) ] ; then

	SOC=0  # scoket 0

	LAST_CORE=$(( $FIRST_CORE + ( $OMP_LMDZ * 2)   ))
	STRING=""

	for core in ` seq $FIRST_CORE 2 $(( $LAST_CORE - 2  )) `; do
 		if [ $core == $FIRST_CORE ]; then
   			STRING=$( echo $core )
 		else
   			STRING=$( echo $STRING','$core )
 		fi
	done
	FIRST_CORE=$LAST_CORE

	else # socket 1 

	SOC=1
	LAST_CORE=$(( $FIRST_CORE1 + ( $OMP_LMDZ * 2)   ))
	STRING=""

	for core in `seq $FIRST_CORE1 2 $(( $LAST_CORE - 2  ))  `; do
 		if [ $core == $FIRST_CORE1 ]; then
   			STRING=$( echo $core )
 		else
   			STRING=$( echo $STRING','$core )
 		fi
	done
	FIRST_CORE1=$LAST_CORE
	fi

    echo "rank "$(( $compt - 1 ))"="$node" slot="$SOC":"$STRING >> atos_lmdz_rankfile

    compt=$(( $compt + 1 )) # maj rang absolu
    compt1=$(( $compt1 + 1 )) # maj rang local LMDZ

    old_node=$node # dernier noeud occupé par LMDZ

    done # end while for lmdz #------------------------------------------------------------
#
#   NEMO ne coexiste pas sur le même noeud que des tâches LMDZ
#   NEMO : creation d'uh fichier temporaire NODEFILE pour NEMO 
#
    if [[ $compt -eq $(( $MPI_LMDZ + 1 )) && $old_node != $node ]]; then
	go_nemo=1
    fi

    if [[ $go_nemo -eq 1 && $compt -le $(( $MPI_LMDZ + $MPI_NEMO ))  ]]; then

	compt2=1 # rang local NEMO
	while [[ $compt2 -le $PPN_NEMO && $compt  -le $(( $MPI_LMDZ + $MPI_NEMO ))  ]]; do

		STRING=$(( ( $compt2 - 1 ) * 2 ))


		echo "rank "$(( $compt - 1 ))"="$node" slot="$STRING >> atos_nemo_rankfile
		compt=$(( $compt + 1 )) # rang absolu
		compt2=$(( $compt2 + 1 )) # rang local NEMO
	done
    fi
#
# XIOS
#
    if [[ $compt -eq $(( $MPI_LMDZ + $MPI_NEMO + 1 ))  ]]; then
	go_xios=1
    fi

	while [[ $go_xios -eq 1 && $compt -le $(( $MPI_LMDZ + $MPI_NEMO + $MPI_XIOS ))  ]]; do
		STRING=$(( ( $compt2 + 1 ) * 2 ))
		echo "rank "$(( $compt - 1 ))"="$node" slot="$STRING >> atos_xios_rankfile
		compt=$(( $compt + 1 ))
		compt2=$(( $compt2 + 1 ))
	done
done  # boucle for sur les noeuds présents dans la liste de SLURM
# -------------------------------------------------------------------------------------------
# ------------------------------------------------------------------------------------------
# NEMO : travail spécifique sur la distribution cyclique
# Cyclic for NEMO
#
First_rank_nemo=$(( $MPI_LMDZ + 1 ))
compt=1  # rang  NEMO
while [[ $compt  -le $MPI_NEMO  ]]; do # boucle locale sur les rangs NEMO

	compt2=1 # nombre de rangs NEMO sur le noeud en cours ( pour dépeuplement) 
	compt_core=$compt2 # initialisation compteur position du core utilisé sur le socketen suivant la numérotation logique
        max_on_socket=$((  $PPN_NEMO /2 ))
	while [[ $compt2 -le $PPN_NEMO && $compt  -le $MPI_NEMO ]]; do  # parcours des rangs NEMO 

		for i in $( cat atos_nemo_rankfile | sed 's@=@ @g' | awk '{print $3}' | sort | uniq ) ; do  # parcours de tous les noeuds pour NEMO

			if [ $compt  -le $MPI_NEMO ] ; then
				echo "rank "$(( $First_rank_nemo + $compt - 2  ))"="$i" slot="$(( 2 * ( $compt_core - 1 )  )) >> atos_nemo_rankfile1
				last_compt=$(( $First_rank_nemo + $compt - 2  )) # compteur rang nemo
				old_node1=$i
				old_string=$((  $compt_core - 1   ))
				compt=$(( $compt + 1 )) # rang  NEMO
			fi

		done # fin parcours sur les noeuds du fichier temporaire NODEFILE pour NEMO
  	compt2=$(( $compt2 + 1  )) # rang local  NEMO

#       depeuplement 8 NEMO par socket et 16 par noeud 
#       Quand commence -t on au deuxième socket ?
###	if [ $compt2 -eq 9 ]; then # 8 rangs NEMO non consecutifs sont déjà placés
	if [ $compt2 -eq $(( $max_on_socket + 1 )) ]; then # premier socket a atteint la limite max_on_socket 
  		compt_core=13 # on passe au deuxieme socket (numerotation logigue pour OpenMPI et pour le deuxieme socket sur Occigen cela commence au slot=24 == 2*(13-1) 
	else
  		compt_core=$(( $compt_core + 1 ))
	fi
	done
done
mv atos_nemo_rankfile1 atos_nemo_rankfile

######## XIOS with cyclic nemo

if [ $MPI_XIOS = 1 ]; then

echo "rank "$(( $last_compt + 1 ))"="$old_node1" slot="$(( ( $old_string + 1 ) * 2  )) > atos_xios_rankfile

fi


########

rm -f atos_rankfile

cat atos_lmdz_rankfile >> atos_rankfile
cat atos_nemo_rankfile >> atos_rankfile
cat atos_xios_rankfile >> atos_rankfile

}}}
 * script SLURM sur OCCIGEN
{{{
#!/bin/bash
#SBATCH  --nodes=26
#SBATCH --ntasks=269
#SBATCH --time=00:30:00
#SBATCH -J IPSL
##SBATCH -o IPSL_occigen.o.%J
##SBATCH -e IPSL_occigen.e.%J
#SBATCH --mem=120GB
#SBATCH --cpu_bind=none
#SBATCH --exclusive

module load intel/15.0.3.187
module load  bullxmpi/1.2.8.4-mxm

module load  hdf5/1.8.14_parallel_bullxmpi
module load  netcdf/bullxmpi/4.3.3-rc2
module load  netcdf/bullxmpi/fortran-4.4.1_4.3.3-rc2
module load  ferret/6.93

MPI_LMDZ=47 # nombre de tâches LMDZ
PPN_LMDZ=4  # nombre de tâches LMDZ par noeud de 24 cores
OMP_LMDZ=$(( 24 / $PPN_LMDZ )) # nombre de threads par tâche MPI LMDZ 
MPI_NEMO=221 # nombre de tâches NEMO

export OMP_NUM_THREADS=$OMP_LMDZ
#export KMP_STACKSIZE=2g
export KMP_STACKSIZE=3g

 * tuning pour bullxmpi

export KMP_BLOCKTIME=infinite
export OMP_NESTED=FALSE
export MXM_MEM_ON_DEMAND_MAP=n
export OMPI_MCA_mpi_leave_pinned=0

export bin_dir=$HOME/bin-with-xCORE-AVX2
cp $bin_dir/* .

# recopie des scripts 
cp ../scripts/s*ksh .
# recopie des donnees d entree 
ln -sf ../INPUT_CURIE/* .
# les arguments passes au script de creation automatique du rankfile sont :
# nb de tâches LMDZ - nb de threads/tâche - nombre de tâches LMDZ/noeud - nombre de tâches NEMO - nombre de tâches NEMO par noeud - nombre de tâches XIOS - nombre de tâches XIOS par noeud 
bash $SLURM_SUBMIT_DIR/create_rankfile_cyclic_nemo_16ppn.sh $MPI_LMDZ $OMP_LMDZ $PPN_LMDZ $MPI_NEMO 16 1 1

# ------------------------------------------------------------------------------------------------------------------------------------------------------
echo "RUN STARTS"
date
#
#  recopie du script slurm en cours dans le repertoire de travail sur $SCRATCHDIR
cp $0 .
#
# execution 
#
/usr/bin/time mpirun  --rankfile atos_rankfile -np $MPI_LMDZ ./script_lmdz.ksh : -np $MPI_NEMO ./script_opa.ksh : -np 1  ./script_xios.ksh
#
#####################################################################################################################################################
 * scripts ksh de lancement des trois codes gmc.e opa et xios_serve.exe
{{{
cat  script_lmdz.ksh
#!/bin/ksh
export KMP_STACKSIZE=3g
./gcm.e
}}}
{{{
cat script_opa.ksh
#!/bin/ksh
./opa
}}}
{{{
 cat script_xios.ksh
#!/bin/ksh
./xios_server.exe
}}}