Einführung in die Rechendienste - RRZN

Computedienste am 

Rechenzentrum 

Scientific Computing Gruppe 

css@rrzn.uni-hannover.de 

Computedienste am Rechenzentrum Scientific Computing Gruppe | 7. November 2013 1

Inhalt 

1 Zugang 

2 Arbeitsablauf 

3 Verfügbare Rechenleistung 

4 Anwendungen und Software 

5 Die Modules-Umgebung 

6 Benutzung des Batchsystems 

7 Beispiel-Batchskripte 

8 Dateisysteme 

9 Wenn Fehler auftauchen. . . 

10 Informationslinks 

11 Kontaktinformationen 


Skizze des Clustersystems 


Zugang–Accounts beantragen 

Ein »Projekt« ist vorhanden: 

Der Projektleiter beantragt einen neuen Account über die BIAS Webseite: 

https://bias.rrzn.uni-hannover.de 

Kein vorhandenes »Projekt«: 

ORG.BEN4 ausfüllen 

danach Account über BIAS erstellen 

Tipps: 

Beantragter Benutzername soll den Namen des Nutzers abbilden 

Mailadresse des Nutzers angeben 


Zugang–zum System 

ssh login-node.rrzn.uni-hannover.de 

(Zugangsknoten: Orac und Avon) 

Hier kann man: 

Rechenjobs vorbereiten 

Batchskripte vorbereiten 

Rechenjobs in die Queue (Jobwarteschlange) schicken 

Kleine Tests laufen lassen 

Den Queuestatus abfragen 

Rechenergebnisse sichten 

Dateien in das Archivsystem kopieren 

Dateien zum Arbeitsplatzrechner kopieren 

NICHT für Produktionsläufe: Maximale Laufzeit 30 Minuten, danach 

werden Prozesse abgebrochen 

Alle Anwendungen, Compiler und Tools sind verfügbar 


Zugang–zum System (Windows; grafische Oberfläche) 

NX 

Kostenlos (frei verfügbar) 

Sehr schnell, kann über langsame Leitungen benutzt werden 

http://www.rrzn.uni-hannover.de/cluster-zugang.html#c15446 

X-Win32 

Kosten: 10 e 


XMing 

Kostenlos (Open-Source-Software) 

Benutzt PuTTY für eine verschlüsselte Verbindung zu den Loginknoten 



Zugang–zum System (Windows; weitere Software) 

PuTTY: Nutzung mit der Kommandozeile auf den Loginknoten 


Benutzt eine SSH (Secure-Shell) verschlüsselte Verbindung 


FileZilla: Dateien transferieren 


Bedienung über grafische Oberfläche 

http://filezilla-project.org/ 

Dokumentation: 

http://www.rrzn.uni-hannover.de/cluster-zugang.html 


Arbeitsablauf 

Dateien vom Arbeitsplatzrechner auf einen der Loginknoten kopieren 

Sicher stellen, dass das Programm funktioniert 

Batchskript schreiben 

Batchskript submittieren; Job in die Warteschlange absetzen 

⇒ qsub 

Jobstatus überprüfen 

⇒ qstat -a 

http://www.rrzn.uni-hannover.de/betriebsstatus.html 

Überflüssige Daten löschen 

Optional: Ergebnisse zum Arbeitsplatzrechner zurückkopieren 

Optional: Ergebnisse ins Archivsystem kopieren 

⇒ Account zum Archiv muss über BIAS freigegeben werden 

http://www.rrzn.uni-hannover.de/batchsystem.html 


Verfügbare Rechenleistung 

3 Cluster (für Jobs, die viele CPUs brauchen) 

Tane: 96 Knoten; je 12 Kerne á 2.9 GHz; 48 GB 

Paris: 11 Knoten; je 8 Kerne á 3 GHz; 64 GB 

Taurus: 54 Knoten; je 12 Kerne á 2.66 GHz; 48 GB 

14 SMP Rechner (für Jobs, die viel Hauptspeicher brauchen) 

Lucky: 24 Kerne á 2.6 GHz; 256 GB 

SMP: 18 Knoten; je 24 Kerne á 2.0 GHz; 256 GB 

Centaurus: 32 Kerne á 2.7 GHz; 512 GB 

Helena: 160 Kerne á 2.0 GHz; 640 GB 

http: 

//www.rrzn.uni-hannover.de/scientific_computing.html 


