Eräajotyöskriptin luominen Roihulle

Eräajotyöskripti sisältää määrittelyt työlle varattavista resursseista sekä komennot, jotka käyttäjä haluaa suorittaa.

Eräajotyöskriptin luominen Roihulle

Eräajotyöskriptin rakenne

Esimerkki eräajotyöskriptistä, jossa käytetään osaa yhden noodin resursseista:

#!/bin/bash
#SBATCH --job-name=my-test          # Job name
#SBATCH --account=<project>         # Billing project, has to be defined!
#SBATCH --partition=small           # Job partition (queue)
#SBATCH --time=00:30:00             # Max. duration of the job
#SBATCH --nodes=1                   # Number of nodes used for the job
#SBATCH --ntasks=1                  # Number of tasks allocated
#SBATCH --cpus-per-task=1           # Number of CPU cores allocated per task
#SBATCH --mem-per-cpu=1000M         # Memory to reserve per CPU core
#SBATCH --output=slurm-%j.out       # Standard output of the job script
##SBATCH --mail-type=BEGIN          # Uncomment to enable mail

module load myprog/1.2.3            # Load required modules

srun myprog -i input -o output      # Run program using requested resources

Ensimmäinen rivi #!/bin/bash kertoo, että tiedosto tulee tulkita Bash-skriptinä.

Rivit, jotka alkavat merkinnällä #SBATCH, ovat eräajojärjestelmän argumentteja (direktiivejä). Näissä esimerkeissä käytetään vain pientä osaa valinnoista. Luettelo kaikista mahdollisista valinnoista löytyy Slurmin dokumentaatiosta.

#SBATCH-valinnan yleinen syntaksi on:

#SBATCH --option-name=argument

Esimerkkimme ensimmäinen rivi asettaa työn nimen:

#SBATCH --job-name=my-test

Työn nimeksi tulee my-test. Sitä voidaan käyttää työn tunnistamiseen jonossa ja muissa listauksissa.

Työn laskutusprojekti asetetaan valinnalla --account:

#SBATCH --account=<project>

Korvaa <project> projektisi Unix-ryhmällä. Löydät sen MyCSC:stä välilehdeltä Projects. Lisätietoja laskutuksesta.

Muista määrittää laskutusprojekti

Laskutusprojektin argumentti on pakollinen. Jos sitä ei aseteta, seurauksena on virhe:

