HyperQueue

HyperQueue (HQ) on tehokas alisolmutason tehtäväajastin. Sen sijaan, että lähettäisit jokaisen laskentatehtäväsi erillisinä Slurm- töinä tai työvaiheina, voit varata suuren resurssilohkon ja käyttää sitten HyperQueuea tehtäviesi lähettämiseen tähän varaukseen. Yksi resurssivaraus kuormittaa eräjono- järjestelmää huomattavasti vähemmän, ja se on suositeltu tapa suorittaa suuren läpimenon laskennan käyttötapauksia. Lisäksi voimme käyttää HyperQueuea Slurmin sijaan tehtävien suorittajana muille työnkulunhallintaohjelmille, kuten Snakemakelle ja Nextflow’lle.

Lisenssi

Vapaasti käytettävissä ja avointa lähdekoodia MIT-lisenssillä

Saatavilla

• Puhti: 0.13.0, 0.15.0, 0.16.0
• Mahti: 0.13.0, 0.15.0, 0.16.0
• LUMI: 0.18.0

Käyttö

Lataa HyperQueuen oletusversio Puhdissa ja Mahdissa näin:

module load hyperqueue

Tietyn version lataamiseen käytä:

module load hyperqueue/<version>

Korvaa <version> sopivalla versionumerolla (katso yllä). Käytä komentoa module spider muiden versioiden löytämiseen.

Jotta voit käyttää CSC:n HyperQueue-moduuleja LUMIssa, muista ensin suorittaa module use /appl/local/csc/modulefiles.

module use /appl/local/csc/modulefiles
module load hyperqueue

Tehtäväviljely sbatch-hq-työkalulla

Yksinkertaisiin tehtäväviljelyn työnkulkuihin, joissa haluat ajaa vain monia samankaltaisia, itsenäisiä ja ei-MPI-rinnakkaisohjelmia, voit käyttää CSC:n apuohjelmaa sbatch-hq. Määritä vain ajettavien komentojen lista tiedostossa, yksi komento per rivi. Työkalu sbatch-hq luo ja käynnistää erätyön, joka alkaa suorittaa tiedoston komentoja HyperQueuen avulla. Voit määrittää, kuinka monella solmulla haluat komentoja ajaa, ja sbatch-hq jatkaa komentojen suorittamista, kunnes kaikki ovat valmiita tai erätyön aikaraja saavutetaan.

Oletetaan, että meillä on tasks-tiedosto, jossa on lista komennoista, jotka haluamme ajaa kahdeksalla säikeellä kukin. Älä käytä komennoissa srun-komentoa! HyperQueue käynnistää tehtävät pyydettyjen varattujen resurssien avulla. Esimerkiksi

command1 arguments1
command2 arguments2
# and so on

Esimerkiksi varataan yksi laskentasolmu koko työlle, mikä tarkoittaa, että voisimme ajaa joko viittä tehtävää samanaikaisesti Puhdissa tai 16 tehtävää samanaikaisesti Mahdissa.

module load sbatch-hq
sbatch-hq --cores=8 --nodes=1 --account=<project> --partition=test --time=00:15:00 tasks

Tiedoston komentojen määrä voi (ja yleensä pitäisi) olla paljon suurempi kuin niiden tehtävien määrä, jotka mahtuvat ajettaviksi samanaikaisesti varatuilla solmuilla. Katso lisätietoja käytöstä ja syötevalinnoista komennolla sbatch-hq --help.

HyperQueuen käyttäminen Slurm-erätyössä

HyperQueue toimii worker-server-client-periaatteella. Palvelin hallitsee yhteyksiä workereiden ja asiakkaan välillä. Asiakas lähettää tehtävät palvelimelle, joka välittää ne käytettävissä oleville workereille. Asiakas ja palvelin voivat toimia kirjautumis- tai laskentasolmuilla, ja workerit toimivat laskentasolmuilla. HyperQueue muistuttaa Slurmia Slurmin sisällä, mutta palvelin ja workerit on käynnistettävä itse. Suosittelemme lukemaan virallisen HyperQueue-dokumentaation.

Tämä esimerkki koostuu eräskriptistä ja suoritettavasta tehtäväskriptistä. Eräskripti käynnistää HyperQueue-palvelimen ja workerit sekä lähettää tehtäviä workereille. Tehtäväskripti on suoritettava skripti, jonka lähetämme workereille. Voit kopioida seuraavan esimerkin, ajaa sen sellaisenaan ja muokata sitä tarpeidesi mukaan. Hakemistorakenne näyttää seuraavalta:

