HPL (High Performance Linpack): Benchmarking Raspberry PIs

El benchmarking es el proceso de ejecutar algunos de los programas estándar para evaluar la velocidad alcanzada por un sistema. Hay varios programas de benchmarking estándar y en este tutorial benchmarkeamos el sistema Linux utilizando un programa bien conocido llamado HPL, también conocido como High Performance Linpack.

Introducción

En este tutorial cubrimos cómo realizar el benchmarking de un sistema de un solo procesador, el Raspberry Pi. Primero benchmarkearemos un solo nodo, y luego continuaremos benchmarkeando múltiples nodos, cada nodo representando un Raspberry Pi. Hay algunas cosas que se deben tener en cuenta aquí. En primer lugar, el benchmarking de un solo nodo o múltiples nodos tiene algunas dependencias que deben satisfacerse, las cuales se cubrirán en este tutorial. PERO, en múltiples nodos hay aún más dependencias, como la implementación de MPI (como MPICH o OpenMPI) que debe estar construida y funcionando para que HPL funcione. Así que para benchmarkear múltiples nodos, asumo que tus nodos tienen MPICH instalado y funcionando.

¿Qué es HPL?

HPL es un paquete de software que resuelve un sistema lineal denso (aleatorio) en aritmética de doble precisión (64 bits) en computadoras de memoria distribuida. El paquete HPL proporciona un programa de prueba y temporización para cuantificar la precisión de la solución obtenida, así como el tiempo que tomó calcularla. El mejor rendimiento alcanzable por este software en tu sistema depende de una gran variedad de factores. Esta implementación es escalable en el sentido de que su eficiencia paralela se mantiene constante con respecto al uso de memoria por procesador. Así que podemos usar esto para benchmarkear un solo procesador o una serie de procesadores distribuidos en paralelo. Así que comencemos a instalar HPL.

1 Instalando dependencias

HPL tiene algunas dependencias de software que deben satisfacerse antes de que pueda ser instalado. Son:

gfortran - compilador de programas fortran
MPICH2 - una implementación de MPI
mpich2-dev - herramientas de desarrollo
BLAS - Subprogramas Básicos de Álgebra Lineal

Aquí asumimos que tienes MPICH2 instalado. Para instalar otras dependencias y paquetes, usa el siguiente comando:

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

Solo este paso debe repetirse en cada uno de los nodos (Pis) presentes en el clúster.

2 Descargar HPL y configurarlo

Descarga el paquete HPL desde aquí. Lo siguiente que debes hacer es extraer el archivo tar y crear un makefile basado en la plantilla dada. Abre la terminal y cambia el directorio a donde se almacena el archivo tar de HPL descargado. Ejecuta el siguiente conjunto de comandos uno tras otro.

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

El último comando copia el contenido de Make.UNKNOWN a Make.rpi. Hacemos esto porque el makefile contiene todos los detalles de configuración del sistema (el raspberry pi) y también los detalles de varias bibliotecas como mpich2, paquetes atlas/blas, directorio de inicio, etc. En el siguiente paso, hacemos cambios en el archivo Make.rpi.

3 Ajustar el archivo Make.rpi

Este es un paso importante. Los cambios que se muestran a continuación varían según tu sistema. Aquí lo muestro con respecto a mi sistema. Ten en cuenta que los siguientes cambios tienen parámetros que se distribuyen a lo largo del archivo Make.rpi. Así que te sugiero que encuentres cada parámetro y reemplaces o agregues los cambios y solo entonces continúes al siguiente parámetro.

Abre el archivo Make.rpi usando un editor de texto con el comando:

nano Make.rpi

Haz los siguientes cambios en el archivo.

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 Compilando el HPL

Una vez que el makefile esté listo, podemos comenzar con la compilación del HPL. El archivo “.xhpl” estará presente en la carpeta “bin/rpi” dentro de la carpeta HPL. Ejecuta el siguiente comando:

makeh arch=rpi

5 Creando el archivo de entrada HPL

El siguiente es un ejemplo del archivo “HPL.dat”. Este es el archivo de entrada para HPL cuando se ejecuta. Los valores proporcionados en este archivo se utilizan para generar y calcular el problema. Puedes usar este archivo directamente para ejecutar pruebas para un solo nodo. Crea un archivo dentro de la carpeta “bin/rpi” y nómbralo “HPL.dat”. Copia el contenido a continuación en ese archivo.

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)

El contenido de este archivo debe variar mediante el método de prueba y error, hasta que se obtenga una salida que sea satisfactoria. Para conocer cada uno de los parámetros y cómo cambiarlos, consulta un documento aquí. Para ir al grano, comienza a leer desde la página 6 de ese documento.