sbatch: error: AssocMaxSubmitJobLimit
sbatch: error: Batch job submission failed: Job violates accounting/QOS policy (job submit limit, user's size and/or time limits)

Osio (jono) on asetettava työn vaatimusten mukaisesti. Esimerkiksi:

#SBATCH --partition=small

Käytettävissä olevat osiot

Katso käytettävissä olevat eräajotyöosiot.

Ajoaikavaraus asetetaan valinnalla --time:

#SBATCH --time=00:30:00

Aika annetaan muodossa hours:minutes:seconds (vaihtoehtoisesti days-hours:minutes:seconds). Enimmäisajoaika riippuu valitusta jonosta. Kun aikavaraus päättyy, työ lopetetaan riippumatta siitä, onko se valmistunut vai ei, joten aikavarauksen tulee olla riittävän pitkä. Huomaa, että työ kuluttaa laskutusyksiköitä (BUs) todellisen ajoaikansa mukaan.

Työssä käytettävien noodien määrä voidaan asettaa valinnalla --nodes:

#SBATCH --nodes=1

Tämä ei ei tarkoita, että noodin tai noodien kaikki resurssit varattaisiin, vaan että tässä tapauksessa kaikki tehtävät ja CPU-ytimet allokoidaan yhdeltä noodilta. Yleisesti tässä voidaan antaa myös väli --nodes=<minnodes>-<maxnodes> määrittämään niiden noodien hajonta, joille resurssit allokoidaan.

Työlle allokoitujen tehtävien määrä voidaan asettaa valinnalla --ntasks:

#SBATCH --ntasks=1

Allokoituja tehtäviä voidaan käyttää työskriptissä eri tavoin, tavallisimmin MPI-prosesseina.

Työlle allokoitujen CPU-ytimien määrä tehtävää kohden voidaan asettaa valinnalla --cpus-per-task:

#SBATCH --cpus-per-task=1

Valintojen --ntasks ja --cpus-per-task tulo määrittää työlle allokoitujen CPU-ytimien kokonaismäärän.

Kullekin CPU-ytimelle varattavan muistin määrä asetetaan valinnalla --mem-per-cpu:

#SBATCH --mem-per-cpu=1000M

Jos ohjelma ylittää varatun muistimäärän, työ lopetetaan.

Työskriptin vakiotulostetiedosto asetetaan valinnalla --output:

#SBATCH --output=slurm-%j.out

Vakiotuloste tarkoittaa kaikkea tulostusta, joka näkyisi komentotulkissa, jos skriptissä luetellut komennot suoritettaisiin interaktiivisessa komentotulkissa. Tässä %j on jobid:n korvaussymboli, joten tuloste menee tiedostoon slurm-<slurm-jobid>.out. Oletuksena tämä tiedosto kerää myös vakiovirheen, mutta vakiovirheelle on mahdollista määrittää eri tiedosto valinnalla --error=<filename_pattern>.

Käyttäjälle voidaan lähettää sähköposti-ilmoitus, kun työ alkaa, käyttämällä valintaa --mail-type

##SBATCH --mail-type=BEGIN          # Uncomment to enable mail

Muita hyödyllisiä argumentteja (useat argumentit erotetaan pilkulla) ovat END ja FAIL. Oletuksena sähköposti lähetetään CSC-käyttäjätiliisi liitettyyn sähköpostiosoitteeseen. Tämän voi ohittaa valinnalla --mail-user=.

Sähköposti-ilmoitukset eivät ole vielä käytössä

Sähköposti-ilmoitukset eivät ole vielä käytössä, eikä valinta --mail-type tee tällä hetkellä mitään.

Kun kaikki tarvittavat resurssit on määritelty eräajotyöskriptissä, määritä tarvittava ympäristö lataamalla sopivat moduulit. Huomaa, että jotta moduulit ovat käytettävissä eräajotöissä, ne on ladattava eräajotyöskriptissä. Lisätietoja ympäristömoduuleista.

module load myprog/1.2.3

Lopuksi käynnistämme sovelluksen pyydetyillä resursseilla komennolla srun:

srun myprog -i input -o output

Sarjalliset ja jaetun muistin eräajot

Sarjalliset ja jaetun muistin työt on ajettava yhden laskentanoodin sisällä. Siksi töitä rajoittavat noodeissa käytettävissä olevat laitteistomääritykset. Katso käytettävissä olevat noodityypit ja ytimien määrä noodia kohden tältä sivulta.

#SBATCH-valintaa --cpus-per-task käytetään määrittämään laskentaytimien määrä, jota eräajotyön tehtävä käyttää. Valinta --nodes=1 varmistaa, että kaikki varatut ytimet sijaitsevat samalla noodilla, ja --ntasks=1 osoittaa kaikki varatut laskentaytimet samalle tehtävälle.

Säiepohjaisissa töissä muistivaraukseen suositellaan valintaa --mem. Tämä valinta määrittää tarvittavan muistimäärän noodia kohden. Huomaa, että jos käytät sen sijaan valintaa --mem-per-cpu, työn kokonaismuistipyyntö on pyydetty muistimäärä CPU-ydintä kohden (--mem-per-cpu) kerrottuna varattujen ytimien määrällä (--cpus-per-task). Jos siis muutat ytimien määrää, tarkista myös, että muistivaraus on sopiva.

Tyypillisesti tehokkain käytäntö on sovittaa varattujen ytimien määrä (--cpus-per-task) sovelluksen käyttämien säikeiden tai prosessien määrään. Tarkista kuitenkin aina sovelluskohtaiset tiedot.

Jos sovelluksessa on komentorivivalinta säikeiden/prosessien/ytimien määrän asettamiseen, sitä tulee aina käyttää, jotta ohjelmisto toimii odotetusti. Jotkin sovellukset käyttävät oletuksena vain yhtä ydintä, vaikka useampia olisi varattu.

Toiset sovellukset voivat yrittää käyttää kaikkia noodin ytimiä, vaikka vain osa niistä olisi varattu. Ympäristömuuttujaa $SLURM_CPUS_PER_TASK, joka sisältää valinnan --cpus-per-task arvon, voidaan käyttää numeron sijasta määritettäessä käytettävien ytimien määrää. Tämä on hyödyllistä, koska komentoa ei tarvitse muuttaa, jos --cpus-per-task-arvoa muutetaan myöhemmin.

Lopuksi käytä ympäristömuuttujaa OMP_NUM_THREADS asettamaan sovelluksen käyttämien säikeiden määrä. Esimerkiksi

export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK:-1}

