NIIF szuperszámítógépek használata

A szuperszámítógépekről
Az NIIF Intézet szuperszámítógép szolgáltatása tudományos számítási feladatok futtatására, valamint tudományos célú adattárolásra szolgál. A jelenleg integrált szuperszámítógép-rendszer komponensei négy helyszínen találhatók:


 * Debreceni Egyetem
 * NIIFI központ
 * Pécsi Tudományegyetem
 * Szegedi Tudományegyetem

A tudományos számítási feladatok különböző típusainak minél szélesebb körű lefedettsége érdekében az egyes helyszíneken különböző felépítésű gépek találhatók: egy helyszínen SMP/ccNUMA, három helyszínen pedig "fat-node" fürtözött megoldás. Az alrendszereket az NIIFI nagy sávszélességű, alacsony késleltetésű HBONE+ adathálózatán keresztül, ARC grid köztesréteg, valamint harmonizált felhasználói azonosítás segítségével integráljuk egységes elvek mentén elérhető számítási egységgé. Az erőforrás jelenleg Magyarország legnagyobb tudományos számítás céljára felhasználható erőforrása, amely összesen 50 billió lebegőpontos művelet elvégzését teszi lehetővé másodpercenként. A szuperszámítógép-rendszert az NIIFI üzemelteti és fejleszti. A rendszerhez regisztrációt követően, minden olyan személy vagy kutatócsoport hozzáférhet, amely tagintézményi szerződéses kapcsolatban áll az NIIF Intézettel. A gépen megtalálhatók és futtathatók a legkorszerűbb fejlesztőeszközök és tudományos számításra szolgáló alkalmazások, valamint, az NIIF adatközpontban elhelyezett alrendszer kivételével, valamennyi alrendszer kiegészül a számítási feladatok eredményeit megjelenítő vizualizációs eszközökkel.

Hozzáférés a szuperszámítógépekhez
A szuperszámítógépekhez kulcsos SSH használatával lehet hozzáférni. Ajánlott UTF-8 képes terminált használ az ékezetes betűk megjeelenítése érdekében. PUTTY terminál esetén a Window/Translation beállítás alatt a character set-et kell UTF-8-ra állítani.

SSH belépés
ahol a  a felhasználónév, a   pedig a belépéshez használt szupergép neve: budapest, debrecen, pecs, szeged. Nem alapértelmezett kulcs használata a  kapcsolóval lehetséges.

Példa
Belépés a szegedi gépre alice felhasználóként, az SSH privát kulcsot a  fájlból olvasva:

Fájl másolás SCP segítségével
Letöltés a HOME könyvtárból és feltöltés a HOME könyvtárba: scp USER@login.SITE.hpc.niif.hu:FILE FILE scp FILE USER@login.SITE.hpc.niif.hu:FILE

Példa
A szegedi gép HOME könyvtárában lévő  fájl letöltése a helyi gép aktuális könyvtárába:

Adatátvitel rsync segítségével
Nagyobb fájlok ill. könyvtárstruktúrák szinkronizálásához az SSH-t és az rsync-et együtt kell használni. Fel- és leszinkronizálás: rsync -a -e ssh DIRECTORY USER@login.budapest.hpc.niif.hu:/home/USER rsync -a -e ssh USER@login.budapest.hpc.niif.hu:/home/USER/DIRECTORY

Példa
A budapesti gépre szinkronizálom a helyi  könyvtár tartalmát (nem az alapértelmezett kulcsot használva) és a másolás folyamatát nyomonkövetem:

Felhasználói felület
A szupergépek elsődleges felhasználói felülete a Bash shell. Az automatikusan betöltődő NIIF Common Environment (NCE) a PS1 promptot a következőképp állítja be:

