
# gitlab-runner (CVTK)
C. Hourdin - Juillet 2022
## Table of content 
[toc]


## CVTK test\_repro: Principe de fonctionnement 
C. Hourdin - Juillet 2022

**Test of compilation and good parallel reproductibility (OpenMP and MPI) of code (test\_repro)**


Il y a aussi test\_perfrst (perfect Restart) et test\_real

[doc croco CVTK (Rachid)
](https://gitlab.inria.fr/croco-ocean/croco/-/wikis/devs/Automatic-testing)

1. CVTK tourne d'abord en mode SERIAL (monoproc) 
Il écrit des tableaux (RVTK\_DEBUG\_WRITE) sélectionnés par des clés RVTK :
RVTK\_DEBUG
RVTK\_DEBUG\_PERFRST  (perfect restart)
RVTK\_DEBUG\_ADVANCED
Les tableaux sont écrit dans un fichier *check\_file* qui peut vite devenir énorme.

1. Il tourne ensuite en mode MPI et/ou OPENMP
*Remarque:* le mode OPENMP est peu ou pas utilisé dans croco. Pas complètement ou mal codé.
Poour chaque tableau choisi par les clés RVTK_DEBUG, CVTK va lire le tableau correspondant écrit dans le fichier *check\_file* en mode SERIAL.
Cette lecture se fait avec la routine debug.F (subroutine check\_tab2d, check\_tab3d).
Si le tableau est différent, il stoppe avec un message d'erreur spécifié	 pour identifier le tableau incriminé:

```
#  if defined RVTK_DEBUG || defined RVTK_DEBUG_ADVANCED
C$OMP MASTER
      call check_tab2d(ust2d(:,:),'ust2d in prestep ','u')
      call check_tab2d(vst2d(:,:),'vst2d in prestep ','v')
C$OMP END MASTER
#  endif
```

REMARQUE:  CVTK garanti le bon fonctionnement du parallèlisme et de la restartabilité après modification du code, mais ne garanti pas que le commit testé conserve les resultats de nos configurations. Il faut donc envisager des tests complémentaires de conservation de nos resultats de simu avant / après modification du code pour chacune de nos configs.



## CVTK test\_repro: Mise en oeuvre sur IRENE (Skylake & AMD)



### Installation sur IRENE (Skylake & AMD)
C. Hourdin - Juillet 2022


`module load gitlab-runner/13.3.0`

On personnalise l'environnement dans:
`croco/.gitlab-ci.yml`

comme :

```
  CI_FC: "ifort"
  CI_MPIF90: "mpif90"
```

TOUJOURS COMMITER SINON gitlab-runner NE PREND PAS EN COMPTE LES MODIFS !!!!!!!


CVTK test\_repro contient 3 types de tests: 

1. **ANA**
	the various analytical test cases, the ANA tests family.
	
2. **VORT** (AGRIF)
	the vortex test case that tests AGRIF nesting: NoAGRIF, AGRIF 1 way, AGRIF 2 way. This is the VORT tests family
	
3. **REG** (BENGUELA_VHR)
	Various regional test cases on the Benguela_VHR grid with different sets of keys. This is the REG tests family
	
Tout est dans :

```
CVTK/common
CVTK/test_repro
CVTK/test_repro/Scripts_ana
CVTK/test_repro/Scripts_reg
CVTK/test_repro/Scripts_vort
```

### Tests analytiques
[doc croco Test cases](https://croco-ocean.gitlabpages.inria.fr/croco_doc/tutos/tutos.03.test_cases.html)

les configs sont définies dans :

`CVTK/test_repro/Scripts_ana/Configure_Test_ana_ALL`

```
BASIN   DUNE     GRAV_ADJ  INNERSHELF  ISOLITON  KH_INST   RIP    SANDBAR   SHELFRONT  SWASH  THACKER     TS_HADV_TEST
CANYON  EQUATOR  IGW       INTERNAL    JET       OVERFLOW  RIVER  SEAMOUNT  SHOREFACE  TANK   TIDAL_FLAT  UPWELLING
```

On fait la liste des configs par copie des configs voulue dans :

`CVTK/test_repro/Scripts_ana/Configure_Test_ana`

si on veut juste tester BASIN RIVER et JET:

```
BASIN RIVER  JET
```


```
#!/bin/bash

LIST_KEY0='REGIONAL MPI OPENMP'
# => Keys that will put to undef at the begining of the rvtk scripts

TEST_NAME='BASIN'
CONFIG_NAME='BASIN'
LIST_KEY_PHYS='BASIN'
FLAG_OPENMP=1 ; FLAG_MPI=1
NBPROCS_X=2
NBPROCS_Y=2
NBPROCS=$(( $NBPROCS_X * $NBPROCS_Y ))
LIST_KEY_NEST=''
KEY_DEBUG='RVTK_DEBUG'
CROCOIN=''
```
Pour activer ou désactiver le test en OPENMP ou en MPI: 
FLAG à 0 ou 1

le jobcomp executé est :

`CVTK/common/jobcomp_rvtk.bash`

```
OCEAN/cppdefs.h
OCEAN/param.h
```

Les fichiers param.h et cppdefs.h sont construits par des sed sur les 2 fichiers sources dans croco/OCEAN.

on lance CVTK en interractif avec :

<mark>**gitlab-runner exec shell ana_run --timeout 7200**</mark>

```
   exec          Execute a build locally
   ana_run       défini dans .gitlab-ci.yml
                    (ou vort_run, ou reg_run)
   timeout       Set maximum job timeout for a runner
```

Il commence par lire et executer le fichier croco/.gitlab-ci.yml

Puis va aller réaliser tous les tests dont les fichiers de configs sont dans

`CVTK/test_repro/Scripts_ana/`

Il lance :
  
```
create_link_master_ana.sh
     (CVTK/test_repro/Scripts_ana/create_link_master_ana.sh)
```

puis

   
```
./mk_TESTALL.bash CONFIGURE_ANA ana
    (CVTK/test_repro/mk_TESTALL.bash)
```

des sed pour aller remplacer les options dans cppdefs.h et param.h du source croco.

Exemple execution de BASIN : 

```
dans /ccc/scratch/cont005/gen1140/hourdinc/croco_dev_2022_PISCES/builds/0/project-0/.datawork/KTEST/BASIN

sorties de la compilation dans :
jobcomp_MPI_BASIN.log
jobcomp_OPENMP_BASIN.log
jobcomp_SERIAL_BASIN.log

sorties de l'execution dans :
mpi_4_BASIN.log
openmp_4_RIVER.log
serial_BASIN.log
```


### gitlab-runner help

```
> gitlab-runner --help
   gitlab-runner [global options] command [command options] [arguments...]
   ex commande exec :
      gitlab-runner --debug --log-format json exec

> gitlab-runner exec --help
    gitlab-runner exec command [command options] [arguments...]
    ex command shell :
       gitlab-runner --debug --log-format json exec shell
       
> gitlab-runner exec shell --help
   gitlab-runner exec shell [command options] [arguments...]
   gitlab-runner exec shell --timeout 7200
```



### Modifications .gitlab-ci.yml

> mpirun.openmpi not found

```
-  CROCO_CI_MPIRUN: "mpirun.openmpi"
---
+  CROCO_CI_MPIRUN: "ccc_mprun -p rome -m work,scratch,store -A gen1140 -T 3600"
  
-  CI_FC: "gfortran"
---
+  CI_FC: "ifort"

```

### Modifications jobcomp\_rvtk.bash

>ifort: command line error: option '-openmp' is not supported. Please use the replacement option '-qopenmp'

`CVTK/common/jobcomp_rvtk.bash`

```
-  FFLAGS1="$FFLAGS1 -openmp"
---
+  FFLAGS1="$FFLAGS1 -qopenmp"
```

pour ifort, les options de compilations du jobcomp_rvtk.bash sont positionnés sur l'optimisation. 
Dans un premier temps je remets nos options sépcifiques (S. Pous) sur IRENE

```
-  FFLAGS1="-O3 -fno-alias -i4 -r8 -fp-model precise"
---
+  FFLAGS1="-check bounds -fpe0 -traceback -g -O0 -ftrapuv -72 -fno-alias -i4 -r8 -fp-model precise -mcmodel=medium"
```


### Modifications comp\_run\_mpi.bash 

`CVTK/test_repro/comp_run_mpi.bash`

```
30c30,31
-  $MPIRUN -np $NBPROCS ./croco_${par1}.exe $CROCOIN > mpi_${NBPROCS}_${TEST_NAME}.log 2>&1  || { echo -e "   $msg2" | tee -a mylog.txt ; echo -e $msg1 ; exit 2 ; }
---
+  $MPIRUN -n $NBPROCS ./croco_${par1}.exe $CROCOIN > mpi_${NBPROCS}_${TEST_NAME}.log 2>&1  || { echo -e "   $msg2" | tee -a mylog.txt ; echo -e $msg1 ; exit 2 ; }
```
                      
### Lancement de gitlab-runner en batch sur IRENE

L'ensemble des tests est très lent. 
La compilation elle même est très lente. Pas de raison à priori Problème d'IRENE en Juillet ou y a t il une raison? 
En tous les cas, la solution est de lancer en batch: 

```
ccc_mprun -p skylake -n 4 -T 14400 -K
```

```
module load gitlab-runner/13.3.0
{ time gitlab-runner exec shell ana_run --timeout 14400 2>&1 |tee listing_IRENE_ALL_ANA_TESTS_DEBUG.txt; } 2>> listing_IRENE_ALL_ANA_TESTS_DEBUG.txt

```

## Installation sur JEANZAY
C. Hourdin - ?? 2022

Installer gitlab-runner (pas de module à disposition!)

## CVTK : Réflexion pour la mise en place sur l'ensemble des Machines

### IDRIS - Jean-Zay

C. Hourdin - 16 Juillet 2022

Echange téléphonique avec la hotline (Rémi Lacroix) - [Mail](./2022_07_16_gitlab-runner_IDRIS_hotline_Remi_Lacroix.html)

Pour des questions de sécurité, pas recommandé car pas de traçabilité des utilisateurs qui commitent s'ils n'ont pas un compte sur Jean-Zay. 
Donc pas de module mis à disposition. 
En pratique l'IDRIS ne va pas policer mais n'encourage pas non plus. 
L'IPSL fait du *trusting* depuis des années, ce qui est une forme d'intégration continue.
A nous d'installer un gitlab-runner et de se limiter à des utilisateurs qui ont un compte sur Jean-Zay. 
De toutes façons l'idée n'est pas de lancer des tests en config réalistes à chaque commit, mais bien de faire une vérification épisodique. 
Une vérifiaction avec CVTK pour la reproductibilité du parallèlisme et de la restartabilité, et une vérification pour s'assurer que les résultats sont préservés entre les 2 versions de code pour chacune de nos configurations (sans doute avec pulsation + ATLAS sur une période suffisament longue (1 mois?) si on constate une dérive sur plusieurs pas de temps).

Faut il demander à l'IFREMER pour DATARMOR ou installer nous même un gitlab-runner?