Verfügbare Rechenleistung (fort.) 

Sehr große Projekte können auf dem HLRN rechnen 

Gesondertes Antragsverfahren 

»Schnupperaccounts« sind möglich 

http://www.hlrn.de 


Steigende Rechenleistung 

Rechenleistung des Clustersystems 

Rechenleistung (GFlops) 

3 

2 

1 

Rechenleistung 

Rechenleistung/Watt 

400 

300 

200 

100 

Rechenleistung/Watt (MFlops/W) 

0 

01.2008 

·10 4 Datum 

07.2008 

02.2009 

08.2009 

03.2010 

09.2010 

04.2011 

11.2011 

05.2012 

0 


Anwendungen und Software 

Es gibt eine Vielfalt von Anwendungen und Software auf dem 

Clustersystem 

Chemie 

Biologie 

Ingenieurwissenschaften 

Numerik 

Mathematik 

Physik 

Statistik 

Wirtschaftswissenschaften 

Parallelisierungswerkzeuge 

Softwareentwicklung 

Visualisierung 

Die »Modules«-Umgebung erleichtert die Benutzung 

Das module-Kommando initialisiert die richtige Umgebung für die 

jeweilige Anwendung 


Anwendungen–Physik 

Anwendung Gebiet Modulname 

Comsol Multiphysik comsol 

Matlab Matrizen und allgemeine Numerik matlab 

Octave Matrizen und allgemeine Numerik octave 

QuTiP Quanteninformation qutip 

Bild: Trajektorien für ein neues 3D-Elektronenmikroskop (COMSOL) | Renke Scheuer, Institut für Mess- und Regelungstechnik, LUH 


Anwendungen–Mathematik 


GAMS Mathematische Optimierung gams 

Maple Symbolische Mathematik maple 

Mathematica Symbolische Mathematik mathematica 


Anwendungen–Wirtschaftswissenschaft und Statistik 


R Statistik und Grafik R 

SAS Statistische Analyse, Data-Mining sas 


Anwendungen–Chemie 


CPMD Molekulardynamik cpmd 

Crystal Elektronische Struktur-Berechnung crystal 

GAMESS-US Allgemeine ab initio Quantenchemie gamess_us 

Gaussian Elektronische Struktur-Berechnung gaussian 

Gromacs Molekulardynamik gromacs 

MSINDO Molekulardynamik msindo 


Anwendungen–Biologie 


Biopython Werkzeuge für biologisches Rechnen biopython 

Blat Schnelle Sequenzsuche blat 

Bowtie Genesequenzen Anordner bowtie 

BWA Burrows-Wheeler Anordner bwa 

Oases Transcriptome Assemblierung für kurzes oases 

Lesen 

TGI Cluster Tool EST/mRNA Datensätzen in Clustern sortieren 

tgicl 

Velvet Gen-Sequenz Anordung velvet 


Anwendungen–Ingenieurwissenschaft 


Abaqus Finite Element Simulationen abaqus 

ANSYS Multiphysik ansys 

CFX Fluiddynamik cfx 

Fluent Fluiddynamik fluent 

Gambit Präprocessing (Geometrie/Meshes) gambit 

HFSS Elektromagnetisches Feld Simulationen hfss 

Marc Finite Element Simulationen marc 

Maxwell Elektromagnetische Feld-Simulationen maxwell 


Anwendungen–Ingenieurwissenschaft (fort.) 


Nastran Finite Element Simulationen nastran 

OpenFOAM Fluiddynamik openfoam 

Patran Prä- und Postprozessor für CAE Simulationen patran 

Creo CAD/CAE Entwurfs- und Entwicklungswerkzeug 

creo/proe 

SELFE 3D Ozeansimulation selfe 

StarCCM+ Fluiddynamik starccm 

StarCD Fluiddynamik starcd 

Bild: Wasserspiegelauslenkung und Salinität im Weserästuar | Anna Zorndt, Franzius Institut, LUH 


Anwendungen–Simulationspakete 

Anwendung Beschreibung Modulname 

Harminv Waveform harmonic inversion harminv 

Meep FDTD simulations meep 


Anwendungen–Visualisierung 


Blender 3D Grafik blender 

Gnuplot Allgemeine Datenvisualisierung gnuplot 

Paraview Allgemeine und 3D Datenvisualisierung paraview 

Povray »Persistence of Vision« Raytracer povray 

QtiPlot Schnelle Datenvisualisierung qtiplot 

