Jobb Script

? kj?re en jobb p? klyngen inneb?rer ? lage et skallskript kalt et jobbskript. Jobbskriptet er en ren tekstfil som inneholder et hvilket som helst antall kommandoer, inkludert den prim?re kommandoen, dvs. den kan kopiere eller endre navn p? filer, cd til riktig katalog osv., alt f?r du gj?r den "ekte" jobben. Linjene i skriptfilen er kommandoene som skal utf?res, i gitt rekkef?lge. Linjer som starter med "#" ignoreres som kommentarer, bortsett fra linjer som starter med "#SBATCH" som ikke blir utf?rt, men inneholder spesielle instruksjoner til k?systemet.

Hvis du ikke er kjent med shell-skript, er de ganske enkelt et sett med kommandoer som du kunne ha skrevet p? kommandolinjen. Du kan finne mer informasjon om shell scripts her: Introduction to Bash shell scripts.

Et jobbskript best?r av flere elementer:

• Instruksjoner til k?systemet
• Kommandoer for ? sette opp milj?et hvor jobbene kj?res
• De faktiske kommandoene som skal kj?res

Instruction parameters to the queue system may be specified on the sbatch command line and/or in #SBATCH lines in the job script. There can be as many #SBATCH lines as you need, and you can combine several parameters on the same line. If a parameter is specified both on the command line and in the jobscript, the parameter specified on the command line takes precedence. The #SBATCH lines should precede any commands in the script. A couple of parameters are compulsory. If they are not present, the job will not run:

Instruksjonsparametere til k?systemet kan spesifiseres p? sbatch-kommandolinjen og/eller i #SBATCH-linjer i jobbskriptet. Det kan v?re s? mange #SBATCH-linjer du trenger, og du kan kombinere flere parametere p? samme linje. Hvis en parameter er spesifisert b?de p? kommandolinjen og i jobbskriptet, har parameteren angitt p? kommandolinjen forrang. #SBATCH-linjene skal komme foran alle kommandoer i skriptet. Et par parametere er obligatoriske. Hvis de ikke er til stede, vil ikke jobben kj?re:

• -account: Spesifiserer prosjektet jobben skal kj?re i. Hvis prosjektet ditt har en Sigma-kvote, vil dette v?re prosjekt (f.eks. p11). Hvis prosjektet ditt ikke har en Sigma-kvote, m? du bruke tsd-reservasjonen, project_tsd (f.eks. p11_tsd).
• --time: Angir maksimal mulig kj?retid for jobben. Ikke spesifiser grensen for lav, fordi jobben vil bli drept hvis den ikke er ferdig innen denne tiden. P? den annen side vil kortere jobber startes tidligere, s? ikke spesifiser lenger enn du trenger. Standard maksimalt tillatt --time spesifikasjon er 1 uke; se detaljer her.
• --mem-per-cpu: Spesifiserer hvor mye RAM hver oppgave (standard er 1 oppgave; se Parallelle jobber) trenger for jobben. Teknisk sett spesifiserer denne grensen mengden internminne + swap jobben kan bruke. Hvis jobben pr?ver ? bruke mer enn denne innstillingen, vil den bli drept. Det maksimale som kan bes om er det tilgjengelige minnet p? noden (~500 GB p? beregningsnodene). For eksempel:

  #SBATCH --mem-per-cpu=2000M

  Hvis jobben pr?ver ? bruke mer enn 2000 MiB internminne som er forespurt i dette eksemplet, vil den bli drept. Merk at --mem-per-cpu er spesifisert per forespurt kjerne.

Kommandoene for ? sette opp milj?et b?r inkludere

module load SomeProgram/SomeVersion

jobsetup vil sette opp n?dvendige milj?variabler og skallfunksjoner, og m? v?re den f?rste kommandoen i skriptet. modulen vil sette opp milj?variabler for ? f? tilgang til det angitte programmet. Det anbefales ? spesifisere den eksplisitte versjonen i module load kommandoen. Vi oppfordrer deg ogs? til ? bruke

module purge

f?r module load, for ? unng? ? arve ukjente milj?variableinnstillinger fra skallet du bruker til ? sende inn jobben. Vi gir ogs? r?d om bruk av

set -o errexit

tidlig i skriptet. Dette gj?r at skriptet avsluttes umiddelbart hvis en kommando etter denne mislykkes, i stedet for ? g? videre til neste kommando. Dette gj?r det mye lettere ? finne ut om noe gikk galt i jobben, og i s? fall hvor det skjedde.

