Suurivolyymilaskenta ja työnkulut

Suurivolyymilaskenta (high-throughput computing, HTC) tarkoittaa suuren laskentatehtävämäärän suorittamista, usein automatisoinnin, skriptien ja työnkulunhallintaohjelmien avulla. Tällä sivulla esitellään keskeiset käsitteet, jotka kannattaa ottaa huomioon suurivolyymisiä työnkulkuja suunniteltaessa, ja autetaan rajaamaan käyttötapaukseesi sopiva työkalukokonaisuus. Valitsemalla huolellisesti tarkoituksenmukaisimman teknologiakokonaisuuden työsi odottavat vähemmän jonossa, I/O-operaatiot toimivat tehokkaammin ja koko HPC-järjestelmän suorituskyky pysyy vakaana ja nopeana kaikille käyttäjille.

Käsitteet

Suurivolyymilaskenta ja työnkulut HPC-ympäristössä

Suurivolyymilaskennalle on ominaista suuren määrän samankaltaisten, usein lyhytkestoisten laskentatehtävien suorittaminen. Kun nämä tehtävät ovat toisistaan riippumattomia, tästä käytetään usein nimitystä task farming tai embarrassingly parallel -ongelma, koska tehtävät voidaan periaatteessa jakaa yhtä monelle prosessorille kuin tehtäviä on suoritettavana. Tyypillisiä esimerkkejä ovat monien aineistojen analysointi samalla tavalla tai saman simulaation ajaminen monilla eri parametreilla.

Työnkulku on sarja tehtäviä, joissa osa tehtävistä riippuu toisten tuottamasta tulosteesta ja siksi ne on suoritettava määritellyssä järjestyksessä. Työnkulunhallintaohjelmat automatisoivat tällaisten tehtävägraafien suorittamisen. Työnkulut ovat usein hyvin sovelluskohtaisia, eikä tiettyyn käyttötapaukseen yleensä löydy menetelmää, joka toimisi suoraan ilman mukautuksia.

Miksi yksi suuri Slurm-työ monien pienten sijaan

Suuren eräajotöiden määrän (käynnistetty sbatch-komennolla) ja työvaiheiden (käynnistetty srun-komennolla) suorittaminen aiheuttaa ongelmia Slurmin kaltaisille eräajojen ajastimille. Monet työt ja työvaiheet tuottavat ylimääräistä lokidataa ja hidastavat Slurmia. Lyhyissä töissä on myös suuri ajastuksen yleiskustannus, mikä tarkoittaa, että yhä suurempi osa ajasta kuluu laskennan sijaan jonossa odottamiseen.

Jotta suurivolyymilaskenta olisi mahdollista ilman näitä ongelmia, pakkaa tehtäväsi niin, että ne suoritetaan mahdollisimman vähillä sbatch- ja srun-kutsuilla varaamalla yksi suuri resurssivaraus ja ajamalla sen sisällä monta tehtävää sopivalla työkalulla. Nyrkkisääntönä voidaan pitää, että jos ajat yli 20 lyhyttä tehtävää (alle noin 30 minuuttia), jotka suoritetaan yhdellä solmulla, ne kannattaa pakata yhteen Slurm-työhön.

Muita huomioita

Suurivolyymiset työnkulut ovat usein rajoittuneita I/O:n eivätkä laskennan vuoksi, joten kiinnitä erityistä huomiota siihen, miten tehtäväsi käyttävät rinnakkaista tiedostojärjestelmää. CSC:n Lustre-tiedostojärjestelmät on optimoitu kohtalaisen suuren määrän suurten tiedostojen lukemiseen ja kirjoittamiseen, ja ne toimivat huonosti, kun kuorma lukee tai kirjoittaa suuria määriä pieniä tiedostoja. Yleinen pullonkaula syntyy tehtävien käynnistyessä, kun monet tehtävät avaavat samanaikaisesti saman tiedostojoukon, mikä voi ylikuormittaa tiedostojärjestelmää ja hidastaa paitsi omia töitäsi myös koko järjestelmää muiden käyttäjien kannalta. Jotkin työnkulkutyökalut tuottavat myös suuren määrän pieniä väliaikais- ja lokitiedostoja, mikä pahentaa ongelmaa entisestään. Aina kun mahdollista, vähennä tiedostojen määrää pitämällä välidata muistissa, kokoamalla pieniä tiedostoja arkistoihin tai ohjaamalla raskas I/O paikallisille levyalueille jaetun rinnakkaisen tiedostojärjestelmän sijaan.