Modul környezet
A szupergépekre telepített alkalmazásokat az ún. modul rendszer segítségével lehet használ. A modul rendszer lehetővé teszi egy adott alkalmazás több verziójának használatát is. Feladata a shell környezeti változók helyes beállítása. Normál felhasználók számára az alapértelmezett modul környezet automatikusan betöltődik. Az elérhető modulok listáját a következő paranccsal kapjuk meg: a már betöltött modulok listáját: Alkalmazást a következő paranccsal tölthetünk be: ahol az  a betöltendő modulok space-szel elválasztott listája.

A NIIF által beállított környezeti változókat  parancs listázza ki.

Példa
A Maple, netcfd és az R csomagok betöltése:

Adatok megosztása projekt tagok számára
Fájlok ill. könyvtárak megosztásához használjuk a (fájlrendszer ACL-eket). Az ACL-ekkel a hagyományos unix engedélyeken felül finoman szabályozhatjuk a fájlok és könyvtárak hozzáférési engedélyeit. A következő példában a  könyvtárat osztjuk egy munkatárs számára: $ setfacl -m u:user1:x $HOME $ getfacl $HOME user::rwx user:user1:--x group::r-x mask::r-x other::--- $ cd $ mkdir Shared $ setfacl -m u:user1:rwx $HOME/Shared $ getfacl Shared user::rwx user:user1:rwx group::rwx mask::rwx other::r-x
 * 1) a home könyvtár beállítása
 * 2) user1 user számára belépsi engedély: u:user1:x
 * 1) file: user2/user2
 * 2) owner: user2
 * 3) group: user2
 * 1) Shared könyvtár megosztása
 * 2) user1 számára minden unix jog
 * 1) file: Shared
 * 2) owner: user2
 * 3) group: user2

SLURM ütemező használata
Weboldal: http://slurm.schedmd.com

A szupergépeken CPU óra (gépidő) alapú ütemezés működik. Ez azt jelenti, hogy a fogyasztási időtartamra (hónap) az elérhető maximális gépidő fel van osztva a felhasználók között. Minden UNIX felhasználó egy vagy több számlához (Account) tartozhat. Az ütemező számla egy adott HPC-s projekthez tartozik, hasonló a UNIX csoporthoz. Szupergépes feladatokat csak az egyes számlák terhére lehet indítani. A CPU óra az elhasznált idő (Walltime) és az igényelt processzorok számának szorzata. Például a budapesti gépen 2 db node (48 processzor mag) foglalása 30 percre 48 * 30 = 1440 CPU perc = 24 CPU óra. A CPU órát az ütemező a futás kezdetétől a befejezésig méri.

'''Rendkívül fontos arról meggyőződni, hogy a futtatandó alkalmazás rendesen kihasználja-e a szupergépet. Egy üres vagy rosszul futó job hamar elhasználja a rendelkezésre álló gépidőt. Elfogyasztott gépidő esetén új jobokat már nem lehet indítani, és meg kell várni a számlázási időszak végét. A gépidő limitek (Account Limit) minden hónap elején jóváíródnak.'''

Számláink állapotáról a következő paranccsal kapunk információt:

Példa
A parancs Bob számára a következő táblázatot jeleníti meg. A felhasználó két számlához (foobar,barfoo) is hozzáfér, futatthat a számla terhére. Saját magát megcsillagozva látja a listában. Bobbal mindkét számlán (Account oszlop) Alice is osztozik. A második oszlopban (Usage) az egyes felhasználók elhasznált gépideje, a negyeik oszlopban pedig a számla összesített gépideje látható. Az utolsó két oszlop a maximális (Account Limit) és a még alérhető (Available) gépidőről ad tájékoztatást. Scheduler Account Balance -- --- + --- + - --- User             Usage |          Account       Usage | Account Limit   Available (CPU hrs) -- --- + --- + - --- alice                0 |           foobar           0 |             0           0 bob *               0 |           foobar           0 |             0           0

bob *               7 |           barfoo           7 |         1,000         993 alice               0 |           barfoo           7 |         1,000         993

A gépidő becslése
Nagyüzemi (production) futtatások előtt gépidőbecslést érdemes végezni. Ehhez a következő parancs használható: ahol a  a lefoglalni kívánt node-ok száma, a   pedig a futás maximális ideje.

