Suurivolyymilaskenta ja työnkulut

Suurivolyymilaskenta (high-throughput computing, HTC) tarkoittaa suuren laskentatehtävämäärän ajamista, 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 oikea työkalukokonaisuus omaan käyttötapaukseesi. 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ä

Suurivolyymilaskennan tunnusomainen piirre on suuren määrän samankaltaisten, usein lyhytkestoisten laskentatehtävien ajaminen. 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 ajettavia tehtäviä on. Tyypillisiä esimerkkejä ovat monien aineistojen analysointi samalla tavalla tai saman simulaation ajaminen monilla eri parametreilla.

Työnkulku on tehtäväsarja, jossa osa tehtävistä riippuu toisten tuottamasta tulosteesta ja siksi ne on ajettava määrätyssä 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 sellaisenaan.

Miksi yksi suuri Slurm-työ monien pienten sijaan

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

Jotta suurivolyymilaskenta olisi mahdollista ilman näitä ongelmia, pakkaa tehtäväsi niin, että ne ajetaan 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, kannattaa harkita niiden pakkaamista yhteen Slurm-työhön.

Muita huomioita

Suurivolyymisiä työnkulkuja rajoittaa usein enemmän I/O kuin laskenta, 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 kuormittaa tiedostojärjestelmää liikaa 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, niputtamalla 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 tiivistyvät yhdeksi tiedostoksi, jota rinnakkainen tiedostojärjestelmä käsittelee paljon tehokkaammin ja joka nopeuttaa tehtävien käynnistymistä huomattavasti. Kun ajat suurivolyymistä kuormaa, aja 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 konttidokumentaatio, jossa kerrotaan, 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 ajamiseen. 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äkestoinen, 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 ajossa olevien töiden enimmäismäärä ja MaxSubmit on samanaikaisesti jonossa ja ajossa 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 ajetaan yhdellä solmulla ja haluat tarkkaa hallintaa siihen, miten ne suoritetaan. Yllä oleva esimerkki perustuu vain järjestelmän Pythonista saatavaan Pythonin vakiokirjastoon, joten se ei vaadi lisäasennuksia eikä 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 esi- 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 käyttöön varattujen ytimien kesken, 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, riippumattomien tehtävien tehokkaan ajamisen 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-valitsin
Amberin multi-pmemd

Lisälukemista

Gaussian-töiden task 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, ajavat tehtävät oikeassa järjestyksessä ja toipuvat virheistä käynnistämällä epäonnistuneet tehtävät uudelleen. Seuraava luettelo ei ole täydellinen, 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 Slurm-kuormalla ja vähäisellä lisä-I/O:lla. Se voi ajastaa tehtäviä osasolmutarkkuudella ja skaalautuu suuriin tehtävämääriin useiden solmujen yli. Tehtävien välisten riippuvuuksien käsittelemiseksi HyperQueuen Python API antaa sinun rakentaa tehtävägraafin, 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.

Yksinkertaiseen komentoluetteloihin perustuvaan task farming -käyttöön CSC:n apuohjelma sbatch-hq käyttää HyperQueuea taustalla, jotta voit lähettää joukon samankaltaisia riippumattomia tehtäviä suoraan komentotiedostosta.

Snakemake

Snakemake on suosittu Python-pohjainen työnkulunhallintaohjelma, jossa on riippuvuustuki ja automaattinen kontti-integraatio. Katso Snakemake-sivu, jossa kerrotaan, miten sitä ajetaan CSC:llä, myös HyperQueue-suorittajan kanssa.

Nextflow

Nextflow on suosittu Groovyyn perustuva työnkulunhallintaohjelma, jossa on riippuvuustuki ja kontti-integraatio. Katso Nextflow-sivu, jossa kerrotaan, miten sitä ajetaan CSC:llä, myös HyperQueue-suorittajan kanssa.

FireWorks

FireWorks on työnkulkutyökalu monimutkaisiin riippuvuuksiin ja usean solmun alitehtäviin. Huomaa, että se voi luoda paljon työvaiheita ja ylimääräisiä tiedostoja, mikä ei ole HTC:n kannalta ihanteellista; suosi yllä olevia vaihtoehtoja, kun ne sopivat käyttötapaukseesi.

Tuki

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