Kontit ovat tehokas tapa vähentää yllä kuvattua tiedostomääräongelmaa. Ohjelmistopinot, jotka koostuvat suuresta määrästä pieniä tiedostoja, kuten Python ulkoisine paketteineen tai R kirjastoineen, ovat erityisen ongelmallisia rinnakkaisessa tiedostojärjestelmässä sekä sinne asennettuina että tehtävän käynnistyessä tuotavina. Kun tällainen ohjelmisto paketoidaan yhdeksi konttikuvaksi, monet pienet tiedostot yhdistyvät yhdeksi tiedostoksi, jota rinnakkainen tiedostojärjestelmä käsittelee paljon tehokkaammin ja joka nopeuttaa tehtävien käynnistymistä huomattavasti. Kun ajat suurivolyymistä kuormaa, suorita task farming- tai työnkulkutyökalu yhden pitkään käynnissä olevan kontin sisällä sen sijaan, että käynnistäisit erillisen kontin jokaiselle yksittäiselle tehtävälle, sillä monien konttien käynnistäminen aiheuttaa merkittävää yleiskustannusta. Katso konttidokumentaatiosta, miten kontteja rakennetaan ja ajetaan CSC:llä.

Task farming HPC-ympäristössä

Tässä osiossa käsitellään työkaluja suuren määrän riippumattomien tehtävien suorittamiseen. Ne kattavat HTC-käyttötapauksia kymmenistä satoihin tuhansiin tehtäviin. Vaihtoehdot on järjestetty karkeasti järjestykseen "kokeile tätä ensin" alaspäin.

Yksittäiset Slurm-työt, työvaiheet ja taulukkotyöt

Tavalliset Slurm-työkalut sopivat hyvin tilanteisiin, joissa kukin tehtävä on riittävän pitkä, jotta ajastuksen yleiskustannus on merkityksetön (yksittäiset ajoajat yli noin 30 minuuttia). Slurmin tulisi olla myös ensimmäinen vaihtoehtosi MPI-töille, koska MPI-työt on käynnistettävä srun-komennolla. Taulukkotyöt ovat Slurmin oma tapa lähettää monta samankaltaista riippumatonta tehtävää yhdellä komennolla. Ne integroituvat saumattomasti Slurmiin ja tukevat MPI-tehtäviä, mutta eivät pakkaa työvaiheita eivätkä käsittele riippuvuuksia.

Voit tarkistaa käynnissä olevien ja jonossa olevien töiden määrärajoitukset seuraavasti:

sacctmgr show assoc user=$USER format=Account,Partition,MaxJobs,MaxSubmit -p

Tässä MaxJobs on samanaikaisesti käynnissä olevien töiden enimmäismäärä ja MaxSubmit on samanaikaisesti jonossa ja käynnissä olevien töiden enimmäismäärä.

Task farming Pythonin multiprocess-toiminnallisuudella yhdellä solmulla

farming.py

#!/usr/bin/env python3
import os
import subprocess
from concurrent.futures import ProcessPoolExecutor, as_completed

def task(arg: str) -> str:
    # Run one task. Use subprocess to call an external command,
    # or replace this with your own Python code.
    ret = subprocess.run(["echo", "-n", arg], capture_output=True, text=True)
    return ret.stdout

if __name__ == "__main__":
    # Use one worker per reserved core (SLURM_CPUS_PER_TASK).
    max_workers = int(os.getenv("SLURM_CPUS_PER_TASK", "1"))

    # The arguments to run the task with, one task per argument.
    args = [str(i) for i in range(100)]

    with ProcessPoolExecutor(max_workers=max_workers) as executor:
        # Submit all tasks to the pool; they run as workers become free.
        futures = [executor.submit(task, arg) for arg in args]

        # Collect the results as the tasks finish.
        results = []
        for future in as_completed(futures):
            results.append(future.result())

        print(results)

farming.sh

#!/bin/bash
#SBATCH --account=<project>
#SBATCH --partition=small
#SBATCH --time=00:15:00
#SBATCH --nodes=1
#SBATCH --ntasks-per-node=1
#SBATCH --cpus-per-task=10
#SBATCH --mem-per-cpu=1000
# You can load modules and set environment here if needed.
python3 farming.py

Lähetä Slurmiin

sbatch farming.sh