'''Fontos, hogy a lefoglalni kívánt gépidőt a lehető legpontosabban adjuk meg, mivel az ütemező ez alapján is rangsorolja a futtatásra váró feladatokat. Általában igaz, hogy a rövidebb job hamarabb sorra kerül. Érdemes minden futás idejét utólag az  paranccsal is ellenőrizni.'''

Példa
Alice 2 nap 10 órára és 2 node-ra szeretne foglalást kérni, megnézi van-e elég gépidő a számláján: sestimate -N 2 -t 2-10:00:00

Estimated CPU hours: 2784 Sajnos ebben a hónapban erre már nem telik.

Állapotinformációk
Az ütemezőben lévő jobokról az, a klaszter általános állapotáról az   parancs ad tájékoztatást. Minden beküldött jobhoz egy egyedi azonosítószám (JOBID) rendelődik. Ennek ismeretében további információkat kérhetünk. Feladott vagy már futó job jellemzői:

Minden job egy ún. számlázási adatbázisba (accounting) is bekerül. Ebből az adatbázisból visszakereshetők a lefuttatott feladatok jellemzői és erőforrás-felhasználás statisztikái. A részletes statisztikát a következő paranccsal tudjuk megnézni:

A felhasznált memóriáról a következő parancs ad tájékoztatást:

A lemezhasználatról pedig a

Példa
Az ütemezőben 3 feladat van. Az első egy arrayjob, éppen erőforrásra vár (PENDING). A második egy MPI job, ami 4 node-on fut már 25 perce (TIME). A harmadik egy egy node-os OMP futtatás, éppen most indult el. A feladatik nevei (NAME) egyénileg adható meg. Rövid, informatív neveket érdemes adni. squeue -l

Wed Oct 16 08:30:07 2013 JOBID PARTITION    NAME     USER    STATE       TIME TIMELIMIT  NODES NODELIST(REASON) 591_[1-96]   normal    array    alice  PENDING       0:00     30:00      1 (None) 589   normal      mpi      bob  RUNNING      25:55   2:00:00      4 cn[05-08] 590   normal      omp    alice  RUNNING       0:25   1:00:00      1 cn09

Ennek a 2 node-os batch jobnak a jellemző memóriaterhelés a következő volt: kb. 10GB virtuális és 6.5GB RSS memóriát használt el node-onként. smemory 430

MaxVMSize MaxVMSizeNode  AveVMSize     MaxRSS MaxRSSNode     AveRSS -- -- -- -- -- -- 10271792K          cn06  10271792K   6544524K       cn06   6544524K 10085152K          cn07  10085152K   6538492K       cn07   6534876K

CPU felhasználás ellenőrzése
Nagyon fontos meggyőződni arról, hogy az alkalmazás kihasználja-e a rendelkezésre álló gépidőt. Egy futó alkalmazás a következő paranccsal tudunk monitorozni:

Példa
Ez a job 4 node-on fut. A LOAD csoport a gép általános terheléséről ad információt és kb. a core-ok számával egyezik meg. A helyes felhasználásról a CPU csoport ad tájékoztatást. Ideális esetben a  oszlop értékei 90 fölött vannak. Ez alatt valamilyen probléma lépett fel és a futást érdemes megszakítani. Hostname                    LOAD                       CPU              Gexec CPUs (Procs/Total) [    1,     5, 15min] [  User,  Nice, System, Idle, Wio] cn08   24 (   25/  529) [ 24.83, 24.84, 20.98] [  99.8,   0.0,   0.2,   0.0,   0.0] OFF cn07   24 (   25/  529) [ 24.93, 24.88, 20.98] [  99.8,   0.0,   0.2,   0.0,   0.0] OFF cn06   24 (   25/  529) [ 25.00, 24.90, 20.97] [  99.9,   0.0,   0.1,   0.0,   0.0] OFF cn05   24 (   25/  544) [ 25.11, 24.96, 20.97] [  99.8,   0.0,   0.2,   0.0,   0.0] OFF

