HPL (High Performance Linpack):Benchmarking von Raspberry PIs

Benchmarking ist der Prozess, bei dem einige der Standardprogramme ausgeführt werden, um die von einem System erreichte Geschwindigkeit zu bewerten. Es gibt eine Reihe von Standard-Bechmarking-Programmen, und in diesem Tutorial messen wir das Linux-System mit einem bekannten Programm namens HPL, das auch als High Performance Linpack bekannt ist.

Einführung

In diesem Tutorial behandeln wir das Benchmarking eines Einzelprozessorsystems, des Raspberry Pi. Zuerst werden wir einen einzelnen Knoten bewerten und dann mit dem Benchmarken mehrerer Knoten fortfahren, wobei jeder Knoten einen Raspberry Pi darstellt. Hier gibt es einiges zu beachten. Erstens müssen beim Benchmarking eines einzelnen Knotens oder mehrerer Knoten einige Abhängigkeiten erfüllt werden, die in diesem Tutorial behandelt werden. ABER, auf mehreren Knoten gibt es noch mehr Abhängigkeiten, wie die MPI-Implementierung (wie MPICH oder OpenMPI), die erstellt und ausgeführt werden muss, damit HPL funktioniert. Für das Benchmarking mehrerer Knoten gehe ich davon aus, dass auf Ihren Knoten MPICH installiert ist und ausgeführt wird.

Was ist HPL?

HPL ist ein Softwarepaket, das ein (zufälliges) dichtes lineares System in Arithmetik mit doppelter Genauigkeit (64 Bit) auf Computern mit verteiltem Speicher löst. Das HPL-Paket bietet ein Test- und Timing-Programm, um die Genauigkeit der erhaltenen Lösung sowie die Zeit, die für ihre Berechnung benötigt wurde, zu quantifizieren. Die beste Leistung, die diese Software auf Ihrem System erzielen kann, hängt von einer Vielzahl von Faktoren ab. Diese Implementierung ist in dem Sinne skalierbar, dass ihre parallele Effizienz in Bezug auf die Speichernutzung pro Prozessor konstant gehalten wird. Somit können wir dies verwenden, um einen einzelnen Prozessor oder eine Reihe verteilter Prozessoren parallel zu benchmarken. Beginnen wir also mit der Installation von HPL.

1 Abhängigkeiten installieren

HPL hat einige Software-Abhängigkeiten, die erfüllt werden müssen, bevor es installiert werden kann. Sie sind:

• gfortran - Fortran-Programm-Compiler
• MPICH2 - eine Implementierung von MPI
• mpich2-dev - Entwicklungstools
• BLAS - Grundlegende 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 im Cluster vorhandenen Knoten (Pis) wiederholt werden.

2 HPL herunterladen und einrichten

Laden Sie das HPL-Paket hier herunter. Als nächstes müssen Sie die Tar-Datei extrahieren und ein Makefile basierend auf der angegebenen Vorlage 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 Himbeer-Pi) und auch die Details verschiedener Bibliotheken wie mpich2, atlas/blas-Pakete, Home-Verzeichnis usw. enthält. Im nächsten Schritt nehmen wir Änderungen vor in die Make.rpi-Datei.
 
3 Passen Sie die Make.rpi-Datei an
 

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

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

 Nehmen Sie die folgenden Änderungen an der Datei vor.
 
ARCH =rpiTOPdir =$(HOME)/hpl-2.1MPdir =/usr/local/mpich2MPinc =-I $(MPdir)/includeMPlib =$(MPdir)/lib/libmpich.aLAdir =/usr/lib/atlas -base/LAlib =$(LAdir)/libf77blas.a $(LAdir)/libatlas.a
 
4 HPL kompilieren
 

 Sobald die Make-Datei fertig ist, können wir mit der Kompilierung der HPL beginnen. Die „.xhpl“-Datei befindet sich im Ordner „bin/rpi“ innerhalb des HPL-Ordners. Führen Sie den folgenden Befehl aus:
 
makeh arch=rpi
 
5 Erstellen der HPL-Eingabedatei
 

 Nachfolgend sehen Sie ein Beispiel für die Datei „HPL.dat“. Dies ist die Eingabedatei für HPL, wenn es ausgeführt wird. Die in dieser Datei bereitgestellten 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 auszuführen. Erstellen Sie eine Datei im Ordner "bin/rpi" und nennen Sie sie "HPL.dat". Kopieren Sie den Inhalt unten in diese Datei.
 