(huomaa syntaksi :-1, joka asettaa säikeiden määräksi 1, jos --cpus-per-task-valintaa ei ole asetettu).

MPI-pohjaiset eräajot

MPI-töissä jokaisella tehtävällä on oma muistiallokaatio. Siksi tehtävät voidaan jakaa useille noodeille.

Kun ajetaan töitä osittaisella noodilla (small-osio), aseta MPI-tehtävien määrä seuraavasti:

#SBATCH --partition=small
#SBATCH --ntasks=<number_of_mpi_tasks>

Kun ajetaan täysillä noodeilla (medium- ja large-osiot), suositellaan, että valintaa --ntasks ei käytetä, vaan sen sijaan asetetaan --nodes, --ntasks-per-node ja --cpus-per-task:

#SBATCH --partition=medium
#SBATCH --nodes=<number_of_full_nodes>
#SBATCH --ntasks-per-node=384 --cpus-per-task=1  # The product should be 384

Tämä varmistaa ennakoitavan prosessien jakautumisen ja CPU-sidonnan noodin sisällä, katso suorituskyvyn tarkistuslista.

Aseta sekä --ntasks-per-node että --cpus-per-task täysille noodeille

On suositeltavaa asettaa sekä --ntasks-per-node että --cpus-per-task niin, että niiden tulo on 384 parhaan suorituskyvyn saavuttamiseksi. Katso huomiot täysien noodien vajaakäytöstä.

MPI-ohjelmien ajaminen

MPI-ohjelmia ei pidä käynnistää komennoilla mpirun tai mpiexec. Käytä sen sijaan komentoa srun.
MPI-moduuli on ladattava eräajotyöskriptissä, jotta ohjelma toimii oikein.

Hybridieräajot (esim. MPI+OpenMP)

Hybriditöissä kullekin tehtävälle allokoidaan useita ytimiä. Kukin tehtävä käyttää sitten muuta rinnakkaistusta kuin MPI:tä työn tekemiseen. Yleisin strategia on, että jokainen MPI-tehtävä käynnistää useita säikeitä OpenMP:n avulla. Jos haluat pyytää enemmän ytimiä MPI-tehtävää kohden, käytä argumenttia --cpus-per-task. Oletusarvo on yksi ydin tehtävää kohden.

Kun ajetaan täysillä noodeilla, on suositeltavaa kirjoittaa valinnat --ntasks-per-node ja --cpus-per-task samalle #SBATCH-riville selkeyden vuoksi:

#SBATCH --partition=medium
#SBATCH --nodes=<number_of_full_nodes>
#SBATCH --ntasks-per-node=192 --cpus-per-task=2  # The product should be 384
#SBATCH --ntasks-per-node=96  --cpus-per-task=4  # The product should be 384

Syynä on se, että nämä valinnat liittyvät toisiinsa siten, että niiden tulon tulee aina olla 384, jotta kaikki noodilla käytettävissä olevat CPU-ytimet tulevat käyttöön. Voit kommentoida toisen riveistä pois testataksesi sovelluksellesi optimaalista ajokonfiguraatiota, katso suorituskyvyn tarkistuslista.