Licenszek ellenőrzése
Az elérhető és éppen használt licenszekről a következő parancs ad információt:

Karbantartás ellenőrzése
A karbantartási időablakban az ütemező nem indít új jobokat, de beküldeni lehet. A karbantartások időpontjairól a következő parancs ad tájékoztatást:

Összesített felhasználás
Egy hónapra visszamenőleg az elfogyasztott CPU perceket a következő paranccsal kérhetjük le:

Feladatok futtatása
Alkalmazások futtatása a szupergépeken kötegelt (batch) üzemmódban lehetséges. Ez azt jelenti, hogy minden futtatáshoz egy job szkriptet kell elkészíteni, amely tartalmazza az igényelt erőforrások leírását és a futtatáshoz szükséges parancsokat. Az ütemező paramétereit (erőforrás igények) a  direktívával kell megadni. Az ütemezők összehasonlításáról és a Slurm-ban elérhető direktívákról a következő táblázat ad bővebb tájékoztatást.

Kötelező paraméterek
A következő paramétereket minden esetben meg kell adni: ahol az  a terhelendő számla neve (elérhető számláinkről az   parancs ad felvilágosítást), a   a job rövid neve, a   pedig a maximális walltime idő. A következő időformátumok használhatók: "minutes", "minutes:seconds", "hours:minutes:seconds", "days-hours", "days-hours:minutes" és "days-hours:minutes:seconds".
 * 1) !/bin/bash
 * 2) SBATCH -A ACCOUNT
 * 3) SBATCH --job-name=NAME
 * 4) SBATCH --time=TIME

A jobok feladását a következő parancs végzi:

Sikeres feladás esetén a következő kimenetet kapjuk: Submitted batch job JOBID ahol a  a feladat egyedi azonosítószáma.

A feladat leállítását a következő parancs végzi:

Feladat sorok
A szupergépeken két, egymást nem átfedő, sor (partíció) áll rendelkezésre, a  sor és a   sor. Utóbbi az éles számolásokra való, előbbi fejlesztés és tesztelés céljára használható. A teszt sorban összesen 1 node-ot, maximum fél órára lehet lefoglalni. Az alapértelmezett sor a. A teszt partíciót a következő direktívával lehet kiválasztani:
 * 1) SBATCH --partition=test

A szolgáltatás minősége (QOS)
Lehetőség van alacsony prioritású jobok feladására is. Az ilyen feladatokat bármilyen normál prioritású job bármikor megszakíthatja, cserébe az elhasznált gépidő fele számlázódik csak. A megszakított jobok automatikusan újraütemeződnek. Fontos, hogy olyan feladatokat indítsunk alacsony prioritással, amelyek kibírják a véletlenszerű megszakításokat, rendszeresen elmentik az állapotukat (checkpoint) és ebből gyorsan újra tudnak indulni. A szolgáltatást alapértelmezett minősége, azaz nem megszakítható a futás.

Az alacsony prioritás kiválasztását a következő direktívával tehetjük meg:
 * 1) SBATCH --qos=lowpri

Memória foglalás
A memória a CPU-hoz hasonlóan korlátozott, foglalható erőforrás. A felhasználás mérése a memória / core alapon történik: 1 core óra, 2600 MB órának felel meg. Alapértelmezetten 1 CPU core-hoz 1000 MB memória van rendelve, ennél többet a következő direktívával igényelhetünk: ahol  MB egységben van megadva. Budapesten és Szegeden a maximális memória/core 2600 MB.
 * 1) SBATCH --mem-per-cpu=MEMORY

Email értesítés
Levél küldése job állapotának változásakor (elindulás,leállás,hiba): ahol az  az értesítendő emial cím.
 * 1) SBATCH --mail-type=ALL
 * 2) SBATCH --mail-user=EMAIL