VTK Visualisierungs Tookit vtk 


Compiler 

Anwendung Sprachen Modulnamen 

GNU C/C++, Java, Fortran gcc, g++, gcj, gfortran 

Intel C/C++, Fortran icc, ifort, 

intel.compiler 

PGI C/C++, Fortran pgi 

Sun Java Java sun-java 

Solaris Studio C/C++, Fortran solstudio 

Nvidia CUDA C cudatoolkit 


Numerische Bibliotheken 

Bibliothek Gebiet Modulnamen 

Geospatial Data Datenverarbeitung gdal 

Abstraction Library (GDAL) 

Gnu Scientific Library (GSL) Allgemeine Numerik gsl 

FFTW 

Fourier- 

fftw 

Transformation 

Intel Math Kernel Library (MKL) Allgemeine Numerik imkl 

LAPACK/BLAS Lineare Algebra lapack, blas 

Multi-precision complex arithm. Complex Arith. mpc 

Multi-precision floating point Floating Point Arith. mpfr 

Qhull 

Computationale 

Geom. 

qhull 


Allgemeine Bibliotheken und Anwendungen 

Bibliothek Gebiet Modulnamen 

L A TEX Textbearbeitung latex 

libctl Controlefile-Bibliothek libctl 

PROJ Cartografische Projektionen proj 

Xerces XML-Bearbeitung xerces-c 


MPI-Implementierungen 

MPI – das Message Passing Interface – ist eine Bibliothek für die 

Kommunikation zwischen Prozessoren, um Programme in fast beliebigen 

Konfigurationen parallel laufen zu lassen 

Implementierung Beschreibung Modulname 

MPICH2 Standard MPICH Installation mpich2 

MVAPICH MPICH für Infiniband optimiert mvapich2 

Intel MPI Intels Implementierung des MPI impi 

OpenMPI OpenMPI openmpi 

PGI-MPICH MPICH mit PGI Compiler übersetzt pgi-mpich 

PGI-MVAPICH MVAPICH mit PGI Compiler übersetzt pgi-mvapich 

MPI funktioniert nicht automatisch; muss programmiert sein 


Debugger und Profiler 

Anwendung Beschreibung Modulname 

Valgrind Call Graph und Speicheranalyse valgrind 

kCachegrind Grafische Oberfläche zu Valgrind kcachegrind 

Valkyrie Grafische Oberfläche zu Valgrind valkyrie 

Totalview Paralleler Debugger totalview 

Intel Trace Analyser Profiler itac 

VTune Profiler vtune 

MPE MPI-Programm-Profiler mpe2-impi 

Scalasca Parallelprogramm-Profiler scalasca 

Intel Debugger 

idb 

GNU Debugger 

gdb 


Verwenden der Modules-Umgebung 

Zuerst muss die Modules-Umgebung initialisiert werden 

Initialisierung passiert normalerweise beim Login automatisch 

Initialisierung innerhalb eines Batchjobs: 

#!/bin/bash -login 

in die erste Zeile eines Batchskripts. 

Falls das module-Kommando nicht bekannt ist, muss man die Umgebung 

explizit mit einem der folgenden Kommandos intialisieren 

Im Allgemeinen: 

source $MODULESHOME/init/`basename $SHELL` 

Mit ksh, bash und csh funktioniert auch: 

. $MODULESHOME/init/ksh 

. $MODULESHOME/init/bash 

. $MODULESHOME/init/csh 

Der Punkt und das Leerzeichen vorne sind wichtig!!! 

http://www.rrzn.uni-hannover.de/modules.html 


Kommandos der Modules-Umgebung 

Alle Module anzeigen lassen 

$ module avail 

Ein Modul (oder mehrere) laden 

$ module load 

Ein Modul entladen 

$ module unload 

Bereits geladene Module zeigen 

$ module list 

Informationen über ein Modul zeigen 

$ module show 

Hilfe und detaillierte Informationen über ein Modul zeigen 

$ module help 


Batchsystem 

Ein Batchsystem ist ein automatisches System, um Rechenjobs fairen Zugang 

zu den Ressourcen eines Clusters zu währen. Jobs werden von einem zentralen 

Ort zum Batchsystem geschickt (»submittiert«) und in eine Warteschlange 

(auch »Queue« genannt) gestellt. Ein Scheduler verteilt die Jobs nach einem 