Tämä lähestymistapa sopii hyvin tilanteisiin, joissa tehtäväsi suoritetaan yhdellä solmulla ja haluat hienojakoista hallintaa siihen, miten ne suoritetaan. Yllä oleva esimerkki perustuu vain järjestelmän Pythonista saatavilla olevaan Pythonin standardikirjastoon, joten se ei vaadi lisäasennuksia tai ympäristön määritystä. Komentotulkiskriptaukseen verrattuna Python-skriptaus on vankempaa ja helpommin ylläpidettävää, erityisesti kun tehtävien käynnistämisen ja koordinoinnin logiikka muuttuu monimutkaisemmaksi. Sen avulla voit myös integroida datasi esikäsittelyn ja jälkikäsittelyn suoraan samaan skriptiin, pitää välitulokset muistissa ja välttää tarpeettomien tiedostojen kirjoittamista rinnakkaiseen tiedostojärjestelmään. ProcessPoolExecutor jakaa tehtävät työn varaamille ytimille, ja työntekijöiden määrä otetaan muuttujasta SLURM_CPUS_PER_TASK, joten se vastaa automaattisesti eräajoskriptissä pyydettyjä resursseja.

Hajautettu laskenta ohjelmointikielessäsi

Jos työsi on jo kirjoitettu korkean tason kielellä, kielen omat rinnakkais- ja hajautetun laskennan ominaisuudet ovat usein yksinkertaisin vaihtoehto:

Bash:

GNU xargs- ja parallel-komennot mahdollistavat erittäin suuren määrän lyhyiden, sarjallisten ja riippumattomien tehtävien tehokkaan suorittamisen ilman, että Slurmin loki paisuu. Se ei vaadi tietokantaa tai pysyvää hallintaprosessia eikä tue tehtävien välisiä riippuvuuksia.

Python:

R:

Julia:

Ohjelmistosi sisäänrakennetut HTC-vaihtoehdot

Monet simulointipaketit voivat ajaa useita riippumattomia simulaatioita yhden Slurm-työvaiheen sisällä. CSC:llä saatavilla olevia esimerkkejä:

GROMACSin multidir-vaihtoehto
CP2K:n FARMING-tila (tukee myös alitöiden välisiä riippuvuuksia)
LAMMPSin multi-partition-kytkin
Amberin multi-pmemd

Lisälukemista

Gaussian-töiden farming HyperQueuella

Työnkulut HPC-ympäristössä

Kun tehtävilläsi on riippuvuuksia ja ne muodostavat putken, käytä työnkulunhallintaohjelmaa. Nämä työkalut seuraavat, mitkä tehtävät riippuvat mistäkin, suorittavat tehtävät oikeassa järjestyksessä ja toipuvat virheistä käynnistämällä epäonnistuneet tehtävät uudelleen. Seuraava ei ole täydellinen luettelo, ja myös muut työkalut voivat sopia käyttötapaukseesi.

HyperQueue

HyperQueue on yleiskäyttöinen työkalu suurivolyymilaskentaan. Sen sijaan, että lähettäisit jokaisen tehtävän erillisenä Slurm-työnä tai työvaiheena, varaat suuren resurssilohkon ja annat HyperQueuen ajastaa tehtäväsi siihen minimaalisella kuormalla Slurmille ja vähäisellä lisä-I/O:lla. Se voi ajastaa tehtäviä osasolmutarkkuudella ja skaalautuu suuriin tehtävämääriin useilla solmuilla. Tehtävien välisten riippuvuuksien käsittelemiseksi HyperQueuen Python API mahdollistaa tehtävägraafin rakentamisen, jossa kukin tehtävä voi määritellä, mistä tehtävistä se riippuu. HyperQueue voi toimia myös tehtävien suorittajana työnkulunhallintaohjelmille, kuten Snakemakelle ja Nextflow’lle.

Snakemake

Snakemake on suosittu Python-pohjainen työnkulunhallintaohjelma, jossa on riippuvuustuki ja automaattinen kontti-integraatio. Katso Snakemake-sivulta, miten sitä käytetään CSC:llä, mukaan lukien HyperQueue-suorittajan kanssa.

Nextflow

Nextflow on suosittu Groovyyn perustuva työnkulunhallintaohjelma, jossa on riippuvuustuki ja kontti-integraatio. Katso Nextflow-sivulta, miten sitä käytetään CSC:llä, mukaan lukien HyperQueue-suorittajan kanssa.

FireWorks

FireWorks on työnkulkutyökalu monimutkaisille riippuvuuksille ja monisolmuisille alitehtäville. Huomaa, että se voi luoda paljon työvaiheita ja ylimääräisiä tiedostoja, mikä ei ole ihanteellista HTC-käytössä; suosi yllä olevia vaihtoehtoja, kun ne sopivat käyttötapaukseesi.

Tuki

Työnkulut, jotka sisältävät suuren määrän monisolmuisia tehtäviä, saattavat vaatia erityisratkaisun. Älä epäröi ottaa yhteyttä CSC:n Service Deskiin, jos sinulla on huolia työnkulkusi toteutuksesta.