HPLinpack-Benchmark-EingabedateiInnovative Computing Laboratory, University of TennesseeHPL.out Name der Ausgabedatei (falls vorhanden)6 Gerät aus (6=stdout,7=stderr,Datei)1 Anzahl der Problemgrößen (N)5040 Ns1 Anzahl der NBs128 NBs0 PMAP-Prozesszuordnung (0 =Zeile, 1 =Spalte-Haupt)1 # der Prozessgitter (P x Q)1 Ps1 Qs16.0 Schwellenwert1 # der Panel-Fakt2 PFACTs (0 =links, 1 =Crout, 2 =rechts)1 # of rekursives Stoppkriterium4 NBMINs (>=1)1 # of Panels in Recursion2 NDIVs1 # of recursive panel fact.1 RFACTs (0=left, 1=Crout, 2=right)1 # of broadcast1 BCASTs (0=1rg,1 =1rM,2=2rg,3=2rM,4=Lng,5=LnM)1 # Lookahead-Tiefe1 DEPTHs (>=0)2 SWAP (0=bin-exch,1=long,2=mix)64 Swapping-Schwelle0 L1 in (0=transponiert,1=nicht transponiert) form0 U in (0=transponiert d,1=no-transponiert) form1 Equilibration (0=nein,1=ja)8 Memory Alignment in double (> 0)
 

 Der Inhalt dieser Datei muss durch Trial-and-Error-Methode variiert werden, bis man eine zufriedenstellende Ausgabe erhält. Informationen zu den einzelnen Parametern und deren Änderung finden Sie hier. Um zum Hauptpunkt zu springen, lesen Sie ab Seite Nr. 6 in diesem Dokument.
 
6 Ausführen von HPL auf einem einzelnen Knoten
 

 Sobald die HPL.dat-Datei fertig ist, können wir die HPL ausführen. Die obige HPL.dat-Datei gilt für einen einzelnen Knoten oder Prozessor. Das Produkt der P*Q-Werte in der obigen Datei gibt die Anzahl der Prozessoren an, für die das HPL getestet wird. Somit ist aus der obigen Datei P=1 und Q=1 , 1*1=1, also für einen einzelnen Prozessor. Um es jetzt auszuführen, verwenden Sie die Befehle:
 
cd bin/rpi
./xhpl
 

 Die Ausgabe sieht in etwa so aus wie unten gezeigt:
 
============================================================================HPLinpack 2.1 – Hochleistungs-Linpack-Benchmark – 26. Oktober 2012 Geschrieben von A Petitet und R. Clint Whaley, Innovative Computing Laboratory, UTKMändert von Piotr Luszczek, Innovative Computing Laboratory, UTKMändert von Julien Langou, University of Colorado Denver==============================================================================Es folgt eine Erläuterung der Ein-/Ausgabeparameter:T/V :Wandzeit / codierte Variante.N :Die Ordnung der Koeffizientenmatrix A.NB :Der Partitionierungsblockfaktor.P :Der Anzahl der Prozesszeilen. Q:Die Anzahl der Prozessspalten. Zeit:Zeit in Sekunden zum Lösen des linearen Systems. Gflops:Ausführungsrate zum Lösen des linearen Systems. Die folgenden Parameterwerte werden verwendet:N:5040 NB:128 PMAP :Row-major Process MappingP :1 Q :1 PFACT :Right NBMIN :4 NDIV :2 RFACT :Crout BCAST :1ringM DEPTH :1 SWAP :Mix (threshold =64)L1 :transponierte FormU :transponierte FormEQUIL :yesALIGN :8 Wörter mit doppelter Genauigkeit ------ -------------------------------------------------- ------------ Die Matrix A wird für jeden Test zufällig generiert.- Die folgende skalierte Residuenprüfung wird berechnet:||Ax-b||_oo / ( eps * ( || x ||_oo * || Ein ||_oo + || b ||_oo ) * N )- Die relative Maschinenpräzision (eps) wird mit 1,110223e-16 angenommen. Computertests bestehen, wenn skalierte Residuen kleiner als 16,0 sind
 

 Außerdem müssen wir uns auf das Endergebnis konzentrieren. Die endgültige Ausgabe, die auf dem Terminal erscheint, sieht ähnlich aus wie unten gezeigt. Der letzte Wert gibt die Geschwindigkeit an und die Werte davor zeigen die verschiedenen bereitgestellten Parameter. Im folgenden Inhalt wird die Geschwindigkeit in Gflops angezeigt und ihr Wert liegt bei etwa 1,21e-01 Gflops, was umgerechnet 121 Mega FLOPS (MFLOPS) ergibt.
 
