HPL (High Performance Linpack): Benchmarking Raspberry PIs

Il benchmarking è il processo di esecuzione di alcuni dei programmi standard per valutare la velocità raggiunta da un sistema. Ci sono diversi programmi di benchmarking standard e in questo tutorial benchmarkiamo il sistema Linux utilizzando un programma ben noto chiamato HPL, noto anche come High Performance Linpack.

Introduzione

In questo tutorial trattiamo come effettuare il benchmarking di un sistema a singolo processore, il Raspberry Pi. Prima benchmarkeremo un singolo nodo, e poi continueremo a benchmarkare più nodi, ciascun nodo rappresenta un Raspberry Pi. Ci sono alcune cose da notare qui. In primo luogo, il benchmarking di un singolo nodo o di più nodi ha alcune dipendenze da soddisfare che saranno trattate in questo tutorial. MA, su più nodi ci sono ancora più dipendenze come l’implementazione MPI (come MPICH o OpenMPI) deve essere costruita e in esecuzione affinché l’HPL funzioni. Quindi per il benchmarking di più nodi, presumo che i tuoi nodi abbiano MPICH installato e in esecuzione.

Cos’è HPL?

HPL è un pacchetto software che risolve un sistema lineare denso (casuale) in aritmetica a doppia precisione (64 bit) su computer a memoria distribuita. Il pacchetto HPL fornisce un programma di test e temporizzazione per quantificare l’accuratezza della soluzione ottenuta e il tempo impiegato per calcolarla. La migliore prestazione raggiungibile da questo software sul tuo sistema dipende da una grande varietà di fattori. Questa implementazione è scalabile nel senso che la loro efficienza parallela è mantenuta costante rispetto all’uso della memoria per processore. Quindi possiamo usare questo per benchmarkare un singolo processore o una serie di processori distribuiti in parallelo. Iniziamo quindi a installare HPL.

1 Installazione delle dipendenze

HPL ha alcune dipendenze software che devono essere soddisfatte prima che possa essere installato. Esse sono:

gfortran - compilatore di programmi fortran
MPICH2 - un’implementazione di MPI
mpich2-dev - strumenti di sviluppo
BLAS - Sottoprogrammi di Algebra Lineare di Base

Qui assumiamo che tu abbia MPICH2 installato. Per installare altre dipendenze e pacchetti, usa il seguente comando:

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

Solo questo passaggio deve essere ripetuto in ciascuno dei nodi (Pi) presenti nel cluster.

2 Scaricare HPL e configurarlo

Scarica il pacchetto HPL da qui. La prossima cosa da fare è estrarre il file tar e creare un makefile basato sul template fornito. Apri il terminale e cambia la directory in cui è memorizzato il file tar HPL scaricato. Esegui il seguente insieme di comandi uno dopo l’altro.

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

L’ultimo comando copia il contenuto di Make.UNKNOWN in Make.rpi. Lo facciamo perché il make file contiene tutti i dettagli di configurazione del sistema (il raspberry pi) e anche i dettagli di varie librerie come mpich2, pacchetti atlas/blas, directory home, ecc. Nel passaggio successivo, apportiamo modifiche al file Make.rpi.

3 Regolare il file Make.rpi

Questo è un passaggio importante. Le modifiche mostrate di seguito variano a seconda del tuo sistema. Qui lo mostro rispetto al mio sistema. Si prega di notare che le seguenti modifiche hanno parametri mostrati che sono sparsi in tutto il file Make.rpi. Quindi ti suggerisco di trovare ciascun parametro e sostituire o aggiungere le modifiche e solo allora continuare al parametro successivo.

Apri il file Make.rpi utilizzando un editor di testo con il comando:

nano Make.rpi

Apporta le seguenti modifiche al file.

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 Compilare l’HPL

Una volta che il Make file è pronto, possiamo iniziare con la compilazione dell’HPL. Il file “.xhpl” sarà presente nella cartella “bin/rpi” all’interno della cartella HPL. Esegui il seguente comando:

makeh arch=rpi

