julia

Cette page explique comment créer un environement, ajouter des paquets et lancer un code Julia avec sbatch sûr Olympe

Versions installées sur Olympe = 1.5.3, 1.7.2 et 1.9.3

Pour pouvoir installer des paquets chaque utilisateur doit créer ses propres environnements en local.

Il est aussi fortement recommandé d'utiliser des environnements spécifiques à chaque projet pour assurer la reproductibilité et réduire au minimum les dépendances des paquets. Julia dispose d'un bon gestionnaire de paquets intégré pour simplifier les choses.

Ce site montre la procedure pour créer un environnement en local et ajouter des paquets.

D'abord, charger une des version Julia accessibles, par exemple:

module load julia/1.9.3

Le gestionnaire de paquets

Pkg est le gestionnaire de paquets intégré de Julia et gère des opérations telles que l'ajout, la mise à jour et la suppression de paquets. Un bonne practique c'est démarre Julia depuis le répertoire où ce trouve le code du projet. Pour accéder au REPL de Pkg, tapez simplement le crochet droit ] à partir du REPL de Julia.

julia> ]

le REPL change de couleur, passant du vert (julia) au bleu (pkg). Le préfixe (@v1.9) indique que je suis dans l'environnement par défaut, utilisant la version 1.9.x de Julia.

Générer un environnement

Pour générer un nouvel environnement de projet, tapez simplement "generate" suivi du nom de votre projet.

(v1.9) pkg> generate test

Un répertoire d'environnement sera créé dans votre répertoire de travail actuel. Dans cet environnement, les fichiers Project.toml et Manifest.toml contiennent les spécifications des paquets et de leurs versions disponibles dans votre environnement. Cependant, l'environnement par défaut (@v1.9) reste actif.

Activer un environnement

Pour activer votre nouvel environnement de projet, tapez "activate" suivi du nom de votre projet (répertoire).

pkg> activate test

Le préfixe passe de (@v1.9) à (test), indiquant que le projet "test" est actif. En tapant "status", vous pouvez voir que le projet est encore vide (c'est-à-dire aucun paquet ajouté pour le moment).

Ajouter et mettre à jour des paquets

Ajouter des paquets se fait à l'aide de la commande "add". Par défaut, la dernière version du paquets est ajoutée. Par exemple nous ajouterons le package "CSV" à notre environnement.

(test) pkg> add CSV

Les fichiers Project.toml et Manifest.toml sont mis à jour pour incluire CSV.

Maintenant, nous allons ajouter une version spécifique du package "ScikitLearn". Dans ce cas, la version 0.6.3 en tapant la commande

(test) pkg> add ScikitLearn@0.6.3

Pour mettre à jour tous les packages dans notre environnement de projet, utilisez la commande "update".

De la même manière, vous pouvez supprimer des packages en utilisant la commande "remove".

Lorsque vous souhaitez utiliser un notebook Pluto ou Jupyter pour votre projet, ajoutez simplement les packages correspondants à votre environnement de projet en utilisant "add Pluto" ou "add IJulia".

Quitter le gestionnaire de paquets

Avec la touche <backspace> ou la combinaison de touches <ctrl> + c.

Activation d'un Environnement au Démarrage de Julia

Dans le repertoire où il y a les fichiers Project.toml et Manifest.toml lancer la commande

julia --project=.

pour activer l'environnement.

Pour vérifie l'état de l'environnement à partir du REPL de Pkg avec "status"

pkg> status

Exemple avec l'utilisation du paquet CUDA

module purge
module load nvidia/nvhpc/22.1-cuda-11.5-ompi405-majslurm
module load julia/1.9.3

On lance Julia

$ julia

après on se place dans le gestionnaire de paquets et on crée l'environnement et on l'active

julia> ]
(v1.9) pkg> generate cuda
(cuda) pkg> activate cuda

On install le paquet CUDA et on sort du gestionnaire

(cuda) pkg> add CUDA
(cuda) pkg> <backspace>
julia >

Après on peut faire un test pour verifier que tout fonctionne.

On alloue un noeud avec des GPUs avec salloc

$ salloc -N 1 -n 36 --gres=gpu:1 --time=01:00:00 --mem=20G --qos=volta

la commande va nous donner le nom du noeud reservé et on fait ssh vers le noeud:

$ ssh olympevoltaX

on se possitione où se trouve l'environnement qu'on a crée, on relance julia et on active l'environement:

julia> ]
(v1.9) pkg>
(v1.9) pkg> activate cuda
(cuda) pkg> ]

et on lance l'exemple simple de CUDA.jl

julia> using CUDA
using Test

N = 2^20
x_d = CUDA.fill(1.0f0, N)  # a vector stored on the GPU filled with 1.0 (Float32)
y_d = CUDA.fill(2.0f0, N)  # a vector stored on the GPU filled with 2.0

y_d .+= x_d
@test all(Array(y_d) .== 3.0f0)

Si tout se passe bien à la sortie on verra:

Test Passed

Lancer Julia avec sbatch :

Le module CUDA.jl est intallé, vous pouvez donc utiliser les GPUs avec Julia.

Le script sbatch suivant construit un script Julia et le lance avec l'environement defini par --project=<path>

Dans ce exemple c'est l'environnement qu'il y a au même repertoire où le script sbatch est lance ("--project=.")

#! /bin/bash

#SBATCH -J "Essai julia gpu"
#SBATCH -N 1
#SBATCH -n 9
#SBATCH --gres=gpu:1
#SBATCH --mem=10G

cat <<EOF >essai.jl
using CUDA
using Pkg
println(Pkg.status())
CUDA.versioninfo()
[CUDA.capability(dev) for dev in CUDA.devices()]
println("au revoir")
EOF

module purge
module load julia/1.9.3
julia --project=. essai.jl

Vous pouvez :

  • copier-coller ce script dans julia.bash
  • l’exécuter par sbatch julia.bash
  • Après quelques secondes, un fichier slurm-12345.out devrait apparaître, il devrait se terminer par :
1 device:
  0: Tesla V100-SXM2-16GB (sm_70, 15.357 GiB / 15.782 GiB available)
au revoir

julia et la MKL

cf. https://github.com/JuliaLinearAlgebra/MKL.jl

Le package LinearAlgebra utilise la mkl :

julia> using LinearAlgebra
julia> BLAS.vendor()
:mkl

Plus d'information sur

https://pkgdocs.julialang.org/v1/

Espace utilisateurs/Doc technique Olympe/Les logiciels installés

Voir aussi

FAQ

Questions fréquentes et messages d'erreurs