6 Ejecutando HPL en un solo nodo

Una vez que el archivo HPL.dat esté listo, podemos ejecutar el HPL. El archivo HPL.dat anterior es para un solo nodo o procesador. El producto de los valores PQ en el archivo anterior da el número de procesadores para los que se está probando el HPL. Así que del archivo anterior P=1 y Q=1, 11=1, por lo que es para un solo procesador. Ahora para ejecutarlo usa los comandos:

cd bin/rpi  
./xhpl

La salida se ve algo similar a lo que se muestra a continuación:

================================================================================
HPLinpack 2.1  --  High-Performance Linpack benchmark  --   26 de octubre de 2012
Escrito por A. Petitet y R. Clint Whaley,  Innovative Computing Laboratory, UTK
Modificado por Piotr Luszczek, Innovative Computing Laboratory, UTK
Modificado por Julien Langou, Universidad de Colorado Denver
================================================================================

Una explicación de los parámetros de entrada/salida sigue:
T/V    : Tiempo de pared / variante codificada.
N      : El orden de la matriz de coeficientes A.
NB     : El factor de bloqueo de particionamiento.
P      : El número de filas de procesos.
Q      : El número de columnas de procesos.
Tiempo  : Tiempo en segundos para resolver el sistema lineal.
Gflops : Tasa de ejecución para resolver el sistema lineal.

Los siguientes valores de parámetros se utilizarán:

N      :   5040 
NB     :     128 
PMAP   : Mapeo de procesos por filas
P      :       1 
Q      :       1 
PFACT  :   Derecho 
NBMIN  :       4 
NDIV   :       2 
RFACT  :   Crout 
BCAST  :  1ringM 
DEPTH  :       1 
SWAP   : Mezcla (umbral = 64)
L1     : forma transpuesta
U      : forma transpuesta
EQUIL  : sí
ALIGN  : 8 palabras de precisión doble

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

- La matriz A se genera aleatoriamente para cada prueba.
- Se calculará la siguiente verificación de residuo escalado:
      ||Ax-b||_oo / ( eps * ( || x ||_oo * || A ||_oo + || b ||_oo ) * N )
- La precisión relativa de la máquina (eps) se toma como               1.110223e-16
- Las pruebas computacionales pasan si los residuos escalados son menores que                16.0

Además, debemos concentrarnos en el resultado final. La salida final que aparece en la terminal se verá similar a lo que se muestra a continuación. El último valor da la velocidad y los valores anteriores muestran los diferentes parámetros proporcionados. En el contenido a continuación, la velocidad se muestra en Gflops y su valor es alrededor de 1.21e-01 Gflops, que al ser convertido da 121 Mega FLOPS (MFLOPS).

================================================================================
T/V                N    NB     P     Q               Tiempo                 Gflops
--------------------------------------------------------------------------------
WR11C2R4       21400   128     3    11              537.10              1.210e-01
HPL_pdgesv() tiempo de inicio Lun Jun 23 17:29:42 2014

HPL_pdgesv() tiempo de finalización   Lun Jun 23 17:55:19 2014

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

Ten en cuenta que dependiendo de tu Raspberry Pi, la velocidad y el tiempo tomado pueden ser significativamente diferentes. Así que por favor no uses estos resultados como comparación con tu nodo o clúster.

7 Ejecutando HPL en múltiples nodos

Cuando queremos ejecutar HPL para múltiples nodos, tendremos que cambiar el archivo HPL.dat. Aquí asumamos que tenemos 32 nodos. Así que el producto de PQ debería ser 32. Elegí P=4, Q=8 así que 48=32. Así que aparte de este cambio, tendremos que cambiar el valor de N, mediante prueba y error, obtuvimos la máxima velocidad para N=17400. El contenido final del archivo se muestra a continuación. haz esos cambios en tu archivo “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 vez que esto esté hecho, tendremos que ejecutar el HPL nuevamente. Usa el siguiente comando. Recuerda cambiar la ruta en el comando a continuación para representar la ruta del archivo de máquina en tu sistema.

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

El resultado de esto será similar a lo que se mostró anteriormente para un nodo, pero definitivamente tendrá una velocidad más alta.

Este tipo de cambios se pueden hacer dependiendo del número de nodos o procesadores en el sistema y se pueden encontrar los resultados del benchmark. Y como mencioné anteriormente, para saber más sobre cómo establecer los valores en el archivo HPL.dat, dirígete al documento aquí y léelo.