En enkel seriell jobb

Dette er et skript for ? kj?re en enkel, seriell jobb

#!/bin/bash

# Job name:
#SBATCH --job-name=YourJobname
#
# Project:
#SBATCH --account=YourProject
#
# Wall clock limit:
#SBATCH --time=hh:mm:ss
#
# Max memory usage:
#SBATCH --mem-per-cpu=Size

## Set up job environment:
module purge   # clear any inherited modules
set -o errexit # exit on errors

## Copy input files to the work directory:
cp MyInputFile $SCRATCH

## Make sure the results are copied back to the submit directory (see Work Directory below):
chkfile MyResultFile

## Do some work:
cd $SCRATCH
YourCommands

Erstatt reelle verdier for YourJobname, YourProject, hh:mm:ss, Size (med 'M' for megabyte eller 'G' for gigabyte; f.eks. 200M eller 1G), MyInputFile, MyResultFile og YourCommands.

Arbeidskatalog

Hver jobb har tilgang til et separat scratch omr?de p? det delte filsystemet /cluster. Navnet p? katalogen er lagret i milj?variabelen $SCRATCH i jobbskriptet. Som en generell regel b?r alle jobber bruke scratch-katalogen ($SCRATCH) som sin arbeidskatalog. Dette er spesielt viktig hvis jobben bruker mange filer, eller har mye "random access" til filene (les og skriv gjentatte ganger til forskjellige steder i filene).

Det er flere gode grunner til ? bruke $SCRATCH:

• $SCRATCH er p? et raskere filsystem enn brukerens hjemmekatalog.
• Det er mindre risiko for ? forstyrre kj?rende jobber ved ? endre eller slette jobbens inn- eller utdatafiler ved et uhell.
• Midlertidige filer blir automatisk ryddet opp, fordi scratch-katalogen fjernes n?r jobben er ferdig.
• Man unng?r ? ta un?dvendige sikkerhetskopier av midlertidige og ufullstendige  filer, fordi $SCRATCH ikke er sikkerhetskopiert.

Katalogen der du kj?rte sbatch er lagret i milj?variabelen $SLURM_SUBMIT_DIR. Hvis du ?nsker automatisk kopiering av filer eller kataloger tilbake til $SLURM_SUBMIT_DIR n?r jobben er avsluttet, merk dem med kommandoen chkfile i jobbskriptet:

chkfile OneFile AnotherFile SomeDirectory

• chkfile-kommandoen b?r plasseres tidlig i skriptet, f?r de viktigste beregningskommandoene: Filene vil bli kopiert tilbake selv om skriptet krasjer (selv n?r du bruker set -o errexit), men ikke hvis det avsluttes f?r det kom til chkfile kommandoen.
• Hvis du vil bruke skall-metategn, b?r de v?re mellom anf?rselstegn. Det vil si, bruk chkfile "Results*" i stedet for chkfile Results*.
• Ikke bruk absolutte stier eller ting som ".*" eller .. i kommandoen chkfile; bruk stier som er relative til $SCRATCH.
• Filene/katalogene kopieres til $SLURM_SUBMIT_DIR ved bruk av rsync, som betyr at hvis du bruker chkfile ResultDir, vil innholdet i ResultDir kopieres til $SLURM_SUBMIT_DIR/ResultDir, men hvis du bruker chkfile ResultDir/ (dvs. med en etterf?lgende /), vil innholdet i ResultDir vil bli kopiert direkte til $SLURM_SUBMIT_DIR.

Vi anbefaler ? bruke chkfile (eller cleanup; se nedenfor) i stedet for ? eksplisitt kopiere resultatfilene med cp.

For eksempel:

#!/bin/bash
#SBATCH --job-name=YourJobname --account=YourProject
#SBATCH --time=hh:mm:ss --mem-per-cpu=Size

module purge   # clear any inherited modules
set -o errexit # exit on errors

## Copy files to work directory:
cp YourDatafile $SCRATCH

## Mark outfiles for automatic copying to $SLURM_SUBMIT_DIR:
chkfile YourOutputfile

## Run command
cd $SCRATCH
YourProgram YourDatafile > YourOutputfile

$SCRATCH-katalogen fjernes n?r jobben avsluttes (etter tilbakekopiering av chkfile-filer).