vorgegebenen Priorisierungsalgorithmus auf die vorhandenen Ressourcen, um 

möglichst viel Durchsatz zu erzielen. 

Simulationen (Rechenjobs) werden mit einem »Batchskript« in die Queue 

abgeschickt. Ein Batchskript ist eine Textdatei, die die Ressourcen (wie 

Rechenzeit, Hauptspeicher und CPU-Anzahl) beschreibt, die der Rechenjob für 

seinen Lauf benötigt. Das Batchskript enthält auch die Kommandos, die man 

auf der Konsole absetzen würde, um den Job laufen zu lassen. Diese 

Kommandos werden auf dem entsprechenden Rechenknoten automatisch 

durchgeführt. 



Anatomie eines Batchskripts 

#!/bin/bash beschreibt, welche Shell für die Ausführung des Skriptes 

verwendet werden soll 

Optionen ans Batchsystem übergeben 

Zeilen fangen mit #PBS an 

Beschreiben u.a. die Anforderungen des Jobs, welche Warteschlange 

verwendet werden soll, usw. 

Kommandos, die die Simulation/den Rechenjob vorbereiten und 

durchführen, z.B.: 

Nötigenfalls die Modules-Umgebung initialisieren 

mit #!/bin/bash -login unnötig 

Module laden 

Umgebungsvariablen setzen 

In das Verzeichnis wechseln, in dem gerechnet werden soll 

Das Programm aufrufen 

Grundsätzlich wird alles nach einem ‘#’ (Kommentarzeichen) ignoriert 

Ausnahmen: 

#! in der ersten Zeile 

PBS-Optionen 


Ein simples Batch-Skript 

1 #!/bin/bash -login 

2 #PBS -N job_name 

3 #PBS -M ich@meine.mail.adresse 

4 #PBS -m ae 

5 #PBS -j oe 

6 #PBS -l nodes=1:ppn=1 

7 #PBS -l walltime=00:10:00 

8 #PBS -l mem=3gb 

9 

0 # show which computer the job ran on 

1 echo "Job ran on:" $(hostname) 

2 

3 # change to work dir: 

4 cd $BIGWORK 

5 

6 # run the program 

7 ./hello 


PBS-Optionen 

#PBS -N Name des Jobs 

#PBS -M Mailadresse des Nutzers 

#PBS -m ae 

Mail an Nutzer senden; beim Jobende (’e’) oder -abbruch (’a’) 

#PBS -j oe 

Zusammenführen (»join«) von Standardausgabe (’o’) und 

Fehlerprotokoll (’e’); (STDOUT und STDERR) 

#PBS -l nodes=:ppn= Knoten, Prozessorkerne je Knoten anfordern 

#PBS -l walltime= Maximale Laufzeit des Jobs (HH:MM:SS) 

#PBS -l mem= Gesamthauptspeicher des Jobs anfordern 

z.B. 3600mb, 10gb 

#PBS -q Name der Warteschlange (Queue) 

z.B. all, test, helena 

#PBS -W x="PARTITION:" Name der Clusterpartition (optional) 

z.B. paris, smp, tane, taurus 

#PBS -v Liste der Umgebungsvariablen, die zum Job exportiert 

werden sollen 

#PBS -V 

Alle Umgebungsvariablen der aktuellen Shell dem Job exportieren 


Batchsystemkommandos 

Jobs in die Warteschlange absetzen 

$ qsub 

Interaktive Batchjobs 

$ qsub -I -X (öffnet eine Shell auf einem Knoten) 

Alle Jobs anzeigen lassen 

$ qstat -a 

Alle Jobs mit Knoten-Ansicht anzeigen lassen 

$ qstat -n 

Volle Ausgabe für einen bestimmten Job zeigen 

$ qstat -f 

Job von der Queue löschen 

$ qdel 

Job von einer Queue in eine andere schieben 

$ qmove 


Erweiterte Batchsystemkommandos 

Alle Jobs anzeigen lassen mit geteilter Ansicht: »show queue« 

(RUNNING, IDLE, BLOCKED) 

$ showq 

Alle bereits existierende Reservierungen zeigen: »show reservations« 

$ showres 

Sofort verfügbare Prozessoren und Laufzeiten: »show backfill« 

$ showbf 


Warteschlangen (Queues) 