Tehtävien määrän ja tehtävää kohden varattujen ytimien optimaalinen suhde vaihtelee ohjelman ja työn syötteen mukaan. Oikean yhdistelmän löytämiseksi sovelluksellesi tarvitaan testausta. Esimerkkejä löytyy sovelluksille CP2K ja NAMD.

Säikeet tehtävää kohden hybridi-MPI+OpenMP-töissä

Aseta OpenMP-säikeiden määrä MPI-tehtävää kohden eräajoskriptissäsi käyttämällä ympäristömuuttujia OMP_NUM_THREADS ja SLURM_CPUS_PER_TASK:

export OMP_NUM_THREADS=${SLURM_CPUS_PER_TASK:-1}

Suurimuistiset työt

Roihu-CPU:ssa on suurimuistisia CPU-noodeja, joissa on 6 TiB muistia. Nämä noodit ovat käytettävissä osioissa hugemem ja hugemem_longrun. Katso noodien tekniset tiedot tältä sivulta.

Näiden noodien käyttö on samanlaista kuin muiden Roihu-CPU-noodien, mutta huomaa, että näissä noodeissa on eri prosessori. Erityisesti näissä noodeissa on yhteensä 128 CPU-ydintä noodia kohden. Tämä tarkoittaa, että jos ajetaan täydellä noodilla hugemem-osioissa, valintojen --ntasks-per-node ja --cpus-per-task tulon tulee olla 128 parhaan suorituskyvyn saavuttamiseksi:

#SBATCH --partition=hugemem
#SBATCH --nodes=1
#SBATCH --ntasks-per-node=128 --cpus-per-task=1  # The product should be 128
#SBATCH --ntasks-per-node=64  --cpus-per-task=2  # The product should be 128
#SBATCH --ntasks-per-node=32  --cpus-per-task=4  # The product should be 128

GPU-työt

Jokaisessa Roihun GPU-noodissa on neljä Nvidia GH200 -superpiiriä. GPU:t ovat käytettävissä gpu*-osioissa. Katso noodien tekniset tiedot tältä sivulta.

Resurssien allokointi perustuu täysiin GH200-GPU:ihin osioissa gputest, gpumedium ja gpularge, ja GPU:t voidaan pyytää seuraavasti:

#SBATCH --partition=gpumedium
#SBATCH --gres=gpu:gh200:<number_of_gpus_per_node>

Huomaa, että --gres-varaus tehdään noodikohtaisesti. GPU-noodia kohden on 4 GPU:ta.

Tietoa gpuinteractive-osiosta

MIG:eja ei ole vielä konfiguroitu.

gpuinteractive-osiossa GH200-GPU:t on jaettu pienempiin Multi-Instance GPU (MIG) -instansseihin. Jokaisella MIG:llä on yksi seitsemäsosa laskentakapasiteetista ja yksi kahdeksasosa GPU-muistikapasiteetista verrattuna täyteen GH200-GPU:hun, mikä tarjoaa 12 GiB GPU-muistia.

Työlle käytettävissä olevien CPU-ytimien enimmäismäärä ja CPU-muistin määrä ovat pienemmät kuin osiossa, jossa on täydet GPU:t. Nämä rajat dokumentoidaan, kun MIG-konfiguraatio on viimeistelty.

Voit varata enintään yhden GPU-siivun työtä kohden. GPU-siivuja pyydetään seuraavilla valinnoilla::

#SBATCH --partition=gpuinteractive
#SBATCH --gres=gpu:gh200_xxx:1

GPU-visualisointityöt

Roihussa on visualisointinoodeja, joissa on Nvidia L40 -GPU:t. Nämä noodit ovat käytettävissä vizinteractive-osiossa. Katso noodien tekniset tiedot tältä sivulta.

Nämä noodit voidaan pyytää seuraavasti:

#SBATCH --partition=vizinteractive
#SBATCH --gres=gpu:l40:<number_of_gpus_per_node>

Huomaa, että --gres-varaus tehdään noodikohtaisesti. GPU-noodia kohden on 2 GPU:ta.

Lisäresurssit eräajotöissä

Paikallinen väliaikaistallennustila

Kaikilla Roihun noodeilla on töiden käytettävissä paikallista tallennustilaa (NVMe). Paikallisen tallennustilan käyttöä suositellaan I/O-intensiivisille sovelluksille eli töille, jotka esimerkiksi lukevat ja kirjoittavat paljon pieniä tiedostoja. Katso lisätiedot.

Paikallinen väliaikaistallennustila on käytettävissä jokaiselle työlle ilman lisälaskutusta. Kiintiö asetetaan käyttäjäkohtaisesti, joten noodilla käytettävissä oleva tila ei riipu töiden määrästä eikä varatuista resursseista:

Roihu-CPU:n jaetut noodit (small, interactive ja test -osiot) sisältävät 20 GiB:n kiintiön
Roihu-CPU:n täydet noodit (medium ja large -osiot) sisältävät 600 GiB:n kiintiön
Roihu-GPU-noodit sisältävät 150 GiB:n kiintiön

Käytä ympäristömuuttujaa $TMPDIR eräajotyöskripteissäsi päästäksesi käsiksi kunkin noodin paikalliseen väliaikaistallennustilaan. Esimerkiksi suuren aineistopaketin purkamiseen paikalliseen tallennustilaan:

tar xf my-large-dataset.tar.gz -C $TMPDIR

Muista palauttaa datasi

Työllesi varattu paikallinen tallennustila tyhjennetään työn päätyttyä. Jos siis kirjoitat dataa paikalliselle levylle työsi aikana, muista siirtää kaikki säilytettäväksi haluamasi tiedot jaetulle levyalueelle työn lopussa. Erityisesti datan siirtämiseen käytettävät komennot on annettava eräajotyöskriptissä, koska et enää pääse paikalliseen tallennustilaan eräajotyön päätyttyä. Esimerkiksi joidenkin tulostetietojen kopioimiseksi takaisin hakemistoon, josta eräajotyö lähetettiin:

mv $TMPDIR/my-important-output.log $SLURM_SUBMIT_DIR

Hajautettu tallennustila

Roihun uutena ominaisuutena on mahdollista pyytää paikallisia levyosliitoksia keskitetystä nopeiden tallennusresurssien poolista. Tämä nopea tallennuskapasiteetti tarjotaan verkon yli, ja se näkyy paikallisena scratch-tilana Slurm-työn sisältä. Sitä voidaan pyytää kaikissa osioissa, mukaan lukien jaetun noodin työt.

Pyydä tätä paikallista tallennustilaa seuraavalla lipulla eräajoskriptissä:

#SBATCH --bb="#BB_LUA SBF storagesize=<local_storage_space> path=/sbf/data"

Esimerkiksi 100 GiB:n tallennustilan pyytäminen:

#SBATCH --bb="#BB_LUA SBF storagesize=100G path=/sbf/data"

Tämän jälkeen tämä tallennustila on käytettävissä polussa /sbf/data työskriptin aikana. Polun on alettava merkkijonolla /sbf/. Jokainen työ saa oman yksityisen liitoksensa, joten useat samalla noodilla olevat työt voivat käyttää samaa polkua.

Täysien noodien vajaakäyttö Roihu-CPU:ssa

