HPL (High Performance Linpack): Benchmarking Raspberry PIs

Benchmarking ist der Prozess, einige der Standardprogramme auszuführen, um die Geschwindigkeit zu bewerten, die von einem System erreicht wird. Es gibt eine Reihe von Standard-Benchmarking-Programmen, und in diesem Tutorial benchmarken wir das Linux-System mit einem bekannten Programm namens HPL, auch bekannt als High Performance Linpack.

Einführung

In diesem Tutorial behandeln wir, wie man ein einzelnes Prozessorsystem, den Raspberry Pi, benchmarkt. Zuerst werden wir einen einzelnen Knoten benchmarken und dann fortfahren, mehrere Knoten zu benchmarken, wobei jeder Knoten einen Raspberry Pi darstellt. Es gibt ein paar Dinge, die hier zu beachten sind. Erstens hat das Benchmarking eines einzelnen Knotens oder mehrerer Knoten einige Abhängigkeiten, die erfüllt sein müssen, die in diesem Tutorial behandelt werden. ABER, bei mehreren Knoten gibt es noch mehr Abhängigkeiten, wie die MPI-Implementierung (wie MPICH oder OpenMPI), die für das Funktionieren von HPL gebaut und ausgeführt werden muss. Daher gehe ich davon aus, dass Ihre Knoten MPICH installiert und ausgeführt haben.

Was ist HPL?

HPL ist ein Softwarepaket, das ein (zufälliges) dichtes lineares System in doppelter Präzision (64 Bit) Arithmetik auf verteilten Speichersystemen löst. Das HPL-Paket bietet ein Test- und Zeitprogramm, um die Genauigkeit der erhaltenen Lösung sowie die Zeit zu quantifizieren, die benötigt wurde, um sie zu berechnen. Die beste Leistung, die von dieser Software auf Ihrem System erreicht werden kann, hängt von einer Vielzahl von Faktoren ab. Diese Implementierung ist skalierbar in dem Sinne, dass ihre parallele Effizienz konstant in Bezug auf den Speicherverbrauch pro Prozessor bleibt. Somit können wir dies verwenden, um einen einzelnen Prozessor oder eine Reihe von verteilten Prozessoren parallel zu benchmarken. Lassen Sie uns also mit der Installation von HPL beginnen.

1 Abhängigkeiten installieren

HPL hat einige Softwareabhängigkeiten, die erfüllt sein müssen, bevor es installiert werden kann. Diese sind:

gfortran - Fortran-Programmiercompiler
MPICH2 - eine Implementierung von MPI
mpich2-dev - Entwicklungstools
BLAS - Basis-Lineare Algebra-Unterprogramme

Hier gehen wir davon aus, dass Sie MPICH2 installiert haben. Um andere Abhängigkeiten und Pakete zu installieren, verwenden Sie den folgenden Befehl:

sudo apt-get install libatlas-base-dev libmpich2-dev gfortran

Nur dieser Schritt muss in jedem der Knoten (Pis) im Cluster wiederholt werden.

2 HPL herunterladen und einrichten

Laden Sie das HPL-Paket von hier herunter. Das Nächste, was zu tun ist, ist, die Tar-Datei zu extrahieren und eine Makefile basierend auf der gegebenen Vorlage zu erstellen. Öffnen Sie das Terminal und wechseln Sie in das Verzeichnis, in dem die heruntergeladene HPL-Tar-Datei gespeichert ist. Führen Sie die folgenden Befehle nacheinander aus.

tar xf hpl-2.1.tar.gz  
 cd hpl-2.1/setup  
 sh make_generic  
 cd ..  
 cp setup/Make.UNKNOWN Make.rpi

Der letzte Befehl kopiert den Inhalt von Make.UNKNOWN nach Make.rpi. Wir tun dies, weil die Make-Datei alle Konfigurationsdetails des Systems (des Raspberry Pi) sowie die Details verschiedener Bibliotheken wie mpich2, atlas/blas-Pakete, Heimatverzeichnis usw. enthält. Im nächsten Schritt nehmen wir Änderungen an der Make.rpi-Datei vor.

3 Die Make.rpi-Datei anpassen

Dies ist ein wichtiger Schritt. Die unten gezeigten Änderungen variieren je nach Ihrem System. Hier zeige ich es in Bezug auf mein System. Bitte beachten Sie, dass die folgenden Änderungen Parameter enthalten, die im gesamten Make.rpi-Datei verteilt sind. Ich empfehle Ihnen, jeden Parameter zu finden und die Änderungen zu ersetzen oder hinzuzufügen und erst dann mit dem nächsten Parameter fortzufahren.