Tömbfeladatok (arrayjob)
Tömbfeladatokra akkor van szükségünk, egy szálon futó (soros) alkalmazást szeretnénk egyszerre sok példányban (más-más adatokkal) futtatni. A példányok számára az ütemező a  környezeti változóban tárolja az egyedi azonosítót. Ennek lekérdezésével lehet az arrayjob szálait elkülöníteni. A szálak kimenetei a  fájlokba íródnak. Az ütemező a feltöltést szoros pakolás szerint végzi. Ebben az esetben is érdemes a processzorszám többszörösének választani a szálak számát. Bővebb ismertető

Példa
Alice felhasználó a foobar számla terhére, maximum 24 órára ad fel 96 db soros jobot. A  direktíva jelzi, hogy tömbfeladatról van szó. Az alkalmazást az  paranccsal kell indítani. Ebben az esetben ez egy shell szkript. srun envtest.sh
 * 1) !/bin/bash
 * 2) SBATCH -A foobar
 * 3) SBATCH --time=24:00:00
 * 4) SBATCH --job-name=array
 * 5) SBATCH --array=1-96

Soros (serial) jobok
Több soros job futtatását a tömbfeladatokhoz hasonlóan kell indítani.

Példa
A következő példában a test sorban 3 egy szálon dutó programot indítunk el. A programok és az inputok lehetnek különbözőek. Fontos, hogy az utolsó parancsot nem kell a háttérben (&) indítani és a wait-tel kell befejezni a job szkriptet. srun -n 1 program input1 & srun -n 1 program input2 & srun -n 1 program input3 wait
 * 1) !/bin/bash
 * 2) SBATCH --job-name=serial
 * 3) SBATCH --time=24:30:00
 * 4) SBATCH -n 3
 * 5) SBATCH --partition=test

MPI feladatok
MPI feladatok esetén meg kell adnunk az egy node-on elinduló MPI processzek számát is. A leggyakoribb esetben ez az egy node-ban található CPU core-ok száma. A párhuzamos programot az  paranccsal kell indítani.

Példa
Bob felhasználó a barfoo számla terhére 2 node-ot, 12 órára foglal le egy MPI job számára. Az egyes node-okon 24 MPI szálat fog elindítani. A program stdout kimenetét a  fájlba irányítja. mpirun ./a.out
 * 1) !/bin/bash
 * 2) SBATCH -A barfoo
 * 3) SBATCH --job-name=mpi
 * 4) SBATCH -N 2
 * 5) SBATCH --ntasks-per-node=24
 * 6) SBATCH --time=12:00:00
 * 7) SBATCH -o slurm.out

CPU binding
Az MPI programok teljesítménye általában javítható a processzek CPU magokhoz kötésével. Ilyenkor a párhuzamos program szálait az operációs rendszer nem ütemezi a CPU magok között, ezért javulhat a memória lokalizáció (kevesebb cache miss). A kötés használata ajánlott. Tesztekkel meg kell győződni, hogy egy adott alkalmazás esetén melyik kötési stratégia adja a legjobb eredményt. A következő beállítások az OpenMPI környezetre vontakoznak. A kötésekről részletes információt a  MPI opcióval kaphatunk. Az indítási parancsok melett a részletes binding információ néhány sora is látható. Fontos, hogy az ütemező task binding-ját nem kell használni!

Kötés CPU magonként
Ebben az esetben az MPI szálak (rank) sorban töltik fel a CPU magokat. Indítási parancs: mpirun --bind-to-core --bycore

[cn05:05493] MCW rank 0 bound to socket 0[core 0]: [B. . . . . . . . . . .][. . . . . . . . . . . .] [cn05:05493] MCW rank 1 bound to socket 0[core 1]: [. B. . . . . . . . . .][. . . . . . . . . . . .] [cn05:05493] MCW rank 2 bound to socket 0[core 2]: [. . B. . . . . . . . .][. . . . . . . . . . . .] [cn05:05493] MCW rank 3 bound to socket 0[core 3]: [. . . B. . . . . . . .][. . . . . . . . . . . .]

Kötés CPU foglalat szerint
Ebben az esetben az MPI szálak váltakozva töltik fel a CPU-kat. Indítási parancs: mpirun --bind-to-core --bysocket