5 Creare il file di input HPL

Il seguente è un esempio del file “HPL.dat”. Questo è il file di input per HPL quando viene eseguito. I valori forniti in questo file vengono utilizzati per generare e calcolare il problema. Puoi usare questo file direttamente per eseguire test per un singolo nodo. Crea un file all’interno della cartella “bin/rpi” e chiamalo “HPL.dat”. copia i contenuti qui sotto in quel file.

HPLinpack benchmark input file
Innovative Computing Laboratory, University of Tennessee
HPL.out      nome del file di output (se presente)
6            dispositivo out (6=stdout,7=stderr,file)
1            # di dimensioni dei problemi (N)
5040         Ns
1            # di NBs
128          NBs
0            PMAP mappatura dei processi (0=Row-,1=Column-major)
1            # di griglie di processo (P x Q)
1            Ps
1            Qs
16.0         soglia
1            # di fattore di pannello
2            PFACTs (0=sinistra, 1=Crout, 2=Destra)
1            # di criterio di arresto ricorsivo
4            NBMINs (>= 1)
1            # di pannelli in ricorsione
2            NDIVs
1            # di fattore di pannello ricorsivo.
1            RFACTs (0=sinistra, 1=Crout, 2=Destra)
1            # di broadcast
1            BCASTs (0=1rg,1=1rM,2=2rg,3=2rM,4=Lng,5=LnM)
1            # di profondità di lookahead
1            DEPTHs (>=0)
2            SWAP (0=bin-exch,1=lungo,2=misto)
64           soglia di scambio
0            L1 in (0=trasposto,1=non-trasposto) forma
0            U  in (0=trasposto,1=non-trasposto) forma
1            Equilibration (0=no,1=sì)
8            allineamento della memoria in doppio (> 0)

I contenuti di questo file devono essere variati mediante il metodo di prova ed errore, fino a ottenere un output soddisfacente. Per conoscere ciascun parametro e come cambiarlo, fai riferimento a un documento qui. Per saltare al punto principale, inizia a leggere dalla pagina n. 6 in quel documento.

6 Eseguire HPL su un singolo nodo

Una volta che il file HPL.dat è pronto, possiamo eseguire l’HPL. Il file HPL.dat sopra è per un singolo nodo o processore. Il prodotto dei valori PQ nel file sopra dà il numero di processori per cui l’HPL viene testato. Quindi dal file sopra P=1 e Q=1 , 11=1, quindi è per un singolo processore. Ora per eseguirlo usa i comandi:

cd bin/rpi  
./xhpl

L’output appare simile a quanto mostrato di seguito:

================================================================================
HPLinpack 2.1  --  High-Performance Linpack benchmark  --   26 ottobre 2012
Scritto da A. Petitet e R. Clint Whaley,  Innovative Computing Laboratory, UTK
Modificato da Piotr Luszczek, Innovative Computing Laboratory, UTK
Modificato da Julien Langou, University of Colorado Denver
================================================================================

Un'illustrazione dei parametri di input/output segue:
T/V    : Tempo di muro / variante codificata.
N      : L'ordine della matrice dei coefficienti A.
NB     : Il fattore di blocco della partizione.
P      : Il numero di righe di processo.
Q      : Il numero di colonne di processo.
Tempo   : Tempo in secondi per risolvere il sistema lineare.
Gflops : Tasso di esecuzione per risolvere il sistema lineare.

I seguenti valori dei parametri saranno utilizzati:

N      :   5040 
NB     :     128 
PMAP   : Mappatura dei processi Row-major
P      :       1 
Q      :       1 
PFACT  :   Destra 
NBMIN  :       4 
NDIV   :       2 
RFACT  :   Crout 
BCAST  :  1ringM 
DEPTH  :       1 
SWAP   : Mix (soglia = 64)
L1     : forma trasposta
U      : forma trasposta
EQUIL  : sì
ALIGN  : 8 parole in doppia precisione

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

