Od února 2022 je spouštění úloh na výpočetních uzlech clusteru Kraken možné výhradně přes frontový systém ([[https://slurm.schedmd.com/documentation.html|SLURM]]). Výpočetní uzly nejsou samostatně dostupné ze sítě. Pro připojení ke clusteru, přípravu a zadávání úloh do frontového systému, je vyhrazen administrativní uzel "kraken".

<wrap em>Administrativní uzel není určen k běhu výpočtů</wrap>, užívejte ho především k práci s daty, zadávání úloh do front a kompilaci vlastních programů. Paralelní úlohy mimo fronty spouštět nelze. Pro výpočetně nenáročné paralelní programy (např. Paraview) je určena fronta "NoCompute", která běží jen na administrativním uzlu (ten má kvůli zpracování velkých dat navýšenou RAM na 320GB).



Aktuální vytížení clusteru zobrazuje, kromě [[computing:cluster:fronty:start#zakladni_prikazy|příkazů systému SLURM]], příkaz

''freenodes''

{{:computing:cluster:fronty:computing:cluster:fronty:freenodes.png?direct&400|}}

**Uživatelé zadáním úlohy do fronty přenechávají spuštění výpočtu frontovému systému. Úloha je do fronty zařazena v pořadí dle interních priorit systému a čeká na spuštění. Frontový systém úlohu spustí hned jak jsou dostupné výpočetní kapacity, <wrap em>uživatelé proto dostupnost výpočetní kapacity sami sledovat nemusí</wrap>, mohou se z clusteru odhlásit a vyčkat na dokončení výpočtu (lze nastavit i notifikační email, viz [[computing:cluster:fronty:start#parametry_prikazu_srun_a_sbatch|Přehled příkazů]]).**

Níže naleznete základní popis práce s frontovým systémem (SLURM), specifika spouštění konkrétních aplikací jsou na samostatných stránkách:
  * [[computing:cluster:fronty:abaqus|Abaqus]]
  * [[computing:cluster:fronty:ansys|Ansys (Fluent)]]
  * [[computing:cluster:fronty:comsol|Comsol]]
  * [[computing:cluster:fronty:matlab|Matlab]]
  * [[computing:cluster:fronty:openfoam|OpenFOAM]]
  * [[computing:cluster:fronty:paraview|Paraview]]
  * [[computing:cluster:fronty:pmd|PMD]]


====== Frontový systém SLURM ======
Frontový systém se stará o optimální využití clusteru, přináší řadu nástrojů pro zadávání úloh, jejich kontrolu a paralelizaci. Všechny úkony provádíme po přihlášení na administrativní uzel "kraken" (ssh username@kraken).

Kompletní dokumentace je na adrese [[https://slurm.schedmd.com|slurm.schedmd.com]]

==== Základní příkazy: ====

=== Spouštění úloh ===
K dispozici jsou 2 příkazy pro zařazení úlohy do fronty, ''srun'' a ''sbatch'':
  srun <parametry> <spouštěný_program> <parametry_spouštěného_programu>
//Klíčový příkaz pro zadání úlohy do fronty.// Pro paralelní úlohy nahrazuje příkaz "mpirun" (mpi knihovny v modulech proto ani příkaz mpirun nenabízí..).\\
''srun'' v této podobě vyžádá prostředky dle ''<parametry>'' a program na nich spustí. Spouštíte-li **ne**paralelní úlohu, ponechte parametr ''-n 1'' (výchozí), zvolíte-li vyšší hodnotu, neparalelní program se spustí n-krát! 
  sbatch <script_file>
//Zadání úlohy do fronty dle připraveného skriptu, viz příklady níže. Součástí skriptu pro paralelní úlohy bývá řádka s příkazem "srun" (komerční kódy bývají spouštěny bez //srun//, podobně jako kódy).// Nejběžnější způsob pro zadávání úlohy do fronty je právě sbatch+skript.

=== Řízení úloh ===

  sinfo
//Vypíše přehled front a jejich aktuální využití.// 

  squeue
//Vypíše informace o běžících úlohách ve frontovém systému.//

Význam zkratek ve výpisu //squeue// ([[https://curc.readthedocs.io/en/latest/running-jobs/squeue-status-codes.html|kompletní přehled zde]]):

- ve sloupci "ST" (status): **R** - running, **PD** - pending (čeká na alokaci výp. zdrojů), **CG** - completing (část procesů je dokončena, ale některé jsou stále aktivní),...

- ve sloupci REASON: **Priority** - ve frontě je/jsou úloha/y s vyšší prioritou, **Dependency** - úloha čeká na dokončení úlohy v závislosti a bude spuštěna poté, **Resources** - úloha čeká na uvolnění potřebných výp. zdrojů,...


  scancel <number>
//Ukončí úlohu <number> zařazenou ve frontě.//

=== Informace o uživateli ===

  sacct
//Vypíše informace o úlohách uživatele (včetně historie).//


{{:computing:cluster:fronty:slurm_command_summary.pdf|Seznam příkazů s parametry v PDF dokumentu.}}
===== Spouštění úloh =====

Úlohy je možné spouštěn na více uzlech, ale vždy jen na jedné části serveru kraken:

  * část **M** - stroje kraken-m1 až m10 (všichni uživatelé)
  * část **L** - stroje kraken-l1 až l4 (omezený přístup)

Úlohy lze spouštět:

  * přímo z řádky příkazem ''srun''
  * pomocí skriptu příkazem ''sbatch''


==== Pokyny ke spouštění úloh ====


  * <wrap hi>Úloha musí vždy běžet pod nějakou frontou (partition).</wrap> Pokud není zadána žádná fronta, je použita Mexpress. Seznam definovaných front je uveden níže.
  * Zadáním fronty je definován časový limit běhu. 
  * Úlohám ve frontách express a short nelze pomocí ''-''''-time'' zadat delší dobu běhu. Defaultní čas front long je nastavený na 1 týden, ale umožňují běh až 2 týdny, např. 9 dní a 5 hodin zadáme „''-p Llong'' ''-''''-time=9-05:00:0''“.
  * Slurm při zařazení do fronty čekajících úloh upřednostní úlohu a uživatele, který cluster méně vytěžuje. Není proto výhodné deklarovat delší čas výpočtu, než je nezbytně nutné.


==== Předdefinované fronty a časové limity ====

Na clusteru Kraken je k dispozici 6 front ("partition") rozdělených dle délky běhu úlohy (express, short, long) a části clusteru ("Mxxx" a "Lxxx"). Nespecifikuje-li uživatel frontu přepínačem ``-````-partition`` užije se defaultní hodnota (Mexpress):
^  cluster part  ^  partition  ^  node   ^  time limit  ^
|  M (nodes kraken-m[1-10])  |  **Mexpress**  |  kraken-m[1-10]  |  6 hours  |
|  :::  |  Mshort  |  kraken-m[1-10]  |  **2 days**  |
|  :::  |  :::  |  :::  |  3 days  |
|  :::  |  Mlong   |  kraken-m[3-6],kraken-m8  |  **1 week**  |
|  :::  |  :::  |  :::  |  2 weeks  |
|  L (nodes kraken-l[1-4])  |  Lexpress  |  kraken-l[1-4]  |  6 hours  |
|  :::  |  Lshort  |  kraken-l[1-4]  |  2 days  |
|  :::  |  Llong  |  kraken-l[1-4]  |  **1 week**  |
|  :::  |  :::  |  :::  |  2 months (max)  |
|  admin node only  |  NoCompute  |  kraken  |  **1 hour**  |
|  :::  |  :::  |  :::  |  8 hours  |
*bold=default

Detaily nastavení lze zobrazit také příkazem
  scontrol show partition [partition_name]

==== Parametry příkazů ''srun'' a ''sbatch'' ====


Běh programu se řídí pomocí parametrů. U příkazu ''srun'' se zadávají přímo do příkazové řádky, u příkazu ''sbatch'' se zapisují do spouštěcího skriptu. Ve skriptu je před každým parametrem zapsán identifikátor ''#SBATCH''.

Volby můžeme zadávat ve dvou tvarech, buď plný tvar ''-''''-ntasks=5'' (dvě pomlčky a rovnítko) nebo zkráceně ''-n 5'' (jedna pomlčka a mezera).

^  volba  ^  popis  ^  příklad  ^
|  ``-J``, ``-````-job-name=<jobname>``  |  Job name, shown e.g. in output of //squeue//  |  ``-J my_first_job``  |
|  ``-p``, ``-````-partition=<partition_names>``  |  Request a specific partition for the resource allocation  |  ``-p Mshort``  |
|  ``-n``, ``-````-ntasks=<number>``  |  Number of resources (~cores) to be allocated for the task  |  ``-n 50``  |
|  ``-N``, ``-````-nodes=<nodes>``  |  Number of nodes to be used  |  ``-N 3``  |
|  ``-````-mem``  |  Job memory request  |  ``-````-mem=1gb``  |
|  ``-o``, ``-````-output=<filename>``  |  Name of file where slurm will output  |  ``-o out.txt``  |
|  ``-e``, ``-````-error=<filename>``  |  standard error to file  |  ``-e err.txt``  |
|  ``-````-mail-user=<user>``  |  User to receive email notification of state changes as defined by --mail-type  | ``-````-mail-user=my@email``  |
|  ``-````-mail-type=<type>``  |  Send email with BEGIN, END, FAIL, ALL,...  |  ``-````-mail-type=BEGIN,END``  |
|  ``-````-ntasks-per-node=<ntasks>``  |  Request that ntasks be invoked on each node  |    |
|  ``-t``, ``-````-time=<time>``  |  Set a limit on the total run time of the job allocation (days-hours:minutes:seconds)  |  ``-t 1:12``  |
|  ``-w``, ``-````-nodelist=<node_name_list>``  |  Request a specific list of hosts  |  ``-w kraken-m2,kraken-m[5-6]``  |
|  ``-x``, ``-````-exclude={<host1[,<host2>...]}``  |  Request that a specific list of hosts not be included in the resources allocated to this job  |  ``-````-exclude=kraken-m[7-9]``  |


Do jmen souborů výstupu (output, error) lze začlenit proměnné jako jméno nodu (%N), číslo úlohy (%J), jméno uživatele (%u), apod... Výpis standardní chyby zadaný ve skriptu ''#SBATCH -e slurm.%N.%J.%u.err'' bude v souboru ''slurm.kraken-m123.12345.username.err''

Začátek běhu nově zadávané úlohy lze podmínit např. dokončením úlohy již běžící
``sbatch --dependency=after:123456:+5 myjob.slurm``,
123456 je zde číslo úlohy (dle výpisu squeue) a "+5" značí prodlevu 5 minut od ukončení předchozí a započetí nové úlohy.

Kompletní seznam parametrů naleznete např. na stránce [[https://slurm.schedmd.com/sbatch.html|Slurm-sbatch]].

\\
\\
===== Příklad: kompilace paralelní úlohy a zadání do fronty =====
V adresáři /home/SOFT/modules/HelloMPI/ najdete připravený zdrojový kód jednoduchého paralelního programu pro výpočet čísla π a skript pro jeho zadání do systému front SLURM. Po zkopírování do vlastního adresáře můžete zkoušet nastavení front v souboru //slurm.sh// i náročnost výpočtu resp. přesnost výsledku, tj. parametr //n// ve zdrojovém souboru //pi.c// .

=== kompilace ===

Nejprve adresář zkopírujeme do našeho lokálního adresáře

  cp -r /home/SOFT/modules/HelloMPI/ ./

do adresáře vstoupíme
  cd HelloMPI

Adresář by měl obsahovat 2 soubory, zdrojový "pi.c" a skript "slurm.sh"
  ls
  
Ke kompilaci programu budeme potřebovat příkaz "mpicc". Ten není dostupný ze systému, ale poskytne nám ho některý z modulů mpi knihoven (openmpi, mpich, intel-mpi, ...), např.
  
  ml openmpi

Po načtení modulu zvolené mpi knihovny máme k dispozici příkaz mpicc, s jehož pomocí program zkompilujeme

  mpicc pi.c -o pi  
  
V adresáři se nám nyní objevil spustitelný soubor "pi"

  ls
  
Program "pi" zařadíme do fronty buď pomocí příkazu "srun" nebo "sbatch <script>":
  
== srun ==
Všechny volby vypíšeme jako jeden příkaz //srun//
  srun -n 6 -N 2 pi

Slurm spustí program //pi// na 6 jádrech dvou nodů.
**POZOR: //srun// nahrazuje kvůli kompatibilitě s frontami SLURM v systému příkaz //mpirun//, který běžně poskytují samotné MPI knihovny, proto jsou mpi knihovny v modulech instalovány bez příkazu //mpirun//, ten není dostupný ani po načtení modulu! Pro běh paralelní úlohy je nutné použít příkaz //srun//.**

Místo psaní příkazu //srun// a mnoha parametrů bývá výhodné použít
== skript pro sbatch == 
Přepínače pro //srun// lze mít sepsány v souboru, který předáme příkazu //sbatch//. Jen proměnné příslušející frontovému systému jsou uvedeny //#SBATCH//, jinak jde o příkazy pro příkazovou řádku.

Obsahem souboru "slurm.sh" z adresáře HelloMPI je tak:

  #!/bin/bash
  #
  #SBATCH --job-name=HelloMPI_Pi
  #SBATCH --output=HelloMPI_Pi_log.txt 
  #SBATCH -n 6
  #SBATCH -N 2
  srun pi

Předání úlohy systému:
  sbatch slurm.sh
  
Úpravou souboru slurm.sh můžete volně testovat příkazy uvedené v tabulce výše.

Soubor pro //sbatch// může obsahovat i obecné příkazy pro příkazovou řádku. Rozšíříme-li předchozí:

  .
  .
  .
  #SBATCH -N 2
  echo "PI: starts in folder"
  pwd
  srun pi
  echo "PI:finished"
  mkdir Folder2
  cd Folder2
  echo "PI-second run in folder"
  pwd
  srun ../pi
  cd ../
  ls  
  
Veškeré výpisy do příkazové řádky, jak samotného programu //pi// tak příkazů //echo// a //pwd// naleznete v souboru HelloMPI_Pi_log.txt, zadaném výše pomocí #SBATCH --output
****