all – für Jobs aller Art 1 (#PBS -q all; Default-Einstellung) 

test – für kurze Testjobs (#PBS -q test) 

nur ein Knoten kann benutzt werden; Jobs, die mehr als einen Knoten 

anfordern, werden in dieser Queue nicht anlaufen 

helena – für große-SMP-Jobs (#PBS -q helena) 

nur ein Knoten kann benutzt werden; Jobs, die mehr als einen Knoten 

anfordern, werden in dieser Queue nicht anlaufen 

1 außer Jobs, die für die test oder helena Queues gedacht sind 


Warteschlangen (Grenzen) 

Maximale Anforderungen der all und helena Queues 

Anzahl gleichzeitig laufender Jobs pro Benutzer: 64 

Kerne pro Benutzer: 768 

Maximales Wallclock-Limit: 200 Stunden 

(#PBS -l walltime=200:00:00) 

Maximale Anforderungen der test Queue 

47 GB Hauptspeicher (#PBS -l mem=47gb) 

6 Stunden Wallclockzeit (#PBS -l walltime=6:00:00) 

1 Knoten, 12 Kerne (#PBS -l nodes=1:ppn=12) 


Verfügbare Hauptspeicherressourcen 

Das Betriebssystem benötigt selbst auch Hauptspeicher; die maximal 

möglichen Anforderungen sind daher etwas geringer 

Verfügbare Ressourcen: 

Tane-Knoten: 47 GB 

Taurus-Knoten: 47 GB 

test-n001 (die test-Queue): 47 GB 

Paris Standardknoten: 62 GB 

Paris »dicker«-Knoten: 125 GB 

Lucky: 252 GB 

SMP-Knoten: 252 GB 

Centaurus: 504 GB 

Helena: 630 GB 


Anmerkungen zu den Jobanforderungen 

Jobanforderungen bitte anpassen! 

Wichtig sind Wallclock-Zeit, Hauptspeicher und CPU/Kern-Anzahl 

Vorteile genauer Angaben: 

Besserer Gesamtdurchsatz durch genauere Planbarkeit 

Jobs laufen schneller an und sind früher fertig 

Jobs, die erheblich geringere Ressourcen verbrauchen als angefordert, 

erzeugen eine Warnungsmail 


Beispiel-Batchskripte 

serielles Programm 

paralleles Programm 

serielles Matlab 

paralleles Matlab 

serielles Comsol 

paralleles Comsol 

serielles ANSYS 

shared mem ANSYS 

distributed mem ANSYS 

SAS 

R 

serielles GAMS 

paralleles GAMS 

serielles OpenFOAM 

(airFoil2D) 

paralleles OpenFOAM 

(motorBike) 

MSINDO 

Abaqus 

Gaussian 


Beispiel-Batchskript (serielles Programm) 

Beispiel für ein »serielles« Programm (verwendet nur einen Prozessor) hello. 


2 #PBS -N moin 

3 #PBS -M ich@meine.email.adresse 

4 #PBS -m ae 

5 #PBS -j oe 



8 #PBS -l mem=3600mb 




2 cd $PBS_O_WORKDIR 

3 # the program to run 

4 ./hello 

⇐Zurück zur Batchskriptliste 


Beispiel-Batchskript (serielles Matlab-Programm) 

Matlab-Programm auf einem Prozessor laufen lassen. 


2 #PBS -N serialMatlab 


4 #PBS -m ae 

5 #PBS -j oe 

6 #PBS -l nodes=1:ppn=1:matlab 





1 # load the relevant modules 

2 module load matlab 



5 # log file name 

6 LOGFILE=$(echo $PBS_JOBID | cut -d"." -f1).log 


8 matlab -nojvm -nosplash < hello.m > $LOGFILE 2>&1 



Beispiel-Batchskript (paralleles Matlab-Programm) 

Matlab-Programm auf vier (4) Prozessorkerne laufen lassen. 


2 #PBS -N ParallelMatlab 


4 #PBS -m ae 

5 #PBS -j oe 

6 #PBS -l nodes=1:ppn=4:matlab 

7 #PBS -l walltime=00:10:00,mem=4gb 




1 module load matlab 

2 # change to work dir 


4 # log file name 

5 LOGFILE=$(echo $PBS_JOBID | cut -d"." -f1).log 


7 matlab -nodesktop < lin_solve.m > $LOGFILE 2>&1 



Beispiel paralleles Matlab-Programm 

1 function lin_solve(n) 

2 fprintf(’=============== START =================\n’) 

3 if nargin ~= 1 

4 n = 10000; 

5 fprintf(’Using default matrix size: n = %d\n’, n) 

6 else 

7 n = str2num(n); % argument is a string; convert to num 

8 fprintf(’Using the matrix size: n = %d\n’, n) 

9 end 

0 

1 tic 

2 

3 % set up the matrix to solve 

4 A = rand(n); 

5 y = rand(n,1); 

6 

7 % solve the matrix 

8 x = A\y; 

9 

0 toc 

1 fprintf(’=============== END =================\n’) 


Beispiel-Batchskript (serielles Comsol-Programm) 

Comsol auf einem Prozessor laufen lassen. 


2 #PBS -N comsol_micromixer 

3 #PBS -M ich@meine.email.adresse.de 

4 #PBS -m ae 

5 #PBS -j oe 







2 module load comsol 




6 comsol batch -inputfile micromixer.mph 



Beispiel-Batchskript (paralleles Comsol-Programm) 

Comsol auf acht (8) CPU-Kerne laufen lassen. 


2 #PBS -N comsol_micromixer_parallel 


4 #PBS -m ae 

5 #PBS -j oe 







2 module load comsol 



5 # work out the number of threads 

6 export NUM_THREADS=$(wc -l $PBS_NODEFILE | cut -d" " -f1) 


8 comsol batch -inputfile micromixer.mph -np $NUM_THREADS 



Beispiel-Batchskript (serielles ANSYS-Programm) 

ANSYS auf einem Prozessor laufen lassen. 


2 #PBS -N testcase.serial 


4 #PBS -m ae 

5 #PBS -j oe 







2 module load ansys 



5 # start program for serial run; 

6 # (assuming that an input file testcase.dat has been created before): 

7 ansys130 -i testcase.dat -o serial.out 



Beispiel-Batchskript (shared ANSYS-Programm) 

ANSYS auf einem Knoten mit mehreren Prozessoren und geteiltem Speicher 


2 #PBS -N testcase.shared 


4 #PBS -m ae 

5 #PBS -j oe 








3 # calculate number of threads for shared memory computation 

4 nthr=$(cat $PBS_NODEFILE | wc -l) 

5 echo "nthreads = "$nthr 

6 # start program 

7 ansys130 -b -np $nthr -i testcase.dat -o shared.out 



Beispiel-Batchskript (distributed ANSYS-Programm) 

ANSYS auf mehreren Knoten laufen lassen. 


2 #PBS -N testcase.distr 


4 #PBS -m ae 

5 #PBS -j oe 








3 # set stacksize 

4 ulimit -s 300000 

5 # create correct HOST string for ANSYS call 

6 create_ansys_machine_file machines 

7 read HOST < machines 

8 echo $HOST 

9 # start program in distributed memory mode 

0 ansys130 -b -dis -machines $HOST -mpi hpmpi -i testcase.dat -o distr.out 



Beispiel-Batchskript (SAS-Programm) 


2 #PBS -N seriellSAS 


4 #PBS -m ae 

5 #PBS -j oe 




9 




3 module load sas 




7 sas Simulation.sas 



Beispiel-Batchskript (R-Programm) 


2 #PBS -N seriellR 


4 #PBS -m ae 

5 #PBS -j oe 



8 #PBS -l mem=3600mb 

9 




3 module load R 




7 R --slave < fanta22_korrektur.R 



Beispiel-Batchskript (serielles GAMS-Programm) 

GAMS-Programm auf einem (1) Prozessorkern laufen lassen. 


2 #PBS -N GAMS_trnsport 


4 #PBS -m ae 

5 #PBS -j oe 




9 




3 module load gams 




7 gams trnsport.gms lo=2 lf=transport_log.log 



Beispiel-Batchskript (paralleles GAMS-Programm) 

GAMS-Programm auf vier (4) Prozessorkerne laufen lassen. 


2 #PBS -N CLSP_Optimal 


4 #PBS -m ae 

5 #PBS -j oe 




9 




3 module load gams 



6 # correctly specify the number of cores in cplex.opt!! 


8 gams CLSP_Optimal.gms lo=2 lf=CLSP_Optimal.log 



Beispiel-Batchskript (serielles OpenFOAM-Programm) 

simpleFoam auf einem (1) Prozessorkern laufen lassen. 


2 #PBS -N airFoil2D 


4 #PBS -m ae 

5 #PBS -j oe 







2 module load openfoam/1.7.1 

3 # initialise the OpenFOAM environment 

4 source $foamDotFile 


6 cd $PBS_O_WORKDIR/airFoil2D 

7 # clean up from possible previous runs 

8 ./AllClean 


0 simpleFoam 



Beispiel-Batchskript (serielles OpenFOAM-Programm) 

simpleFoam auf einem (1) Prozessorkern laufen lassen. 


2 #PBS -N motorBike 

3 ####PBS -M ich@meine.mail.adresse 

4 #PBS -M cochrane@rrzn.uni-hannover.de 

5 #PBS -m ae 

6 #PBS -j oe 







13 module load openfoam/1.7.1 

14 # initialise the OpenFOAM environment 

15 source $foamDotFile 


17 cd $PBS_O_WORKDIR/motorBike 

18 # clean up from previous runs 

19 ./Allclean 

20 # set up the mesh and the simulation 

21 cp system/fvSolution.org system/fvSolution 

22 cp -r 0.org 0 > /dev/null 2>&1 

23 blockMesh 

24 snappyHexMesh -overwrite 

25 sed -i ’s/$nNonOrthogonalCorrectors$.*;/\1 10;/g’ system/fvSolution 

26 potentialFoam -writep 

27 sed -i ’s/$nNonOrthogonalCorrectors$.*;/\1 0;/g’ system/fvSolution 


29 simpleFoam 



Beispiel-Batchskript (paralleles Programm) 

Ein MPI-paralleles Programm namens ping_pong_advanced_send, das 

über zwei (2) Prozessoren verteilt wird. 


2 #PBS -N pingpong 


4 #PBS -m ae 

5 #PBS -j oe 

6 #PBS -l nodes=1:ppn=2,walltime=00:10:00,mem=4gb 

7 #PBS -W x=PARTITION:tane 

8 




2 module load impi 



5 # the program to run in parallel 

6 mpirun --rsh=ssh -machinefile $PBS_NODEFILE -np 2 -env I_MPI_DEVICE shm \ 

7 ./ping_pong_advanced_send_c 



Beispiel-Batchskript (MSINDO) 

MSINDO auf 6 Prozessorkerne laufen lassen. 


2 #PBS -N MgO_444 


4 #PBS -m ae 

5 #PBS -j oe 




9 #PBS -W x=PARTITION:tane:paris:kuh 

10 




14 module load msindo 

15 

16 export KMP_STACKSIZE=64M 

17 export OMP_DYNAMIC=.FALSE. 

18 export OMP_NUM_THREADS=$(cat $PBS_NODEFILE | wc -l) 

19 

20 INPUTFILE="MgO_444.inp" 

21 


23 TEMPDIR=$BIGWORK/$(basename $INPUTFILE .inp).$$ 

24 cd $TEMDIR 

25 LOGFILE=$PBS_O_WORKDIR/$INPUTFILE.out.$$ 

26 echo "Running on $OMP_NUM_THREADS cores" >> $LOGFILE 

27 


29 time msindo < $INPUTFILE >> $LOGFILE 2>&1 

30 # clean up output files 

31 if [ -s "fort.9" ]; then cp fort.9 $PBS_O_WORKDIR/$INPUTFILE.f9.$$; fi 

32 if [ -n "$(ls *.dat)" ]; then cp *.dat $PBS_O_WORKDIR/; fi 

33 if [ -n "$(ls *.molden)" ]; then cp *.molden $PBS_O_WORKDIR/; fi 

34 if [ -n "$(ls *.xyz)" ]; then cp *.xyz $PBS_O_WORKDIR/; fi 



Beispiel-Batchskript (Abaqus) 

Abaqus auf 4 Prozessorkerne laufen lassen. 


2 #PBS -N llbeam 

3 #PBS -M ich@meine.mail.adresse.de 

4 #PBS -j oe 

5 #PBS -m ae 


7 #PBS -l mem=15GB 


9 



12 


14 module load abaqus 

15 

16 # change to working directory 


18 

19 # set up simulation parameters 

20 np=$(cat $PBS_NODEFILE | wc -l) 

21 mnp=$(sort -u $PBS_NODEFILE | wc -l) 

22 cp $PBS_NODEFILE hostfile 

23 echo $np >> hostfile 

24 echo $mnp >> hostfile 

25 create_abaqus_host_list 

26 


28 abaqus job=llbeam cpus=$np domains=$np parallel=domain mp_mode=mpi double interactive 



Beispiel-Batchskript (Gaussian) 

Gaussian auf 4 Processorkerne laufen lassen. 


2 #PBS -N gaussian 

3 #PBS -M ich@meine.mail.adresse.de 

4 #PBS -j eo 

5 #PBS -m ae 




9 



2 


4 module load gaussian 

5 

6 # change to working directory 


8 


0 g09 < input.com > g09job.out 



Struktur der Dateisysteme 


Details der Dateisysteme 

$HOME 

Global verfügbares Heimverzeichnis 

Daten werden gesichert; unbegrenzte Lebensdauer 

Datenvolumen begrenzt über Unix-Quotasystem 

Für Skripte, Programme und kleine endgültige Ergebnisse geeignet 

$BIGWORK 

Global verfügbares Arbeitsverzeichnis 

Für große »Work«-Dateien geeignet 

69 TB Speicherplatz für alle zusammen. 

$BIGWORK-Variable zeigt auf /bigwork/ 

Daten werden NICHT gesichert; Daten haben eine Lebensdauer von 28 

Tagen (nach der letzten Änderung der Daten) 


Details der Dateisysteme (fort.) 

Archivsystem 

Langfristige Lagerung von Dateien, auch von großen Datenmengen 

Daten sind auf dem Tape-Backup-Archiv der Universität gesichert 

Von den Loginknoten mit lftp-Kommando erreichbar 

Mehr Informationen unter: 

http://www.rrzn.uni-hannover.de/archivierung.html 

http://www.rrzn.uni-hannover.de/archivierung_policy.html 


Wenn Fehler auftauchen. . . 

1 Batchskript und nötigenfalls das Programm überprüfen 

2 Clusterdokumentation lesen: 

http://www.rrzn.uni-hannover.de/clustersystem.html 

3 Sagt Google etwas dazu? 

4 Melden Sie sich über die Hilfemailingliste: 

cluster-help@rrzn.uni-hannover.de mit den folgenden Infos 

Ihr Benutzername 

Job ID Nummer 

Wann der Job gelaufen ist 

Auf welchem Rechenknoten der Job gelaufen ist 

Das Batchskript 

Eine kurze Beschreibung des Problems 

Jegliche Fehlermeldung des Programms, falls vorhanden 

Das Ausgabeprotokoll des Jobs, z.B.: myjob.o12345 als Anhang 


Informationslinks 

http://www.rrzn.uni-hannover.de/clustersystem.html 

http://www.rrzn.uni-hannover.de/cluster-zugang.html 


http://www.rrzn.uni-hannover.de/rechnerressourcen.html 

http://www.rrzn.uni-hannover.de/installierte_software.html 

http://www.rrzn.uni-hannover.de/handbuecher.html 


Kontaktinformationen 

Fragen, Anregungen und Problemberichte: 

cluster-help@rrzn.uni-hannover.de 

Fachberatung 

Dr. Gerd Brand: brand@rrzn.uni-hannover.de 

Dr. Andreas Gerdes: gerdes@rrzn.uni-hannover.de 

Oliver Heimbrock: heimbrock@rrzn.uni-hannover.de 

Dr. Holger Naundorf: naundorf@rrzn.uni-hannover.de 

Administration, allgemeine Beratung 

Klaus Dobrindt: dobrindt@rrzn.uni-hannover.de 

Patrick Njofang: njofang@rrzn.uni-hannover.de 

Möchten Sie eine Tour der Rechner am Rechenzentrum? Melden Sie sich! 


Vielen Dank für die Aufmerksamkeit! 

:-) 


Never work at Home! 

Warum es keine gute Idee ist, in /home einen Link auf /bigwork anzulegen: 

1 root@avon:/home/nhXXXXXX# ls -l 

2 total 4 

3 lrwxrwxrwx 1 nhXXXXXX nhXX 17 Oct 17 2010 bigwork -> /bigwork/nhXXXXXX 

4 root@avon:/home/nhXXXXXX# 

/home nur über NFS angebunden 

Job muss über NFS nach /home und wieder über NFS zurück nach 

BIGWORK 

Langer Weg! Hohe Last für /home Fileserver!

Einführung in die Rechendienste - RRZN

Sie wollen auch ein ePaper? Erhöhen Sie die Reichweite Ihrer Titel.

Template löschen?

Als Template speichern?