[cn05:05659] MCW rank 0 bound to socket 0[core 0]: [B. . . . . . . . . . .][. . . . . . . . . . . .] [cn05:05659] MCW rank 1 bound to socket 1[core 0]: [. . . . . . . . . . . .][B. . . . . . . . . . .] [cn05:05659] MCW rank 2 bound to socket 0[core 1]: [. B. . . . . . . . . .][. . . . . . . . . . . .] [cn05:05659] MCW rank 3 bound to socket 1[core 1]: [. . . . . . . . . . . .][. B. . . . . . . . . .]

Kötés node-ok szerint
Ebben az esetben az MPI szálak váltakozva töltik fel a node-okat. Lagalább 2 node foglalása szükséges. Indítási parancs: mpirun --bind-to-core --bynode

[cn05:05904] MCW rank 0 bound to socket 0[core 0]: [B. . . . . . . . . . .][. . . . . . . . . . . .] [cn05:05904] MCW rank 2 bound to socket 0[core 1]: [. B. . . . . . . . . .][. . . . . . . . . . . .] [cn06:05969] MCW rank 1 bound to socket 0[core 0]: [B. . . . . . . . . . .][. . . . . . . . . . . .] [cn06:05969] MCW rank 3 bound to socket 0[core 1]: [. B. . . . . . . . . .][. . . . . . . . . . . .]

OpenMP (OMP) feladatok
OpenMP párhuzamos alkalmazásokhoz maximum 1 node-ot lehet lefoglalni. Az OMP szálák számát az  környezeti változóval kell megadni. A változót vagy az alkamazás elé kell írni (ld. példa), vagy exportálni kell az indító parancs előtt:

A következő példában egy taskhoz 24 CPU-t rendeltunk, a 24 CPU-nak egy node-on kell lennie. A CPU-k számát a  változó tartalmazza, és ez állítja be az OMP szálak számát is.

Példa
Alice felhasználó a foobar számla terhére, maximum 6 órára indít el egy 24 szálas OMP alkalmazást. OMP_NUM_THREADS=$SLURM_CPUS_PER_TASK ./a.out
 * 1) !/bin/bash
 * 2) SBATCH -A foobar
 * 3) SBATCH --job-name=omp
 * 4) SBATCH --time=06:00:00
 * 5) SBATCH --ntasks=1
 * 6) SBATCH --cpus-per-task=24

Hibrid MPI-OMP feladatok
Hibrid MPI-OMP módról akkor beszélünk, ha a párhuzamos alkalmazás MPI-t és OMP-t is használ. Érdemes tudni, hogy az Intel MKL-el linkelt programok MKL hívásai OpenMP képesek. Általában a következő elosztás javasolt: az MPI processzek száma 1-től az egy node-ban található CPU foglalatok száma, az OMP szálak ennek megfelelően az egy node-ban található összes CPU core szám vagy annak fele, negyede (értelem szerűen). A jobszkipthez a fenti két mód paramétereit kombinálni kell.

A következő példában 2 node-ot, és node-onként 1-1 taskot indítunk taskonként 24 szállal.

Példa
Alice felhasználó a foobar számla terhére, 8 órára, 2 node-ra küldött be egy hibrid jobot. Egy node-on egyszerre csak 1 db MPI processz fut ami node-onként 24 OMP szálat használ. A 2 gépen összesen 2 MPI proceszz és 2 x 24 OMP szál fut. export OMP_NUM_THREADS=$SLURM_CPUS_PER_TASK mpirun ./a.out
 * 1) !/bin/bash
 * 2) SBATCH -A foobar
 * 3) SBATCH --job-name=mpiomp
 * 4) SBATCH --time=08:00:00
 * 5) SBATCH -N 2
 * 6) SBATCH --ntasks=2
 * 7) SBATCH --ntasks-per-node=1
 * 8) SBATCH --cpus-per-task=24
 * 9) SBATCH -o slurm.out