.             # Current working directory
├── batch.sh  # Batch script for HyperQueue server and workers
└── task      # Executable task script for HyperQueue

Tehtävä

Oletamme, että HyperQueue-tehtävät ovat toisistaan riippumattomia ja suoritetaan yhdellä solmulla. Tässä on esimerkki yksinkertaisesta, suoritettavasta Bashilla kirjoitetusta task-skriptistä.

#!/bin/bash
sleep 1

Yhden tehtävän overhead on noin 0,1 millisekuntia. Siksi voimme suorittaa tehokkaasti jopa hyvin pieniä tehtäviä.

Erätyö

Slurm-erätyössä jokainen Slurm-tehtävä vastaa yhtä HyperQueue-workeria. Voimme kasvattaa workereiden määrää lisäämällä Slurm-tehtävien määrää. Osittaisessa solmuvarauksessa varaamme workeria kohden osan solmun suorittimista ja muistista, ja täydessä solmuvarauksessa kaikki solmun suorittimet ja muistin workeria kohden.

Puhti partial single nodePuhti partial multinodePuhti full single nodePuhti full multinodeMahti full node

#!/bin/bash
#SBATCH --account=<project>
#SBATCH --partition=small    # single node partition
#SBATCH --nodes=1            # one compute node
#SBATCH --ntasks-per-node=1  # one HyperQueue worker
#SBATCH --cpus-per-task=10   # one or more cpus per worker
#SBATCH --mem-per-cpu=1000   # desired amount of memory per cpu
#SBATCH --time=00:15:00

#!/bin/bash
#SBATCH --account=<project>
#SBATCH --partition=large    # multi node partition
#SBATCH --nodes=2            # two or more nodes
#SBATCH --ntasks-per-node=1  # one HyperQueue worker per node
#SBATCH --cpus-per-task=10   # one or more cpus per worker
#SBATCH --mem-per-cpu=1000   # desired amount of memory per cpu
#SBATCH --time=00:15:00

#!/bin/bash
#SBATCH --account=<project>
#SBATCH --partition=small    # single node partition
#SBATCH --nodes=1            # one compute node
#SBATCH --ntasks-per-node=1  # one HyperQueue worker
#SBATCH --cpus-per-task=40   # all cpus on a node
#SBATCH --mem=0              # reserve all memory on a node
#SBATCH --time=00:15:00

#!/bin/bash
#SBATCH --account=<project>
#SBATCH --partition=large    # multi node partition
#SBATCH --nodes=2            # two or more nodes
#SBATCH --ntasks-per-node=1  # one HyperQueue worker per node
#SBATCH --cpus-per-task=40   # reserve all cpus on a node
#SBATCH --mem=0              # reserve all memory on a node
#SBATCH --time=00:15:00

#!/bin/bash
#SBATCH --account=<project>
#SBATCH --partition=medium   # multi node partition
#SBATCH --nodes=1            # one or more nodes
#SBATCH --ntasks-per-node=1  # one HyperQueue worker per node
#SBATCH --cpus-per-task=128  # all cpus on a node
#SBATCH --mem=0              # reserve all memory on a node
#SBATCH --time=00:15:00

Moduuli

Lataamme HyperQueue-moduulin, jotta hq-komento on käytettävissä.

module load hyperqueue

Palvelin

Seuraavaksi määritämme, mihin HyperQueue sijoittaa palvelintiedostot. Kaikki hq-komennot noudattavat tätä muuttujaa, joten asetamme sen ennen minkään hq-komennon käyttöä. Jos palvelinhakemistoa ei määritetä, oletuksena käytetään käyttäjän kotihakemistoa. Tässä tapauksessa on oltava varovainen, ettei sekoita eri laskentoja keskenään, ja on myös huomioitava $HOME-hakemiston rajallinen tallennustila. Suosittelemme yksinkertaisissa tapauksissa, jotka mahtuvat yhden Slurm-työn sisään, käynnistämään yhden palvelimen per työ työkohtaisessa hakemistossa.

# Specify a location for the server
export HQ_SERVER_DIR="$PWD/hq-server/$SLURM_JOB_ID"

# Create a directory for the server
mkdir -p "$HQ_SERVER_DIR"

Nyt käynnistämme palvelimen taustalla ja odotamme sen käynnistymistä. Palvelin jatkaa toimintaansa, kunnes pysäytämme sen; siksi sijoitamme sen taustalle, jotta se ei estä skriptin muun osan suorittamista.

