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 solmun 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 Slurm-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) täytyy asettaa työn vaatimusten mukaisesti. Esimerkiksi:

#SBATCH --partition=small

Käytettävissä olevat osiot

Katso käytettävissä olevat eräajotöiden osiot.

Aikavaraus asetetaan valinnalla --time:

#SBATCH --time=00:30:00

Aika annetaan muodossa hours:minutes:seconds (vaihtoehtoisesti days-hours:minutes:seconds). Enimmäiskesto 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 solmujen määrä voidaan asettaa valinnalla --nodes:

#SBATCH --nodes=1

Tämä ei ei tarkoita, että solmun tai solmujen kaikki resurssit varattaisiin, vaan tässä tapauksessa kaikki tehtävät ja CPU-ytimet allokoidaan yhdestä solmusta. Yleisesti tässä voidaan antaa myös väli --nodes=<minnodes>-<maxnodes> määrittämään niiden solmujen hajonta, joista 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 työn tunnisteen korvausmerkki, joten tuloste kirjoitetaan 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 työn alkaessa 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 täytyy ladata 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äajotyöt

Sarjalliset ja jaetun muistin työt täytyy ajaa yhden laskentasolmun sisällä. Siksi töitä rajoittavat solmuissa उपलब्ध olevat laitteistomääritykset. Katso käytettävissä olevat solmutyypit ja solmukohtainen ydinmäärä 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 samassa solmussa, 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 solmua kohden. Huomaa, että jos käytät sen sijaan valintaa --mem-per-cpu, työn kokonaismuistipyyntö on CPU-ydintä kohden pyydetty muistimäärä (--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 solmun ytimiä, vaikka vain osa niistä olisi varattu. Ympäristömuuttujaa $SLURM_CPUS_PER_TASK, joka sisältää --cpus-per-task-valinnan 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äajotyöt

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

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

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

Kun ajetaan täydellä solmulla (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 solmun sisällä, katso suorituskyvyn tarkistuslista.

Aseta sekä --ntasks-per-node että --cpus-per-task täydelle solmulle

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

MPI-ohjelmien ajaminen

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

Hybridieräajotyöt (esim. MPI+OpenMP)

Hybriditöissä jokaiselle tehtävälle allokoidaan useita ytimiä. Kukin tehtävä käyttää sitten työn suorittamiseen jotakin muuta rinnakkaistusta kuin MPI:tä. Yleisin strategia on, että jokainen MPI-tehtävä käynnistää useita OpenMP-säikeitä. 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äydellä solmulla, 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 solmussa उपलब्ध olevat CPU-ytimet saadaan 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äikeitä tehtävää kohden hybridi MPI+OpenMP -töissä

Aseta OpenMP-säikeiden määrä MPI-tehtävää kohden eräskriptissä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-solmuja, joissa on 6 TiB muistia. Nämä solmut ovat käytettävissä osioissa hugemem ja hugemem_longrun. Katso solmujen tekniset tiedot tältä sivulta.

Näiden solmujen käyttö on samanlaista kuin muiden Roihu-CPU-solmujen, mutta huomaa, että näissä solmuissa on eri prosessori. Erityisesti näissä solmuissa on yhteensä 128 CPU-ydintä solmua kohden. Tämä tarkoittaa, että jos ajetaan täydellä solmulla 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-solmussa on neljä Nvidia GH200 -superpiiriä. GPU:t ovat käytettävissä gpu*-osioissa. Katso solmujen 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 on solmukohtainen. GPU-solmua 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) -osiin. Jokaisella MIG:llä on täällä yksi XXX-osa täyden GH200-GPU:n laskenta- ja muistokapasiteetista. Jokaista GPU-osiota kohden voit varata enintään XXX CPU-ydintä, ja jokaista GPU-osiota kohden työlle allokoidaan XXX GiB CPU-muistia. Huomaa myös, että voit varata enintään yhden GPU-osion työtä kohden. GPU-osiot ovat käytettävissä seuraavilla valinnoilla:

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

GPU-visualisointityöt

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

Nämä solmut voidaan pyytää seuraavasti:

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

Huomaa, että --gres-varaus on solmukohtainen. GPU-solmua kohden on 2 GPU:ta.

Lisäresurssit eräajotöissä

Paikallinen väliaikaistallennustila

Kaikissa Roihun solmuissa 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 solmulla उपलब्ध oleva tila ei riipu töiden määrästä tai varatuista resursseista:

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

Käytä ympäristömuuttujaa $TMPDIR eräajotyöskripteissäsi käyttääksesi kunkin solmun paikallista väliaikaistallennustilaa. Esimerkiksi suuren aineistopaketin purkaminen paikalliseen tallennustilaan:

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

Muista ottaa data talteen

Työllesi varattu paikallinen tallennustila tyhjennetään työn päätyttyä. Jos siis kirjoitat dataa paikalliselle levylle työn aikana, muista siirtää kaikki säilytettäväksi haluamasi yhteiselle levyalueelle työn lopussa. Erityisesti datan siirtämiseen tarvittavat komennot on annettava eräajotyöskriptissä, koska et voi enää käyttää paikallista tallennustilaa eräajotyön päätyttyä. Esimerkiksi joidenkin tulostedatan kopioiminen takaisin hakemistoon, josta eräajotyö lähetettiin:

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

Nopea paikallinen scratch-tallennustila

Roihun uutena ominaisuutena on mahdollista pyytää paikallisia levyasemaliitoksia keskitetystä nopeiden tallennusresurssien poolista. Tämä nopea tallennuskapasiteetti tarjotaan verkon yli, ja se näkyy Slurm-työn sisältä paikallisena scratch-tilana.

Nämä resurssit on pyydettävä yhdessä valinnan --exclusive kanssa

Tällä hetkellä tätä tallennustilaa voi pyytää vain töille, jotka käyttävät täysiä solmuja, eli jotka lähetetään lipulla --exclusive. Tällä hetkellä, jos et määritä tätä lippua, työsi epäonnistuu, mutta se merkitään tilaan "CANCELLED by 350", eikä käytettävissä ole stdout- tai stderr-lokeja. Tämän pitäisi korjaantua, kun jaettujen solmujen töiden tuki saapuu vuoden 2026 kolmannella neljänneksellä.

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

#SBATCH --exclusive
#SBATCH --bb="#BB_LUA SBF storagesize=<local_storage_space> path=/run/sbb/<username>"

Esimerkiksi 100 GiB:n tallennustilan pyytäminen (muista päivittää <username> käyttäjätunnukseksesi sbatch-otsakkeessa):

#SBATCH --exclusive
#SBATCH --bb="#BB_LUA SBF storagesize=100G path=/run/sbb/<username>"

Tämän jälkeen tämä tallennustila on käytettävissä polussa /run/sbb/$USER työskriptin aikana.

Täysien solmujen alikäyttö Roihu-CPU:ssa

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

Kun solmuja alikäytetään, 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. Muistin kaistanleveys (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ä solmua 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ömuuttujan OMP_PROC_BIND 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ä jos mahdollista, tehtävä 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, se on järkevää suorittaa erillisenä työnä small-osiossa kuten alla olevassa esimerkissä. Lisäksi määrittämällä --dependency=afterok:<slurm-jobid> työ saa 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 voidaan käyttää HyperQueue -meta-ajastinta suurten määrien pienten ei-MPI-töiden käsittelyyn.