Hvis du ?nsker mer fleksibilitet enn det chkfile gir, kan du bruke kommandoen cleanup i stedet. Den brukes til ? spesifisere kommandoer som skal kj?res n?r jobben avsluttes (f?r $SCRATCH-katalogen fjernes). Akkurat som chkfile, kj?res cleanup kommandoene selv om skriptet ditt krasjer (selv n?r du bruker set -o errexit), men ikke hvis det krasjer f?r cleanup kommandoen n?s.  S? plasser kommandoen tidlig i skriptet.

For eksempel:

cleanup "cp $SCRATCH/outputfile /some/other/directory/newName"

Note: ikke bruk enkelt anf?rselstegn (') hvis kommandoene inneholder variable som $SCRATCH and $SLURM_SUBMIT_DIR.

Dele opp en jobb i oppgaver (Array jobber)

For ? kj?re mange forekomster av samme jobb, bruk --array  for ? bytte til sbatch. Dette er nyttig hvis du har mange datasett som du vil behandle p? samme m?te med samme jobbskript:

sbatch --array=from-to [other sbatch switches] YourScript

Du kan ogs? sette --array i en #SBATCH-linje inne i skriptet. from og to er f?rste og siste oppgavenummer. Hver forekomst av YourScript kan bruke milj?variabelen $SLURM_ARRAY_TASK_ID for ? velge hvilket datasett som skal brukes, osv. For eksempel:

sbatch --array=1-100 MyScript

kj?rer 100 kopier av MyScript, og setter milj?variabelen $SLURM_ARRAY_TASK_ID til 1, 2, ..., 100 etter tur.

Det er mulig ? spesifisere oppgave-ID-ene p? andre m?ter enn from-to: det kan v?re et enkelt tall, et omr?de ( from-to), et omr?de med en trinnst?rrelse (from-to:step), eller en kommaseparert liste av disse. Til slutt, ? legge til %max p? slutten av spesifikasjonen setter en grense for hvor mange oppgaver som f?r kj?res samtidig. Et par eksempler:

Specification   Resulting TASK_IDs
1,4,42        # 1, 4, 42
1-5           # 1, 2, 3, 4, 5
0-10:2        # 0, 2, 4, 6, 8, 10
32,56,100-200 # 32, 56, 100, 101, 102, ..., 200
1-200%10      # 1, 2, ..., 200, but maximum 10 running at the same time

Merk: mellomrom, desimaltall eller negative tall er ikke tillatt.

Forekomstene av en array-jobb er uavhengige, de har sin egen $SCRATCH og blir behandlet som separate jobber. (Dette betyr at de teller mot grensen for totalt antall jobber en bruker kan ha i jobbk?en, for tiden 400.) Du kan ogs? spesifisere et parallelt milj? i array-jobs, slik at hver instans f?r f.eks. 8 prosessorer. For ? avbryte alle oppgaver i en array-jobb, avbryt jobb-id som returneres av sbatch-kommandoen.

Se man sbatch for detaljer.

Et utvidet eksempel:

$ cat JobScript
#!/bin/bash
#SBATCH --account=YourProject
#SBATCH --time=1:0:0
#SBATCH --mem-per-cpu=1G
#SBATCH --array=1-200

module purge   # clear any inherited modules
set -o errexit # exit on errors

DATASET=dataset.$SLURM_ARRAY_TASK_ID
OUTFILE=result.$SLURM_ARRAY_TASK_ID

cp $DATASET $SCRATCH
cd $SCRATCH
chkfile $OUTFILE
YourProgram $DATASET > $OUTFILE

$ sbatch JobScript

Denne jobben vil prosessere datasettene dataset.1, dataset.2, ... dataset.200 og  lagre resultatene i result.1, result.2, ... result.200.

Paralelliserte Jobber

Siden klyngene best?r av multi-cpu og multi-core databehandlingsnoder, er det flere m?ter ? parallellisere kode og kj?re jobber parallelt. Man kan bruke MPI, OpenMP og threading. (For SIMD-jobber og andre jobber med sv?rt uavhengige parallelle oppgaver, er array-jobber et godt alternativ.) I denne delen vil vi forklare hvordan du kan kj?re parallelt p? en av disse m?tene.

Merk: En parallell jobb vil f? en, delt scratch-katalog ($SCRATCH), ikke separate kataloger for hver node! Dette betyr at hvis mer enn ¨¦n prosess eller tr?d skriver ut til disk, m? de bruke forskjellige filnavn, eller legge filene i forskjellige underkataloger.

OpenMP eller Threading

For ? kj?re parallelt p? ¨¦n node ved ? bruke enten threading eller OpenMP, er det eneste du trenger ? huske ? fortelle k?systemet at oppgaven din trenger mer enn ¨¦n kjerne, alt p? samme node. Dette gj?res med --cpus-per-task. Den vil reservere de n?dvendige kjernene p? noden og sette milj?variabelen $OMP_NUM_THREADS. For eksempel:

#!/bin/bash
# Job name:
#SBATCH --job-name=YourJobname
#
# Project:
#SBATCH --account=YourProject
#
# Wall clock limit:
#SBATCH --time=hh:mm:ss
#
# Max memory usage per core (MB):
#SBATCH --mem-per-cpu=MegaBytes
#
# Number of cores:
#SBATCH --cpus-per-task=NumCores

## Set up job environment:
module purge   # clear any inherited modules
set -o errexit # exit on errors

## Copy files to work directory:
cp YourDatafile $SCRATCH

## Mark outfiles for automatic copying to $SLURM_SUBMIT_DIR:
chkfile YourOutputfile

## Run command
cd $SCRATCH
## (For non-OpenMP-programs, you must control the number of threads manually, using $OMP_NUM_THREADS.)
YourCommand YourDatafile > YourOutputfile

--cpus-per-task vil sikre at alle kjerner er allokert p? en enkelt node. Hvis du ber om flere kjerner enn det som er tilgjengelig p? noen node, vil du ikke kunne sende inn jobben. De fleste noder p? Colossus har 64 kjerner.

MPI

For ? kj?re MPI-jobber m? du spesifisere hvor mange oppgaver som skal kj?res (dvs. kjerner som skal brukes), og sette opp ?nsket MPI-milj?. Symbolgenereringen for forskjellige fortran-kompilatorer er forskjellig, derav versjoner av MPI fortran-grensesnittet for GNU, Intel, Portland og Open64. Alle OpenMPI-biblioteker er bygget ved hjelp av gcc.

Du m? bruke module load both for ? kompilere koden og kj?re den. Du b?r ogs? kompilere og kj?re i samme MPI-milj?. Selv om noen MPI-versjoner kan v?re kompatible, er de vanligvis ikke det.

Hvis du trenger ? kompilere C MPI-kode med icc, se OpenMPIs dokumentasjon om milj?variabler som skal settes for ? tvinge mpicc til ? bruke icc.

Den enkleste m?ten ? spesifisere antall oppgaver (kjerner) som skal brukes i en MPI-jobb, er ? bruke sbatch-bryteren --ntasks. For eksempel

#SBATCH --ntasks 10

vil gi deg 10 oppgaver. K?systemet tildeler oppgavene til noder avhengig av tilgjengelige kjerner og minne osv. Et enkelt MPI-jobscript kan da v?re slik:

#!/bin/bash
# Job name:
#SBATCH --job-name=YourJobname
#
# Project:
#SBATCH --account=YourProject
#
# Wall clock limit:
#SBATCH --time=hh:mm:ss
#
# Max memory usage per task:
#SBATCH --mem-per-cpu=Size
#
# Number of tasks (cores):
#SBATCH --ntasks=NumTasks

## Set up job environment:
module purge   # clear any inherited modules
set -o errexit # exit on errors

module load openmpi.gnu

## Set up input and output files:
cp InputFile $SCRATCH
chkfile OutputFile

cd $SCRATCH
srun YourCommand

K?systemalternativer

Ved ? bruke k?alternativet --ntasks i det forrige eksempelet, har vi antatt at det ikke spiller noen rolle hvordan oppgavene dine er allokert til noder. K?systemet vil kj?re oppgavene dine p? noder slik det passer (det vil imidlertid pr?ve ? tildele s? mange oppgaver som mulig p? hver node). For sm? jobber er dette vanligvis greit. Noen ganger kan du imidlertid trenge mer kontroll. I slike tilfeller kan du bruke bryterne --nodes og --ntasks-per-node i stedet for --ntasks:

• --nodes: Hvor mange noder skal benyttes
• --ntasks-per-node: Hvor mange oppgaver skal kj?res p? hver node

For eksempel, for ? kj?re 1 oppgave p? hver av 4 noder, kan du bruke

#SBATCH --nodes=4 --ntasks-per-node=1

Eller for ? kj?re 4 oppgaver p? hver av 2 noder:

#SBATCH --nodes=2 --ntasks-per-node=4

There are more advanced options for selecting cores and nodes, as well. See man sbatch for the gory details.

Der er ogs? mer avanserte alternativer for ? velge kjerner og noder. Se man sbatch for detaljer.

TCP/IP over InfiniBand for MPI

Hvis du har MPI-jobber som tett knyttet opp mot bruk av TCP/IP, har vi noen knep for ? bruke InfiniBand selv for disse. Det er mulig ? kj?re TCP/IP over InfiniBand med langt bedre ytelse enn over Ethernet. Dette gjelder imidlertid kun kommunikasjon mellom beregningsnodene. Ta kontakt med oss hvis du har en slik applikasjon eller ?nsker ? bruke TCP/IP over InfiniBand. Alle noder har to IP-numre ett for Ethernetnet og ett for InfiniBand.

Nyttige kommandoer i MPI script

Hvis du trenger ? utf?re en kommando ¨¦n gang p? hver node i en jobb, kan du bruke

srun --ntasks=$SLURM_JOB_NUM_NODES command

Kombinasjoner av MPI med OpenMP eller threading

Du kan kombinere MPI med OpenMP eller threading, slik at MPI brukes til ? starte flertr?dede prosesser p? hver node. Den beste m?ten ? gj?re dette p? er:

#!/bin/bash
# Job name:
#SBATCH --job-name=YourJobname
#
# Project:
#SBATCH --account=YourProject
#
# Wall clock limit:
#SBATCH --time=hh:mm:ss
#
# Max memory usage per task:
#SBATCH --mem-per-cpu=Size
#
# Number of tasks (MPI ranks):
#SBATCH --ntasks=NumTasks
#
# Number of threads per task:
#SBATCH --cpus-per-task=NumThreads

## Set up job environment:
module purge   # clear any inherited modules
set -o errexit # exit on errors
module load openmpi.gnu

## Set up input/output files:
cp InputFile $SCRATCH
chkfile OutputFile

## Run command
## (If YourCommand is not OpenMP, use $OMP_NUM_THREADS to control the number of threads manually.)
srun YourCommand

Dette f?r srun til ? starte NumTasks "ranks" (prosesser), som hver har NumThreads tr?der. Hvis du ikke bruker OpenMP, m? programmet passe p? ? ikke starte mer enn NumThreads tr?der.

Akkurat som med entr?dede MPI-jobber, kan du f? mer enn ¨¦n "rank" (MPI-prosess) p? hver node. Hvis du trenger mer kontroll over hvor mange "ranks" som startes p? hver node, bruk --ntasks-per-node og --nodes som ovenfor. For eksempel:

#SBATCH --nodes=3 --ntasks-per-node=2 --cpus-per-task=4

vil starte 2 MPI "ranks" p? hver av 3 noder, og hver prosess har lov til ? bruke 4 tr?der.

Jobber som krever store mengder minne

De fleste noder p? Colossus er utstyrt med 64 CPU-kjerner og 502 GiB RAM tilgjengelig for jobber. Det finnes ogs? et par spesielle bigmem-noder med 128 kjerner og 4 TiB-minne, hvorav ca 3955 GiB kan brukes til jobber.

Hvis du trenger mer enn 502 GiB RAM p? en enkelt node, m? du spesifisere  --partition=bigmem for ? f? tilgang til nodene med mer RAM. For eksempel

#SBATCH --ntasks-per-node=16
#SBATCH --mem-per-cpu=50G --partition=bigmem

Regnskap for "hugemem" jobber

For ? sikre maksimal utnyttelse av klyngen, tas minnebruk inn i regnskapet s? vel som cpu-bruk. Minnespesifikasjoner konverteres til "Processor Equivalents" (PE) ved ? bruke en konverteringsfaktor p? ca. 8 GiB/kjerne(*). Hvis en jobb spesifiserer mer enn 8 GiB RAM per oppgave, dvs. --mem-per-cpu=M, hvor M > 8G, vil hver oppgave telle som M / 8G kjerner i stedet for 1 kjerne. For eksempel vil en jobb med --ntasks=2 --mem-per-cpu=16G bli regnet som ? bruke 4 kjerner i stedet for 2.

Grunnen til dette er at store minnejobber gj?r de ?ubrukte? kjernene p? de samme nodene utilgjengelige for andre jobber. For eksempel vil en jobb p? en 502 GiB node som bruker --ntasks=1 --mem-per-cpu=502G i praksis bruke alle kjerner p? noden, og b?r regnskapsf?res som s?dan.

Merk at kun jobber som spesifiserer mer enn 8 GiB per kjerne vil bli p?virket av dette; alle andre jobber vil bli regnskapsf?rt med antall "tasks".

(*) Den n?yaktige verdien av faktoren avhenger av den totale mengden RAM per kjerne i klyngen, og er for ?yeblikket omtrent 8 GiB / kjerne p? Colossus.

GPU jobber

Colossus har 4 GPU-noder med 2 Nvidia Tesla V100 GPUer hver. To er tilgjengelige for alle brukere og 2 er reservert for dedikerte prosjekter. Du kan kj?re jobber p? GPU-nodene slik:

 $ sbatch --account=YourProject_tsd --partition=accel --gres=gpu:1

eller

 $ sbatch --account=YourProject_tsd --partition=accel --gres=gpu:2

avhengig av hvor mange GPUer jobben trenger.

Checkpointing

"Checkpointing" av en jobb betyr at jobben kan stoppes og s? startes et annet sted, og fortsette der den slapp.

Langvarige jobber b?r implementere en form for "checkpointing", ved ? lagre mellomresultater med jevne mellomrom slik at det blir mulig ? starte med de siste mellomresultatene hvis jobben startes p? nytt.

Nyttige sbatch parametre

Parameter	Beskrivelse
--account=project	Spesifiser prosjektet som jobben kj?res under. Denne parameteren er p?krevd.
--begin=time	Start jobben p? et gitt tidspunkt
--constraint=feature	Be om noder med en bestemt funksjon. For ?yeblikket st?ttede funksjoner inkluderer amd, intel, ib, rackN. Hvis du trenger mer enn ¨¦n funksjon, m? de kombineres med & i samme --constraint spesifikasjon, f.eks. --constraint=ib&rack21. Merk: Hvis du pr?ver ? bruke mer enn ¨¦n --constraint spesifikasjon, vil den siste overstyre den tidligere.
--cpus-per-task=cores	Spesifiser antall CPUer (faktisk: kjerner) som skal tildeles for hver oppgave i jobben. Se --ntasks og -ntasks-per-node, eller man sbatch.
--dependency=dependency list	Utsett starten av denne jobben til de spesifiserte avhengighetene er tilfredsstilt. Se man sbatch for detaljer.
--error=file	Send 'stderr' til den angitte filen. Standard er ? sende den til samme fil som 'stdout'. (Merk: $HOME eller ~ kan ikke brukes. Bruk absolutte eller relative stier i stedet.)
--input=file	Les 'stdin' fra den angitte filen. (Merk: $HOME eller ~ kan ikke brukes. Bruk absolutte eller relative stier i stedet.)
--job-name=jobname	Spesifiser jobb navn
--mem-per-cpu=size	Spesifiser mengden minne som kreves per tildelt kjerne. Dette er den normale m?ten ? spesifisere minnekrav p? (se Jobber som krever store mengder minnne). size skal v?re et heltall etterfulgt av "M" eller "G".
--partition=bigmem	Kj?r jobben p? en bigmem node (se Jobber som krever store mengder minnne).
--nodes=nodes	Spesifiser antall noder som skal tildeles. nodes kan v?re et heltall eller et omr?de (min-maks). Dette kombineres ofte med --ntasks-per-node.
--ntasks=tasks	Spesifiser antall oppgaver (vanligvis kjerner, men se --cpus-per-task) som skal tildeles. Dette er den vanlige m?ten ? spesifisere kjerner p? for MPI-jobber.
--ntasks-per-node=tasks	Spesifiser antall oppgaver (vanligvis kjerner, men se --cpus-per-task) som skal tildeles innenfor hver tildelt node. Ofte kombinert med --nodes.
--output=file	Send 'stdout' (and 'stderr' if not redirected with --error) to the specified file instead of slurm-%j.out. Send 'stdout' (og 'stderr' hvis ikke omdirigert med --error) til den angitte filen i stedet for slurm-%j.out. Merk: $HOME eller ~ kan ikke brukes. Bruk absolutte eller relative stier i stedet. Jobb-id skal alltid inkluderes i filnavnet for ? produsere en separat fil for hver jobb (dvs. --output=custom-name%j.out). Dette er n?dvendig for feils?king.
--time=time	Angi en ("wall clock") tidsbegrensning for jobben. time kan v?re hh:mm:ss eller dd-hh:mm:ss. Denne parameteren er p?krevd.
--nice=value	Kj?r jobben med en justert planleggingsprioritet i prosjektet ditt. En negativ "nice" verdi ?ker prioriteten, ellers reduserer den. Justeringsomr?det er +/- 2147483645.