Il benchmarking è il processo di esecuzione di alcuni dei programmi standard per valutare la velocità raggiunta da un sistema. Esistono numerosi programmi standard di bechmarking e in questo tutorial esaminiamo il sistema Linux utilizzando un noto programma chiamato HPL, noto anche come High Performance Linpack.
Introduzione
In questo tutorial spieghiamo come eseguire il benchmarking di un sistema a processore singolo, il Raspberry Pi. Per prima cosa esamineremo un singolo nodo, quindi continueremo a confrontare più nodi, ogni 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 compilata ed eseguita affinché l'HPL funzioni. Quindi, per il benchmarking di più nodi, presumo che i tuoi nodi abbiano MPICH installato e in esecuzione.
Cos'è l'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 cronometraggio per quantificare l'accuratezza della soluzione ottenuta e il tempo impiegato per calcolarla. Le migliori prestazioni ottenibili da questo software sul tuo sistema dipendono da una grande varietà di fattori. Questa implementazione è scalabile nel senso che la loro efficienza parallela viene mantenuta costante rispetto all'utilizzo della memoria per processore. Quindi possiamo usarlo per confrontare un singolo processore o una serie di processori distribuiti in parallelo. Quindi iniziamo a installare HPL.
1 Installazione delle dipendenze
HPL ha alcune dipendenze software che devono essere soddisfatte prima di poter essere installato. Sono:
- gfortran - compilatore di programmi fortran
- MPICH2 - un'implementazione di MPI
- mpich2-dev - strumenti di sviluppo
- BLAS - Sottoprogrammi di base di algebra lineare
Qui assumiamo che tu abbia installato MPICH2. Per installare altre dipendenze e pacchetti, usa il comando seguente:
sudo apt-get install libatlas-base-dev libmpich2-dev gfortran
Solo questo passaggio deve essere ripetuto in ciascuno dei nodi (Pis) presenti nel cluster.
2 Scarica HPL e configuralo
Scarica il pacchetto HPL da qui. La prossima cosa da fare è estrarre il file tar e creare un makefile basato sul modello dato. Aprire il terminale e modificare la directory in cui è archiviato 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 file make contiene tutti i dettagli di configurazione del sistema ( The raspberry pi) e anche i dettagli di varie librerie come mpich2, pacchetti atlas/blas, home directory, ecc. Nel passaggio successivo, apportiamo modifiche nel file Make.rpi.
3 Regola il file Make.rpi
Questo è un passo importante. Le modifiche mostrate di seguito variano in base al tuo sistema. Qui lo mostro rispetto al mio sistema. Si noti che le seguenti modifiche hanno parametri mostrati che sono sparsi in tutto il file Make.rpi. Quindi ti suggerisco di trovare ogni parametro e sostituire o aggiungere le modifiche e solo dopo passare al parametro successivo.
Apri il file Make.rpi usando un editor di testo usando 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 Compilazione dell'HPL
Una volta che il file Make è 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 Creazione del file di input HPL
Quello che segue è 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. È possibile utilizzare questo file direttamente per eseguire i test per un singolo nodo. Crea un file all'interno della cartella "bin/rpi" e chiamalo "HPL.dat". copia il contenuto di seguito in quel file.
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)
Il contenuto di questo file deve essere variato con il metodo per tentativi ed errori, finché non si ottiene un output soddisfacente. Per conoscere ogni parametro e come cambiarlo fare riferimento a un documento qui. Per passare al punto principale, inizia a leggere dalla pagina n. 6 in quel documento.
6 Esecuzione di 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 P*Q nel file sopra fornisce il numero di processori per cui l'HPL viene testato. Quindi dal file sopra P=1 e Q=1 , 1*1=1, quindi è per un singolo processore. Ora per eseguirlo usa i comandi:
cd bin/rpi
./xhpl
L'output ha un aspetto simile a quello mostrato di seguito:
================================================================================
HPLinpack 2.1 -- High-Performance Linpack benchmark -- October 26, 2012
Written by A. Petitet and R. Clint Whaley, Innovative Computing Laboratory, UTK
Modified by Piotr Luszczek, Innovative Computing Laboratory, UTK
Modified by Julien Langou, University of Colorado Denver
================================================================================
An explanation of the input/output parameters follows:
T/V : Wall time / encoded variant.
N : The order of the coefficient matrix A.
NB : The partitioning blocking factor.
P : The number of process rows.
Q : The number of process columns.
Time : Time in seconds to solve the linear system.
Gflops : Rate of execution for solving the linear system.
The following parameter values will be used:
N : 5040
NB : 128
PMAP : Row-major process mapping
P : 1
Q : 1
PFACT : Right
NBMIN : 4
NDIV : 2
RFACT : Crout
BCAST : 1ringM
DEPTH : 1
SWAP : Mix (threshold = 64)
L1 : transposed form
U : transposed form
EQUIL : yes
ALIGN : 8 double precision words
--------------------------------------------------------------------------------
- The matrix A is randomly generated for each test.
- The following scaled residual check will be computed:
||Ax-b||_oo / ( eps * ( || x ||_oo * || A ||_oo + || b ||_oo ) * N )
- The relative machine precision (eps) is taken to be 1.110223e-16
- Computational tests pass if scaled residuals are less than 16.0
Inoltre, dobbiamo concentrarci sul risultato finale. L'output finale che arriva sul terminale sarà simile a quello mostrato di seguito. L'ultimo valore fornisce la velocità ei valori precedenti mostrano i diversi parametri forniti. Nel contenuto seguente, la velocità è mostrata in Gflops e il suo valore è di circa 1.21e-01 Gflops , che una volta convertito fornisce 121 Mega FLOPS (MFLOPS).
================================================================================ T/V N NB P Q Time Gflops -------------------------------------------------------------------------------- WR11C2R4 21400 128 3 11 537.10 1.210e-01 HPL_pdgesv() start time Mon Jun 23 17:29:42 2014 HPL_pdgesv() end time Mon Jun 23 17:55:19 2014 -------------------------------------------------------------------------------- ||Ax-b||_oo/(eps*(||A||_oo*||x||_oo+||b||_oo)*N)= 0.0020152 ...... PASSED ================================================================================
Tieni presente che, a seconda del tuo Raspberry Pi, la velocità e il tempo impiegato potrebbero essere significativamente diversi. Quindi, per favore non utilizzare questi risultati come confronto con il tuo nodo o cluster.
7 Esecuzione di HPL su più nodi
Quando vogliamo eseguire HPL per più nodi, dovremo modificare il file HPL.dat. Supponiamo di avere 32 nodi. Quindi il prodotto di P*Q dovrebbe essere 32. Ho scelto P=4 , Q=8 quindi 4*8=32. Quindi, a parte questa modifica, dovremo cambiare il valore di N, da tentativi ed errori, abbiamo ottenuto la velocità massima per N=17400. Il contenuto del file finale è mostrato di seguito. apporta le modifiche di conseguenza nel tuo file "HPL.dat".
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)
Una volta fatto ciò, dovremo eseguire nuovamente l'HPL. Usa il seguente comando. Ricorda di cambiare il percorso nel comando seguente per rappresentare il percorso del file macchina nel tuo sistema.
cd bin/rpi
mpiexec -f ~/mpi_testing/machinefile -n 32 ./xhpl
Il risultato sarà simile a quello mostrato sopra per un nodo, ma avrà sicuramente una velocità maggiore.
Questo tipo di modifiche può essere fatto a seconda del numero di nodi o processori nel sistema e si possono trovare i risultati del benchmark. E come accennato in precedenza, per saperne di più su come impostare i valori nel file HPL.dat, vai al documento qui e leggilo.