Raspberry Pi · 8 min read · Dec 14, 2025
HPL (High Performance Linpack) : Évaluation des Raspberry Pi
L’évaluation est le processus d’exécution de certains des programmes standard pour évaluer la vitesse atteinte par un système. Il existe un certain nombre de programmes d’évaluation standard et dans ce tutoriel, nous évaluons le système Linux en utilisant un programme bien connu appelé HPL, également connu sous le nom de High Performance Linpack.
Introduction
Dans ce tutoriel, nous couvrons comment procéder à l’évaluation d’un système à processeur unique, le Raspberry Pi. Tout d’abord, nous évaluerons un seul nœud, puis nous continuerons à évaluer plusieurs nœuds, chaque nœud représentant un Raspberry Pi. Il y a quelques points à noter ici. Tout d’abord, l’évaluation d’un seul nœud ou de plusieurs nœuds a quelques dépendances à satisfaire qui seront couvertes dans ce tutoriel. MAIS, sur plusieurs nœuds, il y a encore plus de dépendances comme l’implémentation MPI (comme MPICH ou OpenMPI) qui doit être construite et en cours d’exécution pour que le HPL fonctionne. Donc, pour évaluer plusieurs nœuds, je suppose que vos nœuds ont MPICH installé et en cours d’exécution.
Qu’est-ce que HPL ?
HPL est un package logiciel qui résout un système linéaire dense (aléatoire) en arithmétique à double précision (64 bits) sur des ordinateurs à mémoire distribuée. Le package HPL fournit un programme de test et de chronométrage pour quantifier la précision de la solution obtenue ainsi que le temps qu’il a fallu pour la calculer. La meilleure performance réalisable par ce logiciel sur votre système dépend d’une grande variété de facteurs. Cette implémentation est évolutive dans le sens où leur efficacité parallèle est maintenue constante par rapport à l’utilisation de la mémoire par processeur. Ainsi, nous pouvons l’utiliser pour évaluer un processeur unique ou une série de processeurs distribués en parallèle. Commençons donc par installer HPL.
1 Installer les dépendances
HPL a quelques dépendances logicielles qui doivent être satisfaites avant qu’il puisse être installé. Elles sont :
- gfortran - compilateur de programme fortran
- MPICH2 - une implémentation de MPI
- mpich2-dev - outils de développement
- BLAS - Sous-programmes de base d’algèbre linéaire
Ici, nous supposons que vous avez MPICH2 installé. Pour installer d’autres dépendances et packages, utilisez la commande suivante :
sudo apt-get install libatlas-base-dev libmpich2-dev gfortranSeule cette étape doit être répétée dans chacun des nœuds (Pis) présents dans le cluster.
2 Télécharger HPL et le configurer
Téléchargez le package HPL d’ici. La prochaine chose à faire est d’extraire le fichier tar et de créer un makefile basé sur le modèle donné. Ouvrez le terminal et changez le répertoire vers l’endroit où le fichier tar HPL téléchargé est stocké. Exécutez le jeu de commandes suivant une après l’autre.
tar xf hpl-2.1.tar.gz
cd hpl-2.1/setup
sh make_generic
cd ..
cp setup/Make.UNKNOWN Make.rpiLa dernière commande copie le contenu de Make.UNKNOWN dans Make.rpi. Nous faisons cela car le makefile contient tous les détails de configuration du système (le raspberry pi) ainsi que les détails de diverses bibliothèques telles que les packages mpich2, atlas/blas, répertoire personnel, etc. Dans l’étape suivante, nous apportons des modifications au fichier Make.rpi.
3 Ajuster le fichier Make.rpi
C’est une étape importante. Les modifications montrées ci-dessous varient selon votre système. Ici, je les montre par rapport à mon système. Veuillez noter que les modifications suivantes ont des paramètres montrés qui sont répartis dans tout le fichier Make.rpi. Je vous suggère donc de trouver chaque paramètre et de remplacer ou d’ajouter les modifications, puis de continuer au paramètre suivant.
Ouvrez le fichier Make.rpi à l’aide d’un éditeur de texte avec la commande :
nano Make.rpiApportez les modifications suivantes au fichier.
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 Compiler le HPL
Une fois le makefile prêt, nous pouvons commencer la compilation du HPL. Le fichier “.xhpl” sera présent dans le dossier “bin/rpi” dans le dossier HPL. Exécutez la commande suivante :
makeh arch=rpi5 Créer le fichier d’entrée HPL
Ce qui suit est un exemple du fichier “HPL.dat”. C’est le fichier d’entrée pour HPL lorsqu’il est exécuté. Les valeurs fournies dans ce fichier sont utilisées pour générer et calculer le problème. Vous pouvez utiliser ce fichier directement pour exécuter des tests pour un seul nœud. Créez un fichier dans le dossier “bin/rpi” et nommez-le “HPL.dat”. Copiez le contenu ci-dessous dans ce fichier.
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)Le contenu de ce fichier doit être varié par méthode d’essai et d’erreur, jusqu’à obtenir un résultat satisfaisant. Pour connaître chaque paramètre et comment le modifier, référez-vous à un document ici. Pour passer au point principal, commencez à lire à partir de la page 6 de ce document.
6 Exécuter HPL sur un nœud unique
Une fois le fichier HPL.dat prêt, nous pouvons exécuter le HPL. Le fichier HPL.dat ci-dessus est pour un seul nœud ou processeur. Le produit des valeurs PQ dans le fichier ci-dessus donne le nombre de processeurs pour lesquels le HPL est testé. Ainsi, d’après le fichier ci-dessus, P=1 et Q=1, 11=1, donc c’est pour un seul processeur. Maintenant, pour l’exécuter, utilisez les commandes :
cd bin/rpi
./xhplLa sortie ressemble à quelque chose de similaire à ce qui est montré ci-dessous :
================================================================================
HPLinpack 2.1 -- High-Performance Linpack benchmark -- 26 octobre 2012
Écrit par A. Petitet et R. Clint Whaley, Innovative Computing Laboratory, UTK
Modifié par Piotr Luszczek, Innovative Computing Laboratory, UTK
Modifié par Julien Langou, University of Colorado Denver
================================================================================
Une explication des paramètres d'entrée/sortie suit :
T/V : Temps d'exécution / variante codée.
N : L'ordre de la matrice des coefficients A.
NB : Le facteur de blocage de partitionnement.
P : Le nombre de lignes de processus.
Q : Le nombre de colonnes de processus.
Time : Temps en secondes pour résoudre le système linéaire.
Gflops : Taux d'exécution pour résoudre le système linéaire.
Les valeurs des paramètres suivants seront utilisées :
N : 5040
NB : 128
PMAP : Mappage de processus en mode ligne
P : 1
Q : 1
PFACT : Droit
NBMIN : 4
NDIV : 2
RFACT : Crout
BCAST : 1ringM
DEPTH : 1
SWAP : Mix (seuil = 64)
L1 : forme transposée
U : forme transposée
EQUIL : oui
ALIGN : 8 mots de précision double
--------------------------------------------------------------------------------
- La matrice A est générée aléatoirement pour chaque test.
- Le contrôle de résidu mis à l'échelle suivant sera calculé :
||Ax-b||_oo / ( eps * ( || x ||_oo * || A ||_oo + || b ||_oo ) * N )
- La précision machine relative (eps) est prise pour 1.110223e-16
- Les tests computationnels réussissent si les résidus mis à l'échelle sont inférieurs à 16.0
De plus, nous devons nous concentrer sur le résultat final. La sortie finale qui apparaît sur le terminal ressemblera à ce qui est montré ci-dessous. La dernière valeur donne la vitesse et les valeurs avant cela montrent les différents paramètres fournis. Dans le contenu ci-dessous, la vitesse est indiquée en Gflops et sa valeur est d’environ 1.21e-01 Gflops, ce qui, lorsqu’il est converti, donne 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 Lun 23 juin 17:29:42 2014
HPL_pdgesv() end time Lun 23 juin 17:55:19 2014
--------------------------------------------------------------------------------
||Ax-b||_oo/(eps*(||A||_oo*||x||_oo+||b||_oo)*N)= 0.0020152 ...... RÉUSSI
================================================================================Veuillez noter qu’en fonction de votre Raspberry Pi, la vitesse et le temps pris peuvent être significativement différents. Donc, veuillez ne pas utiliser ces résultats comme comparaison avec votre nœud ou cluster.
7 Exécuter HPL sur plusieurs nœuds
Lorsque nous voulons exécuter HPL pour plusieurs nœuds, nous devrons modifier le fichier HPL.dat. Ici, supposons que nous avons 32 nœuds. Donc, le produit de PQ devrait être 32. J’ai choisi P=4, Q=8 donc 48=32. Donc, en dehors de ce changement, nous devrons changer la valeur de N, par essai et erreur, nous avons obtenu la vitesse maximale pour N=17400. Le contenu final du fichier est montré ci-dessous. Apportez ces modifications en conséquence dans votre fichier “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)Une fois cela fait, nous devrons exécuter à nouveau le HPL. Utilisez la commande suivante. N’oubliez pas de changer le chemin dans la commande ci-dessous pour représenter le chemin du fichier machine dans votre système.
cd bin/rpi
mpiexec -f ~/mpi_testing/machinefile -n 32 ./xhplLe résultat de cela sera similaire à ce qui est montré ci-dessus pour un nœud, mais il aura définitivement une vitesse plus élevée.
Ce genre de modifications peut être effectué en fonction du nombre de nœuds ou de processeurs dans le système et les résultats de l’évaluation peuvent être trouvés. Et comme je l’ai mentionné plus tôt, pour en savoir plus sur la façon de définir les valeurs dans le fichier HPL.dat, rendez-vous dans le document ici et donnez-lui une lecture.
Recevez de nouveaux articles dans votre boîte de réception.
Aucun spam. Désabonnez-vous à tout moment.