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 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äajotöiden osiot.

Suoritusajan varaus asetetaan valinnalla --time:

#SBATCH --time=00:30:00

Aika annetaan muodossa hours:minutes:seconds (vaihtoehtoisesti days-hours:minutes:seconds). Enimmäissuoritusaika 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 suoritusajan mukaan.

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

#SBATCH --nodes=1

Tämä ei ei tarkoita, että kaikki solmun tai solmujen 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, kuinka monen solmun alueelle resurssit voidaan allokoida.

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 ohjataan 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 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äajotyöt

Sarjalliset ja jaetun muistin työt on ajettava yhden laskentasolmun sisällä. Siksi töitä rajoittavat solmuissa käytettävissä olevat laitteistoresurssit. 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 batch-työn tehtävän käyttämien laskentaytimien määrä. 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). Siksi, jos 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ä tulisi aina käyttää, jotta ohjelmisto toimii odotetusti. Jotkin sovellukset käyttävät oletuksena vain yhtä ydintä, vaikka niitä olisi varattu enemmän.

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ää 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ä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äysillä solmuilla (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äysille solmuille

On suositeltavaa asettaa sekä --ntasks-per-node että --cpus-per-task niin, että niiden tulo on 384 parhaan suorituskyvyn saavuttamiseksi. Katso huomiot täysien solmujen 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äajotyöt (esim. MPI+OpenMP)

Hybriditöissä kullekin tehtävälle allokoidaan useita ytimiä. Kukin tehtävä käyttää sitten jotakin muuta rinnakkaistusta kuin MPI:tä työn suorittamiseen. 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ä solmuilla, on selkeyden vuoksi suositeltavaa kirjoittaa valinnat --ntasks-per-node ja --cpus-per-task samalle #SBATCH-riville:

#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 käytettävissä 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 batch-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-konfiguraatioita ei ole vielä määritetty.

Osiossa gpuinteractive GH200-GPU:t on pilkottu pienemmiksi Multi-Instance GPU (MIG) -instansseiksi. Jokaisella MIG-instanssilla on yksi seitsemäsosa laskentakapasiteetista ja yksi kahdeksasosa täyden GH200-GPU:n GPU-muistikapasiteetista, eli 12 GiB GPU-muistia.

Työlle käytettävissä olevien CPU-ytimien enimmäismäärä ja CPU-muistin määrä ovat pienemmät kuin osioissa, joissa käytetään täysiä GPU:ita. 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 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öille 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 käytettävissä 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 kiintiön
Roihu-CPU:n täydet solmut (medium ja large -osiot) sisältävät 600 GiB kiintiön
Roihu-GPU-solmut sisältävät 150 GiB kiintiön

Käytä ympäristömuuttujaa $TMPDIR eräajotyöskripteissäsi käyttääksesi kunkin solmun paikallista väliaikaistallennustilaa. 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ä. Siksi, jos kirjoitat dataa paikalliselle levylle työn 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 voi enää käyttää paikallista tallennustilaa 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 levyasennuksia keskitetystä nopeiden tallennusresurssien poolista. Tämä nopea tallennuskapasiteetti tarjotaan verkon yli, ja se näkyy Slurm-työn sisältä paikallisena scratch-tilana.

Hajautettu tallennustila on tällä hetkellä käytettävissä vain täyden solmun töissä

Tällä hetkellä tätä tallennustilaa voidaan pyytää vain, jos olet laskentasolmun ainoa käyttäjä, eli jos lähetät työn CPU-puolella osioihin medium ja large, tai pyytämällä GPU-osioissa solmuja valinnalla --exclusive.

Virheelliset hajautetun tallennustilan pyynnöt voivat epäonnistua siten, että työ raportoidaan tilassa CANCELLED by 350, eikä vakiotuloste- tai vakiovirhelokeja synny. Tuki jaetun solmun töille on odotettavissa vuoden 2026 kolmannella neljänneksellä tai kun palvelu on valmis.

Pyydä tätä paikallista tallennustilaa seuraavalla valinnalla batch-skriptissä:

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

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

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

Jos varaat hajautettua tallennustilaa GPU-osioissa, lisää mukaan valinta --exclusive. Huomaa, että sinua laskutetaan täydestä solmusta riippumatta siitä, kuinka monta GPU:ta varaat.

#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 vajaakä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, 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 solmuihin.

Kun solmuja 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 kun --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ä 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ö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ä jos mahdollista, tehtävä jaetaan useisiin ketjutettuihin eräajotöihin 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 tuottaman 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ö saa alkaa vasta, kun aiemmin lähetetty työ on päättynyt 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äsittelemiseen.