Maple Grid feladatok
Maple-t az OMP feladatokhoz hasonlóan 1 node-on lehet futtatni. Használatához be kell tölteni a maple modult is. A Maple kliens-szerver üzemmódban működik ezért a Maple feladat futtatása előtt szükség van a grid szerver elindítására is. Ez az alkalmazás licensz köteles, amit a jobszkriptben meg kell adni. A Maple feladat indátását a  paranccsal kell elvégezni.

Példa
Alice felhasználó a foobar számla terhére, 6 órára indítja el a Maple Grid alkalmazást:
 * 1) !/bin/bash
 * 2) SBATCH -A foobar
 * 3) SBATCH --job-name=maple
 * 4) SBATCH -N 1
 * 5) SBATCH --ntasks-per-node=24
 * 6) SBATCH --time=06:00:00
 * 7) SBATCH -o slurm.out
 * 8) SBATCH --licenses=maplegrid:1

module load maple

${MAPLE}/toolbox/Grid/bin/startserver ${MAPLE}/toolbox/Grid/bin/joblauncher ${MAPLE}/toolbox/Grid/samples/Simple.mpl

GPU-k használata
A szegedi szuperszámítógép rendelkezik 2db GPU kártyákkal is felszerelt compute node-dal. A GPU node-okban 2x6db Nvidia Tesla M2070-es kártya található. A GPU-s node-ok külön job sorban található. A GPU-k számát a  direktívával kell megadni.

Példa
Alice felhasználó a foobar számla terhére, 4GPU-n, 6 órára indítja a következő jobot.
 * 1) !/bin/bash
 * 2) SBATCH -A foobar
 * 3) SBATCH --job-name=GPU
 * 4) SBATCH --partition gpu
 * 5) SBATCH --gres gpu:4
 * 6) SBATCH --time=06:00:00

$PWD/gpu_burnout 3600

Saját programok telepítése
A saját fordítású programokat a HOME könyvtáradba kell telepíteni, ezt általában a fordítás előtti lefuttatott configure szkripttel lehet beállítani. Az adott program a $HOME/local alá fog települni. A PATH és egyéb környezeti változókat értelem szerűen kell beállítani. cd $HOME mkdir local (belépés az alklamazás könyvtárába) ./configure --prefix=$HOME/local make; make install

A frontend gépeken felhasználói limitek vannak beállítva. Ezekről a következő paranccsal kapunk információt: A limitek a compute node-okon és az UV-n nincsenek beállítva.

Java JVM heap méret
A memória limit miatt a Java virtuális gépen és fordító nem jól működik, ezért meg kell adni a maximális heap méretét: java -Xmx512m -version javac -J-Xmx512m -version vagy exportálni kell a következő változót: export _JAVA_OPTIONS="-Xms1g -Xmx1g"

Python Numpy és Scipy használat
A numerikus Python használatához a következő csomagokat kell betölteni: A numpy és a scipy csomagok az Intel MKL OpenMP gyorsítását használják. A jobokat az  párhuzamos környezetbe kell elküldeni.

Fordítás
Elérhető fordítók listája

A fordítási paramétereket az NCE környezeti változókból érdemes kiolvasni: NCE_OFLAGS - optimalizációs kapcsolók C és Fortran NCE_FFLAGS - Fortran kapcsolók NCE_CFLAGS - C kapcsolók NCE_LDFLAGS - könyvtárak C és Fortran Az NCE környezeti változó listáját az  paranccsal kérhetjük le.