Jos sovellus tarvitsee enemmän muistia ydintä kohden kuin täydellä noodilla on käytettävissä (2 GB / ydin), on mahdollista käyttää myös vain osaa noodin ytimistä. Lisäksi jos sovellus on muistiväylärajoitteinen, muistiväylän kaistanleveyttä ja sovelluksen suorituskykyä voidaan parantaa käyttämällä vain yhtä ydintä NUMA-aluetta tai L3-välimuistia kohden (katso Roihun tekninen kuvaus lisätietoja varten. Huomaa kuitenkin, että laskutus perustuu aina täysiin noodeihin.

Kun noodeja käytetään vajaasti, tulee aina asettaa --ntasks-per-node=X ja --cpus-per-task=Y siten, että X * Y = 384, myös puhtaissa MPI-töissä. Oletuksena Slurm hajauttaa MPI-tehtävät --cpus-per-task-välein, eli asetuksella --cpus-per-task=16 MPI-tehtävä 0 sidotaan CPU-ytimeen 0 ja MPI-tehtävä 1 sidotaan CPU-ytimeen 15 jne. Muistikaistanleveys (ja sovelluksen suorituskyky) on paras silloin, kun tehtävät suoritetaan mahdollisimman hajautetuilla ytimillä. Esimerkiksi, jotta voidaan käyttää 32 GB / ydin, voidaan ajaa vain 24 tehtävällä noodia kohden seuraavasti:

...
#SBATCH --ntasks-per-node=24 --cpus-per-task=16  # The product should be 384

module load myprog/1.2.3
export OMP_NUM_THREADS=1

srun myprog -i input -o output

Hybridisovelluksissa tulee käyttää OpenMP-ajonaikaisen ympäristön muuttujaa OMP_PROC_BIND OpenMP-säikeiden sijoitteluun. Esimerkiksi, jotta voidaan ajaa yksi MPI-tehtävä NUMA-aluetta kohden ja yksi OpenMP-säie L3-välimuistia kohden, voidaan asettaa:

...
#SBATCH --ntasks-per-node=8 --cpus-per-task=48  # The product should be 384

export OMP_NUM_THREADS=3
export OMP_PROC_BIND=spread

module load myprog/1.2.3

srun myprog -i input -o output

Small-osion käyttäminen ei-rinnakkaiseen esi- tai jälkikäsittelyyn

Monissa tapauksissa suuret laskentatehtävät sisältävät esi- tai jälkikäsittelyvaiheita, jotka eivät pysty hyödyntämään rinnakkaislaskentaa. Näissä tapauksissa suositellaan, että tehtävä mahdollisuuksien mukaan jaetaan useiksi ketjutetuiksi eräajotöiksi ja että ei-rinnakkainen käsittely suoritetaan Roihun small-osiossa. Small-osiossa työt voivat varata vain muutaman ytimen, jolloin ei-rinnakkaiset tehtävät voidaan suorittaa ilman resurssien tuhlausta.

Oletetaan esimerkiksi, että haluamme jälkikäsitellä aiemman työn output-tiedoston. Jälkikäsittelykomento python post-proc.py output käyttää vain sarjallista laskentaa ja vaatii noin 40 minuuttia sekä 3 GB muistia. Sen sijaan, että jälkikäsittely sisällytettäisiin päätyöhön, on järkevää suorittaa se erillisenä työnä small-osiossa kuten alla olevassa esimerkissä. Lisäksi määrittämällä --dependency=afterok:<slurm-jobid> työn annetaan käynnistyä vasta, kun aiemmin lähetetty työ on valmistunut onnistuneesti. Tässä <slurm-jobid> korvataan sen eräajotyön tunnistenumerolla, joka tuottaa output-tiedoston (saat tunnistenumeron, kun lähetät työn).

#!/bin/bash
#SBATCH --job-name=post-process-my-test
#SBATCH --account=<project>
#SBATCH --time=00:50:00
#SBATCH --partition=small
#SBATCH --nodes=1
#SBATCH --ntasks=1
#SBATCH --cpus-per-task=1
#SBATCH --mem-per-cpu=4G
#SBATCH --dependency=afterok:<slurm-jobid>

python post-proc.py output

Suurten määrien pieniä ei-MPI-töitä suorittaminen

Roihussa HyperQueue-meta-ajastinta voidaan käyttää suurten määrien pieniä ei-MPI-töitä käsittelyyn.