Öffnen Sie die Make.rpi-Datei mit einem Texteditor mit dem Befehl:

nano Make.rpi

Nehmen Sie die folgenden Änderungen an der Datei vor.

ARCH         = rpi
TOPdir       = $(HOME)/hpl-2.1
MPdir        = /usr/local/mpich2
MPinc        = -I $(MPdir)/include
MPlib        = $(MPdir)/lib/libmpich.a
LAdir        = /usr/lib/atlas-base/
LAlib        = $(LAdir)/libf77blas.a $(LAdir)/libatlas.a

4 HPL kompilieren

Sobald die Make-Datei bereit ist, können wir mit der Kompilierung von HPL beginnen. Die “.xhpl”-Datei wird im “bin/rpi”-Ordner innerhalb des HPL-Ordners vorhanden sein. Führen Sie den folgenden Befehl aus:

makeh arch=rpi

5 Die HPL-Eingabedatei erstellen

Das Folgende ist ein Beispiel für die “HPL.dat”-Datei. Dies ist die Eingabedatei für HPL, wenn sie ausgeführt wird. Die in dieser Datei angegebenen Werte werden verwendet, um das Problem zu generieren und zu berechnen. Sie können diese Datei direkt verwenden, um Tests für einen einzelnen Knoten durchzuführen. Erstellen Sie eine Datei im “bin/rpi”-Ordner und benennen Sie sie “HPL.dat”. Kopieren Sie die folgenden Inhalte in diese Datei.

HPLinpack benchmark input file
Innovative Computing Laboratory, University of Tennessee
HPL.out      output file name (if any)
6            device out (6=stdout,7=stderr,file)
1            # of problems sizes (N)
5040         Ns
1            # of NBs
128          NBs
0            PMAP process mapping (0=Row-,1=Column-major)
1            # of process grids (P x Q)
1            Ps
1            Qs
16.0         threshold
1            # of panel fact
2            PFACTs (0=left, 1=Crout, 2=Right)
1            # of recursive stopping criterium
4            NBMINs (>= 1)
1            # of panels in recursion
2            NDIVs
1            # of recursive panel fact.
1            RFACTs (0=left, 1=Crout, 2=Right)
1            # of broadcast
1            BCASTs (0=1rg,1=1rM,2=2rg,3=2rM,4=Lng,5=LnM)
1            # of lookahead depth
1            DEPTHs (>=0)
2            SWAP (0=bin-exch,1=long,2=mix)
64           swapping threshold
0            L1 in (0=transposed,1=no-transposed) form
0            U  in (0=transposed,1=no-transposed) form
1            Equilibration (0=no,1=yes)
8            memory alignment in double (> 0)

Der Inhalt dieser Datei muss durch Versuch und Irrtum variiert werden, bis man eine zufriedenstellende Ausgabe erhält. Um mehr über jeden Parameter und dessen Änderung zu erfahren, beziehen Sie sich auf ein Papier hier. Um zum Hauptpunkt zu springen, beginnen Sie mit dem Lesen ab Seite 6 in diesem Dokument.

6 HPL auf einem einzelnen Knoten ausführen

Sobald die HPL.dat-Datei bereit ist, können wir HPL ausführen. Die oben genannte HPL.dat-Datei ist für einen einzelnen Knoten oder Prozessor. Das Produkt der PQ-Werte in der obigen Datei gibt die Anzahl der Prozessoren an, für die HPL getestet wird. Somit ist P=1 und Q=1, 11=1, also ist es für einen einzelnen Prozessor. Um es auszuführen, verwenden Sie die Befehle:

cd bin/rpi  
./xhpl

Die Ausgabe sieht ungefähr so aus wie unten gezeigt:

================================================================================
HPLinpack 2.1  --  High-Performance Linpack benchmark  --   26. Oktober 2012
Geschrieben von A. Petitet und R. Clint Whaley, Innovative Computing Laboratory, UTK
Modifiziert von Piotr Luszczek, Innovative Computing Laboratory, UTK
Modifiziert von Julien Langou, University of Colorado Denver
================================================================================