============================================================================T/V N NB P Q Zeit Gflops---------- -------------------------------------------------- --------------------WR11C2R4 21400 128 3 11 537.10 1.210e-01HPL_pdgesv() Startzeit Mo 23. Juni 17:29:42 2014HPL_pdgesv() Endzeit Mo 23. Juni 17:55:19 2014 -------------------------------------------- ------------------------------------||Ax-b||_oo/(eps*(| |A||_oo*||x||_oo+||b||_oo)*N)=0.0020152 ...... BESTANDEN=============================================================================
 

 Bitte beachten Sie, dass die Geschwindigkeit und die benötigte Zeit je nach Raspberry Pi erheblich unterschiedlich sein können. Verwenden Sie diese Ergebnisse daher bitte nicht als Vergleich zu Ihrem Knoten oder Cluster.
 
7 Ausführen von HPL auf mehreren Knoten
 

 Wenn wir HPL für mehrere Knoten ausführen möchten, müssen wir die HPL.dat-Datei ändern. Nehmen wir hier an, dass wir 32 Knoten haben. Das Produkt von P*Q sollte also 32 sein. Ich habe P=4 gewählt, Q=8 also 4*8=32. Abgesehen von dieser Änderung müssen wir also den Wert von N ändern, durch Versuch und Irrtum haben wir die maximale Geschwindigkeit für N =17400 erhalten. Der endgültige Dateiinhalt wird unten angezeigt. Nehmen Sie diese Änderungen entsprechend in Ihrer "HPL.dat"-Datei vor.
 
HPLinpack-Benchmark-EingabedateiInnovative Computing Laboratory, University of TennesseeHPL.out Name der Ausgabedatei (falls vorhanden)6 Gerät aus (6=stdout,7=stderr,Datei)1 Anzahl der Problemgrößen (N)17400 Ns1 Anzahl der NBs128 NBs0 PMAP-Prozesszuordnung (0 =Zeile, 1 =Spalte-Haupt)1 # der Prozessgitter (P x Q)4 Ps8 Qs16.0 Schwellenwert1 # der Panel-Fakt2 PFACTs (0 =links, 1 =Crout, 2 =rechts)1 # of rekursives Stoppkriterium4 NBMINs (>=1)1 # of Panels in Recursion2 NDIVs1 # of recursive panel fact.1 RFACTs (0=left, 1=Crout, 2=right)1 # of broadcast1 BCASTs (0=1rg,1 =1rM,2=2rg,3=2rM,4=Lng,5=LnM)1 # Lookahead-Tiefe1 DEPTHs (>=0)2 SWAP (0=bin-exch,1=long,2=mix)64 Swapping-Schwelle0 L1 in (0=transponiert,1=nicht transponiert) form0 U in (0=transponiert ed,1=no-transponiert) form1 Equilibration (0=nein,1=ja)8 Memory Alignment in double (> 0)
 

 Sobald dies erledigt ist, müssen wir die HPL erneut ausführen. Verwenden Sie den folgenden Befehl. Denken Sie daran, den Pfad im folgenden Befehl so zu ändern, dass er den Pfad der Maschinendatei in Ihrem System darstellt.
 
cd bin/rpi
mpiexec -f ~/mpi_testing/machinefile -n 32 ./xhpl
 

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

 Diese Art von Änderungen können in Abhängigkeit von der Anzahl der Knoten oder Prozessoren im System vorgenommen und die Benchmark-Ergebnisse ermittelt werden. Und wie ich bereits erwähnt habe, um mehr darüber zu erfahren, wie man die Werte in der HPL.dat-Datei einstellt, gehen Sie zum Dokument hier und lesen Sie es durch.