# Start the server in the background
hq server start &

# Wait until the server has started
until hq job list &> /dev/null ; do sleep 1 ; done

Workerit

Seuraavaksi käynnistämme HyperQueue-workerit taustalla eräskriptissä määritellyllä suoritinmäärällä käyttäen ympäristömuuttujaa $SLURM_CPUS_PER_TASK. Käynnistämällä workerit srun-komennolla luomme yhden workerin jokaista Slurm-tehtävää kohden. Odotamme myös, että kaikki workerit yhdistyvät, mikä on yleensä hyvä käytäntö, koska näin mahdolliset ongelmat workereiden kanssa havaitaan varhain.

# Start the workers in the background.
srun --overlap --cpu-bind=none --mpi=none hq worker start \
    --manager slurm \
    --on-server-lost finish-running \
    --cpus="$SLURM_CPUS_PER_TASK" &

# Wait until all workers have started
hq worker wait "$SLURM_NTASKS"

Laskentatehtävät

Nyt voimme lähettää tehtäviä palvelimelle komennolla hq submit, jolloin palvelin suorittaa ne käytettävissä olevilla workereilla. Tämä on ei-estävä komento, joten sitä ei tarvitse ajaa taustalla. Tiedosto-I/O:n osalta poistamme tulosteen käytöstä asettamalla --stdout=none ja --stderr=none. Muuten HyperQueue luo jokaiselle tehtävälle tulostetiedostot, mikä voi aiheuttaa ylimääräistä I/O-kuormaa rinnakkaistiedostojärjestelmään, kun tehtäviä on paljon. Kun kaikki tehtävät on lähetetty, odotamme niiden valmistumista skriptin synkronoimiseksi.

# Submit tasks to workers
hq submit --stdout=none --stderr=none --cpus=1 --array=1-1000 ./task

# Wait for all the tasks to finish
hq job wait all

Kannattaa lukea osiot Työt ja tehtävät ja tehtävätaulukot, jotta ymmärtää eri tavat suorittaa laskentaa HyperQueuella. Monimutkaisemmissa tehtäväriippuvuuksissa voimme käyttää HyperQueuea suorittajana muille työnkulunhallinta- ohjelmille, kuten Snakemakelle tai Nextflow’lle.

Workereiden ja palvelimen pysäyttäminen

Kun olemme saaneet kaikkien tehtävien ajon valmiiksi, sammutamme workerit ja palvelimen, jotta vältämme Slurmin virheellisen virheilmoituksen työn päättyessä.

# Shut down the workers and server
hq worker stop all
hq server stop

Paikallisten levyjen käyttäminen HyperQueuen kanssa

Voimme käyttää väliaikaisia paikallisia levyalueita HyperQueuen kanssa I/O-intensiivisten tehtävien suorittamiseen. Koska HyperQueue-tehtävä voi suorittua millä tahansa varatulla solmulla, jokaisen solmun paikallisella levyllä on oltava kopio kaikista tiedostoista, joita tehtävä voi käyttää. Tyypillinen työnkulku koostuu seuraavista:

1. Arkistoitujen syötetiedostojen kopiointi ja purkaminen rinnakkaistiedostojärjestelmästä paikalliselle levylle.
2. Paikallista levyä käyttävien HyperQueue-tehtävien (hq submit) suorittaminen.
3. Tulostetiedostojen arkistointi ja kopiointi paikalliselta levyltä rinnakkaistiedosto- järjestelmään.

Vaiheissa 1 ja 3 voimme suorittaa <executable>-ohjelman jokaisella varatulla solmulla Slurm-työvaiheena seuraavasti:

srun -m arbitrary -w "$SLURM_JOB_NODELIST" <executable>

Ilman valitsimia srun suorittaisi ohjelman jokaisessa Slurm-tehtävässä, mikä voisi tapahtua samalla solmulla. srun-komento voidaan jättää pois, jos pyydetään vain yksi solmu.

Täydelliset esimerkkiskriptit Puhdille

Single nodeMultinode + local disk

task

#!/bin/bash
echo "Hello from task $HQ_TASK_ID!" > "output/$HQ_TASK_ID.out"
sleep 1

batch.sh

#!/bin/bash
#SBATCH --account=<project>
#SBATCH --partition=small
#SBATCH --nodes=1
#SBATCH --ntasks-per-node=1
#SBATCH --cpus-per-task=10
#SBATCH --mem-per-cpu=1000
#SBATCH --time=00:15:00

module load hyperqueue