Eine Erklärung der Eingabe-/Ausgabeparameter folgt:
T/V    : Wandzeit / kodierte Variante.
N      : Die Ordnung der Koeffizientenmatrix A.
NB     : Der Partitionierungsblockfaktor.
P      : Die Anzahl der Prozessreihen.
Q      : Die Anzahl der Prozessspalten.
Zeit   : Zeit in Sekunden zur Lösung des linearen Systems.
Gflops : Ausführungsrate zur Lösung des linearen Systems.

Die folgenden Parameterwerte werden verwendet:

N      :   5040 
NB     :     128 
PMAP   : Zeilenmajor-Prozessabbildung
P      :       1 
Q      :       1 
PFACT  :   Rechts 
NBMIN  :       4 
NDIV   :       2 
RFACT  :   Crout 
BCAST  :  1ringM 
DEPTH  :       1 
SWAP   : Mix (Schwellenwert = 64)
L1     : transponierte Form
U      : transponierte Form
EQUIL  : ja
ALIGN  : 8 doppelte Präzisionswörter

--------------------------------------------------------------------------------

- Die Matrix A wird für jeden Test zufällig generiert.
- Die folgende skalierte Residuenprüfung wird berechnet:
      ||Ax-b||_oo / ( eps * ( || x ||_oo * || A ||_oo + || b ||_oo ) * N )
- Die relative Maschinenpräzision (eps) wird als 1.110223e-16 angenommen.
- Computertests bestehen, wenn skalierte Residuen kleiner sind als 16.0

Bitte beachten Sie, dass je nach Ihrem Raspberry Pi die Geschwindigkeit und die benötigte Zeit erheblich unterschiedlich sein können. Verwenden Sie daher diese Ergebnisse nicht als Vergleich zu Ihrem Knoten oder Cluster.

7 HPL auf mehreren Knoten ausführen

Wenn wir HPL für mehrere Knoten ausführen möchten, müssen wir die HPL.dat-Datei ändern. Angenommen, wir haben 32 Knoten. Das Produkt von PQ sollte also 32 sein. Ich wählte P=4, Q=8, also 48=32. Abgesehen von dieser Änderung müssen wir den Wert von N ändern; durch Versuch und Irrtum haben wir die maximale Geschwindigkeit für N=17400 erhalten. Der endgültige Dateiinhalt ist unten gezeigt. Nehmen Sie diese Änderungen entsprechend in Ihrer “HPL.dat”-Datei vor.

HPLinpack benchmark input file
Innovative Computing Laboratory, University of Tennessee
HPL.out      output file name (if any)
6            device out (6=stdout,7=stderr,file)
1            # of problems sizes (N)
17400         Ns
1            # of NBs
128          NBs
0            PMAP process mapping (0=Row-,1=Column-major)
1            # of process grids (P x Q)
4            Ps
8            Qs
16.0         threshold
1            # of panel fact
2            PFACTs (0=left, 1=Crout, 2=Right)
1            # of recursive stopping criterium
4            NBMINs (>= 1)
1            # of panels in recursion
2            NDIVs
1            # of recursive panel fact.
1            RFACTs (0=left, 1=Crout, 2=Right)
1            # of broadcast
1            BCASTs (0=1rg,1=1rM,2=2rg,3=2rM,4=Lng,5=LnM)
1            # of lookahead depth
1            DEPTHs (>=0)
2            SWAP (0=bin-exch,1=long,2=mix)
64           swapping threshold
0            L1 in (0=transposed,1=no-transposed) form
0            U  in (0=transposed,1=no-transposed) form
1            Equilibration (0=no,1=yes)
8            memory alignment in double (> 0)

Sobald dies erledigt ist, müssen wir HPL erneut ausführen. Verwenden Sie den folgenden Befehl. Denken Sie daran, den Pfad im folgenden Befehl zu ändern, um den Pfad zur Maschinen-Datei in Ihrem System darzustellen.

cd bin/rpi  
mpiexec -f ~/mpi_testing/machinefile -n 32 ./xhpl

Das Ergebnis wird ähnlich sein wie das oben für einen Knoten, wird aber definitiv eine höhere Geschwindigkeit haben.

Solche Änderungen können je nach Anzahl der Knoten oder Prozessoren im System vorgenommen werden, und die Benchmark-Ergebnisse können ermittelt werden. Und wie ich bereits erwähnt habe, um mehr darüber zu erfahren, wie man die Werte in der HPL.dat-Datei festlegt, gehen Sie zu dem Dokument hier und lesen Sie es.