- La matrice A è generata casualmente per ciascun test.
- Il seguente controllo dei residui scalati sarà calcolato:
      ||Ax-b||_oo / ( eps * ( || x ||_oo * || A ||_oo + || b ||_oo ) * N )
- La precisione relativa della macchina (eps) è considerata               1.110223e-16
- I test computazionali superano se i residui scalati sono inferiori a                16.0

Inoltre, dobbiamo concentrarci sul risultato finale. L’output finale che appare nel terminale sarà simile a quanto mostrato di seguito. L’ultimo valore fornisce la velocità e i valori precedenti mostrano i diversi parametri forniti. Nel contenuto sottostante, la velocità è mostrata in Gflops e il suo valore è di circa 1.21e-01 Gflops , che quando convertito dà 121 Mega FLOPS (MFLOPS).

================================================================================
T/V                N    NB     P     Q               Tempo                 Gflops
--------------------------------------------------------------------------------
WR11C2R4       21400   128     3    11              537.10              1.210e-01
HPL_pdgesv() inizio tempo Lun 23 giu 17:29:42 2014

HPL_pdgesv() fine tempo   Lun 23 giu 17:55:19 2014

--------------------------------------------------------------------------------
||Ax-b||_oo/(eps*(||A||_oo*||x||_oo+||b||_oo)*N)=        0.0020152 ...... SUPERATO
================================================================================

Si prega di notare che a seconda del tuo Raspberry Pi la velocità e il tempo impiegato potrebbero essere significativamente diversi. Quindi ti prego di non usare questi risultati come confronto con il tuo nodo o cluster.

7 Eseguire HPL su più nodi

Quando vogliamo eseguire HPL per più nodi, dovremo cambiare il file HPL.dat. Qui assumiamo di avere 32 nodi. Quindi il prodotto di PQ dovrebbe essere 32. Ho scelto P=4 , Q=8 quindi 48=32. Quindi oltre a questo cambiamento, dovremo cambiare il valore di N, tramite prove ed errori, abbiamo ottenuto la massima velocità per N=17400. Il contenuto finale del file è mostrato di seguito. apporta quelle modifiche di conseguenza nel tuo file “HPL.dat”.

HPLinpack benchmark input file
Innovative Computing Laboratory, University of Tennessee
HPL.out      nome del file di output (se presente)
6            dispositivo out (6=stdout,7=stderr,file)
1            # di dimensioni dei problemi (N)
17400         Ns
1            # di NBs
128          NBs
0            PMAP mappatura dei processi (0=Row-,1=Column-major)
1            # di griglie di processo (P x Q)
4            Ps
8            Qs
16.0         soglia
1            # di fattore di pannello
2            PFACTs (0=sinistra, 1=Crout, 2=Destra)
1            # di criterio di arresto ricorsivo
4            NBMINs (>= 1)
1            # di pannelli in ricorsione
2            NDIVs
1            # di fattore di pannello ricorsivo.
1            RFACTs (0=sinistra, 1=Crout, 2=Destra)
1            # di broadcast
1            BCASTs (0=1rg,1=1rM,2=2rg,3=2rM,4=Lng,5=LnM)
1            # di profondità di lookahead
1            DEPTHs (>=0)
2            SWAP (0=bin-exch,1=lungo,2=misto)
64           soglia di scambio
0            L1 in (0=trasposto,1=non-trasposto) forma
0            U  in (0=trasposto,1=non-trasposto) forma
1            Equilibration (0=no,1=sì)
8            allineamento della memoria in doppio (> 0)

Una volta fatto ciò, dovremo eseguire nuovamente l’HPL. Usa il seguente comando. Ricorda di cambiare il percorso nel comando qui sotto per rappresentare il percorso del file macchina nel tuo sistema.

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

Il risultato di questo sarà simile a quanto mostrato sopra per un nodo, ma avrà sicuramente una velocità maggiore.

Questo tipo di modifiche può essere effettuato a seconda del numero di nodi o processori nel sistema e i risultati del benchmark possono essere trovati. E come ho già accennato, per saperne di più su come impostare i valori nel file HPL.dat, vai al documento qui e leggilo.