# Specify a location and create a directory for the server
export HQ_SERVER_DIR="$PWD/hq-server/$SLURM_JOB_ID"
mkdir -p "$HQ_SERVER_DIR"

# Start the server in the background and wait until it has started
hq server start &
until hq job list &> /dev/null ; do sleep 1 ; done

# Start the workers in the background
srun --overlap --cpu-bind=none --mpi=none hq worker start \
    --manager slurm \
    --on-server-lost finish-running \
    --cpus="$SLURM_CPUS_PER_TASK" &

# Wait until all workers have started
hq worker wait "$SLURM_NTASKS"

# Create a directory for output files
mkdir -p output

# Submit tasks to workers
hq submit --stdout=none --stderr=none --cpus=1 --array=1-1000 ./task

# Wait for all tasks to finish
hq job wait all

# Shut down the workers and server
hq worker stop all
hq server stop

Tässä esimerkissä käytetty arkisto input.tar.gz purkautuu input-hakemistoon.

extract

#!/bin/bash
tar xf input.tar.gz -C "$LOCAL_SCRATCH"
mkdir -p "$LOCAL_SCRATCH/output"

task

#!/bin/bash
cd "$LOCAL_SCRATCH"
cat "input/$HQ_TASK_ID.inp" > "output/$HQ_TASK_ID.out"
sleep 1

archive

#!/bin/bash
cd "$LOCAL_SCRATCH"
tar czf "output-$SLURMD_NODENAME.tar.gz" output
cp "output-$SLURMD_NODENAME.tar.gz" "$SLURM_SUBMIT_DIR"

batch.sh

#!/bin/bash
#SBATCH --account=<project>
#SBATCH --partition=large
#SBATCH --nodes=2
#SBATCH --ntasks-per-node=1
#SBATCH --cpus-per-task=40
#SBATCH --mem=0
#SBATCH --time=00:15:00
#SBATCH --gres=nvme:1

module load hyperqueue

# Specify a location and create a directory for the server
export HQ_SERVER_DIR="$PWD/hq-server/$SLURM_JOB_ID"
mkdir -p "$HQ_SERVER_DIR"

# Start the server in the background and wait until it has started
hq server start &
until hq job list &> /dev/null ; do sleep 1 ; done

# Start the workers in the background
srun --overlap --cpu-bind=none --mpi=none hq worker start \
    --manager slurm \
    --on-server-lost finish-running \
    --cpus="$SLURM_CPUS_PER_TASK" &

# Wait until all workers have started
hq worker wait "$SLURM_NTASKS"

# Download some example input files
wget https://a3s.fi/CSC_training/input.tar.gz

# Extract input files to the local disk and create a directory for outputs
srun -m arbitrary -w "$SLURM_JOB_NODELIST" ./extract

# Submit tasks to workers
hq submit --stdout=none --stderr=none --cpus=1 --array=1-1000 ./task

# Wait for all tasks to finish
hq job wait all

# Archive and copy output from each local disk to working directory on Lustre
srun -m arbitrary -w "$SLURM_JOB_NODELIST" ./archive

# Shut down the workers and server
hq worker stop all
hq server stop

Snakemaken tai Nextflown käyttäminen HyperQueuen kanssa

Katso Nextflow-opas tai Snakemake-opas, joissa on ohjeet HyperQueuen käyttämiseen Nextflow- tai Snakemake-työnkulkujen suorittajana.

Monisolmutehtävät

Vaikka HyperQueue ei suoraan tue MPI-suoritusta, se on mahdollista käyttämällä yhdessä HQ-ominaisuutta Monisolmutehtävät sekä orterun-, hydra- tai prrte-työkaluja. Näin MPI-tehtäviä voidaan ajastaa solmutason tarkkuudella.

Automaattinen worker-varaus

Suosittelemme välttämään automaattisen varaajan käyttöä. Se luo automaattisesti ja lähettää eräskriptejä workereiden käynnistämiseksi, mikä lisää tarpeetonta monimutkaisuutta. Lisäksi automaattisesti luoduissa eräskripteissä on joitakin ongelmia, ja ne voisivat olla joustavampia.

Lisätietoja

• HyperQueuen ja paikallisen levyn käyttäminen monien tiedostojen käsittelyyn
• Gaussian-töiden viljely sbatch-hq:lla

Onko tämä sivu hyödyllinen?

Kyllä

Kiitos palautteestasi!

Ei

Kiitos! Arvostamme palautettasi.

Kerro meille miten voisimme parantaa tätä sivua ottamalla meihin yhteyttä.