Benchmarking · 8 min read · Dec 14, 2025
HPL (High Performance Linpack): Benchmarking Raspberry PIs
Benchmarking é o processo de executar alguns dos programas padrão para avaliar a velocidade alcançada por um sistema. Existem vários programas de benchmark padrão e neste tutorial, fazemos o benchmark do sistema Linux usando um programa bem conhecido chamado HPL, também conhecido como High Performance Linpack.
Introdução
Neste tutorial, cobrimos como fazer o benchmark de um sistema de processador único, o Raspberry Pi. Primeiro, faremos o benchmark de um único nó e, em seguida, continuaremos a fazer o benchmark de múltiplos nós, cada nó representando um Raspberry Pi. Há algumas coisas a serem observadas aqui. Em primeiro lugar, fazer o benchmark de um único nó ou de múltiplos nós tem algumas dependências que devem ser atendidas, as quais serão abordadas neste tutorial. MAS, em múltiplos nós, há ainda mais dependências, como a implementação do MPI (como MPICH ou OpenMPI) que deve ser construída e estar em execução para que o HPL funcione. Portanto, para fazer o benchmark de múltiplos nós, assumo que seus nós têm o MPICH instalado e em execução.
O que é HPL?
HPL é um pacote de software que resolve um sistema linear denso (aleatório) em aritmética de precisão dupla (64 bits) em computadores de memória distribuída. O pacote HPL fornece um programa de teste e temporização para quantificar a precisão da solução obtida, bem como o tempo que levou para computá-la. O melhor desempenho alcançável por este software em seu sistema depende de uma grande variedade de fatores. Esta implementação é escalável no sentido de que sua eficiência paralela é mantida constante em relação ao uso de memória por processador. Assim, podemos usar isso para fazer o benchmark de um único processador ou de uma série de processadores distribuídos em paralelo. Então, vamos começar a instalar o HPL.
1 Instalando dependências
O HPL tem algumas dependências de software que devem ser atendidas antes que ele possa ser instalado. Elas são:
- gfortran - compilador de programa fortran
- MPICH2 - uma implementação do MPI
- mpich2-dev - ferramentas de desenvolvimento
- BLAS - Subprogramas Básicos de Álgebra Linear
Aqui, assumimos que você tem o MPICH2 instalado. Para instalar outras dependências e pacotes, use o seguinte comando:
sudo apt-get install libatlas-base-dev libmpich2-dev gfortranApenas este passo deve ser repetido em cada um dos nós (Pis) presentes no cluster.
2 Baixando o HPL e configurando-o
Baixe o pacote HPL daqui. A próxima coisa a fazer é extrair o arquivo tar e criar um makefile com base no modelo fornecido. Abra o terminal e mude o diretório para onde o arquivo tar do HPL baixado está armazenado. Execute o seguinte conjunto de comandos um após o outro.
tar xf hpl-2.1.tar.gz
cd hpl-2.1/setup
sh make_generic
cd ..
cp setup/Make.UNKNOWN Make.rpiO último comando copia o conteúdo de Make.UNKNOWN para Make.rpi. Fazemos isso porque o makefile contém todos os detalhes de configuração do sistema (o raspberry pi) e também os detalhes de várias bibliotecas, como pacotes mpich2, atlas/blas, diretório home, etc. No próximo passo, faremos alterações no arquivo Make.rpi.
3 Ajustando o arquivo Make.rpi
Este é um passo importante. As alterações mostradas abaixo variam de acordo com seu sistema. Aqui, mostro em relação ao meu sistema. Por favor, note que as seguintes alterações têm parâmetros mostrados que estão espalhados por todo o arquivo Make.rpi. Portanto, sugiro que você encontre cada parâmetro e substitua ou adicione as alterações e só então continue para o próximo parâmetro.
Abra o arquivo Make.rpi usando um editor de texto com o comando:
nano Make.rpiFaça as seguintes alterações no arquivo.
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.a4 Compilando o HPL
Uma vez que o makefile esteja pronto, podemos começar a compilação do HPL. O arquivo “.xhpl” estará presente na pasta “bin/rpi” dentro da pasta HPL. Execute o seguinte comando:
makeh arch=rpi5 Criando o arquivo de entrada do HPL
O seguinte é um exemplo do arquivo “HPL.dat”. Este é o arquivo de entrada para o HPL quando ele é executado. Os valores fornecidos neste arquivo são usados para gerar e computar o problema. Você pode usar este arquivo diretamente para executar testes para um único nó. Crie um arquivo dentro da pasta “bin/rpi” e nomeie-o como “HPL.dat”. Copie o conteúdo abaixo para esse arquivo.
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)O conteúdo deste arquivo deve ser variado pelo método de tentativa e erro, até que se obtenha uma saída satisfatória. Para saber sobre cada um dos parâmetros e como alterá-los, consulte um documento aqui. Para pular para o ponto principal, comece a ler a partir da página 6 nesse documento.
6 Executando o HPL em um único nó
Uma vez que o arquivo HPL.dat esteja pronto, podemos executar o HPL. O arquivo HPL.dat acima é para um único nó ou processador. O produto dos valores PQ no arquivo acima dá o número de processadores para os quais o HPL está sendo testado. Assim, a partir do arquivo acima, P=1 e Q=1, 11=1, portanto é para um único processador. Agora, para executá-lo, use os comandos:
cd bin/rpi
./xhplA saída se parece com algo semelhante ao que é mostrado abaixo:
================================================================================
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
Além disso, devemos nos concentrar no resultado final. A saída final que aparece no terminal será semelhante ao que é mostrado abaixo. O último valor fornece a velocidade e os valores antes disso mostram os diferentes parâmetros fornecidos. No conteúdo abaixo, a velocidade é mostrada em Gflops e seu valor é em torno de 1.21e-01 Gflops, que quando convertido dá 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
================================================================================Por favor, note que dependendo do seu Raspberry Pi, a velocidade e o tempo levado podem ser significativamente diferentes. Portanto, não use esses resultados como uma comparação com seu nó ou cluster.
7 Executando o HPL em múltiplos nós
Quando queremos executar o HPL para múltiplos nós, teremos que alterar o arquivo HPL.dat. Aqui, vamos assumir que temos 32 nós. Portanto, o produto de PQ deve ser 32. Eu escolhi P=4, Q=8, assim 48=32. Portanto, além dessa mudança, teremos que alterar o valor de N, a partir de tentativa e erro, obtivemos a velocidade máxima para N=17400. O conteúdo final do arquivo é mostrado abaixo. Faça essas alterações de acordo em seu arquivo “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)Uma vez que isso esteja feito, teremos que executar o HPL novamente. Use o seguinte comando. Lembre-se de alterar o caminho no comando abaixo para representar o caminho do arquivo de máquina em seu sistema.
cd bin/rpi
mpiexec -f ~/mpi_testing/machinefile -n 32 ./xhplO resultado disso será semelhante ao mostrado acima para um nó, mas definitivamente terá uma velocidade maior.
Esse tipo de alteração pode ser feito dependendo do número de nós ou processadores no sistema e os resultados do benchmark podem ser encontrados. E como mencionei anteriormente, para saber mais sobre como definir os valores no arquivo HPL.dat, vá até o documento aqui e dê uma lida.
Receba novas postagens na sua caixa de entrada
Sem spam. Cancele a assinatura a qualquer momento.