A budapesti gépen elérhető a PRACE környezet is, amely tartalmaz egy ajánlott kapcsoló és könyvtár összeállítást tartalmaz. A PRACE környezet betöltése: A PRACE környezet az AMD ACML matematikai könyvtárakat használja, amennyiben az Intel MKL-re van szükségünk, akkor a PRACE környezetet nem kell betölteni. A megfelelő MKL kapcsolókat az Intel Link Advisor szerint kell beállítani, pl.: FFLAGS=-openmp -I$(MKLROOT)/include CFLAGS=-openmp -I$(MKLROOT)/include LDFLAGS=$(MKLROOT)/lib/intel64/libmkl_scalapack_lp64.a \ -Wl,--start-group \ $(MKLROOT)/lib/intel64/libmkl_intel_lp64.a \ $(MKLROOT)/lib/intel64/libmkl_intel_thread.a \ $(MKLROOT)/lib/intel64/libmkl_core.a \ $(MKLROOT)/lib/intel64/libmkl_blacs_openmpi_lp64.a \ -Wl,--end-group -lpthread -lm

OpenMP
Az OpenMP paraméterket környezeti változókon keresztül kell beállítani. Az  párhuzamos SGE környezet az OpenMP szálak számát beállítja. Tovább környezeti változókat az LLNL OpenMP oldalán találtok.

MPI
Az alapértelmezett MPI könyvtár az Open MPI. Ajánlott optimalizációs kapcsolók (CPU binding):

SGI UV Pécs
A pécsi gépen csak SMP vagy MPI programok futtatása engedélyezett. Minimálisan 12 szálat lehet lefoglalni. A foglalás alapegysége a numa node, ami 2x6 processzort és 60GB memóriát tartalmaz. Érdemes 12 többszörösével számolni a lefoglalalndó szálakat, pl.: 12, 24, 48, 96... Ha 2 hatványaira van szükségünk, akkor az SGE foglalást a legközelebbi 12-es szálszámmal kérjük, és az MPI-t vagy az OMP paraméterezzük 2^n szerint.

Az alapértelmezett MPI könyvtár az SGI MPT. Ez a könyvtár biztosítja a legjobb teljesítményt az UV gépen. A felhasználói programokat ehhez a könyvtárhoz kell fordítani. Fordításhoz az Intel Link Advisor-t érdemes használni. Az ajánlott fordítás opciók:

MPI és OpenMP fordítási opciók
Ebben az esetben az MKL műveletek OpenMP szálasíthatók, a program hibrid MPI és OMP módban is tud üzemelni.

MPI SGE job szkript példa
Az `` helyére kell írni a futtatandó programot és paramétereit. A `dplace` egy SGI előtétprogram, ami az MPI szálak ideális CPU elosztását végzi, megadása javasolt, mert általában javítja a teljesítményt.

OMP SGE job szkript példa
Az `omplace` egy SGI előtétprogram, ami az OpenMP szálak ideális CPU elosztását végzi, megadása javasolt, mert általában javítja a teljesítményt.

Monitorozás
A jobhoz rendelt cpusetet (CPU és memória szelet) a következő parancsokkal lehet megfigyelni. A grafikonokhoz  átirányítás szükséges. A processzorterhelés grafikonján négy adat szerepel: zöld - hasznos, felhasználói terhelés, sárga - üresjárat , kék és piros - káros rendszerterhelés. Egy HPC program akkor fut "jól", ha a zöld, felhasználói terhelés maximális, a többi pedig minimális. Ideális esetben a grafikonon egyenes zöld vonalak láthatók. Nem egyenes ("ugráló") grafikon a terhelés nem egyenletes elosztására utal, ezen a CPU binding (dplace, omplace parancsok használata) általában segít.

Processzor terhelés numa node-onként (6 core), az ideális terhelés 6-nál (600%) van:

Processzor terhelés CPU-nként, az ideális terhelés 1-nél (100%) van:

Memória terhelés numa node-onként, a maximális terhelés 30 GB-nál van, ami core-onként 5GB-nak felel meg:

Tesztelés Linpack-kal
A monitorozást egy Linpack teszt segítségével érdemes kipróbálni. A következő parancsokkal előkészítjünk egy Linpack teszt futást a  sorban: A visszakapott jobid-vel hívjuk meg a monitor parancsot: A képen látható ábráknak megfelelő terhelési grafikonokat kell kapnunk. A grafikonok jellege más HPC alkalmazások esetén is ilyennek kell legyen ("egyenes" zöld vonal).