Open SpeedShop

De Wiki de Calcul Québec
Aller à : Navigation, rechercher
Autres langues :anglais 100% • ‎français 100%

Sommaire

Description

Open|SpeedShop est un outil de profilage avancé, ouvert et gratuit qui permet de profiler à la fois les codes séquentiels, parallélisés par fils d'exécution (threads) et MPI. Il permet de profiler aussi bien les applications compilées avec les informations de débogage (option de compilation -g) que ceux compilés sans ces informations. La différence sera dans le niveau de détail disponible. Il s'agit d'un profileur modulaire dont les fonctionnalités s'ajustent selon les outils mis à sa disposition. Par exemple, si les compteurs de performance matériels sont accessibles via PAPI (Performance Application Programming Interface), Open|SpeedShop peut en tirer profit pour vous informer sur les défauts de cache (cache miss). Open|SpeedShop utilise des moyens d'analyse généralement peu intrusifs, ralentissant peu l'exécution du programme. Open|SpeedShop dispose d'une interface graphique utilisable en exportation X11, mais aussi d'une ligne de commande avancée permettant de récupérer les résultats automatiquement.

Liens intéressants

Principe de fonctionnement

Le profilage avec Open|SpeedShop est basé sur la notion d'expérience. Une expérience est une exécution du programme avec un certain nombre de compteurs de métriques activés. Les métriques sont variées et incluent par exemple le temps passé dans chaque fonction, le nombre d'appels à une fonction, le nombre de défauts de cache (cache miss) pour chaque niveau de cache, les appels MPI, les écritures et lectures sur le système de fichier, etc. Les métriques disponibles dépendent de l'architecture sur laquelle l'expérience est exécutée.

Profilage d'applications MPI

Les applications MPI peuvent être profilées de la même façon que les applications séquentielles ou parallélisées par fil d'exécution (voir ci-dessous). Vous remplacez simplement le nom de l'exécutable par "mpirun exécutable .... Quelques exemples seront donnés ci-dessous. Pour pouvoir regrouper les résultats de tous les nœuds, Open|SpeedShop doit écrire les données brutes sur un système de fichiers partagé. Comme l'emplacement par défaut est dans le répertoire /tmp qui n'est généralement pas partagé, vous devez utiliser la variable d'environnement OPENSS_RAWDATA_DIR pour spécifier un emplacement partagé entre tous les nœuds. Nous vous conseillons d'ajouter la ligne (pour l'interpréteur de commandes Bash)

[nom@serveur $] export OPENSS_RAWDATA_DIR=$HOME


à votre fichier de soumission.

Principales expériences

Les principales expériences permettent de chronométrer chacune des fonctions, de comptabiliser les événements à l'aide de compteurs matériels, de profiler les appels de fonctions MPI et de profiler les opérations d'entrée-sortie sur le système de fichier.

Chronomètre : ossusertime

L'expérience ossusertime utilise une technique d’échantillonnage pour déterminer le temps réel inclusif et exclusif utilisé par chaque appel de fonction. Elle enregistre aussi les piles d'appels de fonctions (call stack), permettant de déterminer les chemins les plus coûteux. Pour exécuter cette expérience, utilisez la commande ossusertime :

[nom@serveur $] ossusertime executable


Lorsque l'expérience est exécutée, elle produit un fichier nommé executable-usertime.openss. Pour visualiser le résultat, exécutez la commande :

[nom@serveur $] openss -f executable-usertime.openss


Vous obtiendrez alors une fenêtre ressemblant à celle-ci :

Openspeedshop-usertime.png

Vous avez ainsi l'information sur le nom de l'exécutable, le nombre de fils d'exécution (threads) utilisés, ainsi que la liste des fonctions, les temps exclusifs, inclusifs et le pourcentage exclusif d'utilisation du processeur pour chacune des fonctions.

En cliquant deux fois sur une fonction, si l'application a été compilée avec les informations de débogage, Open|SpeedShop vous affiche le code source avec des indications sur le temps utilisé par différentes sections du code, tel qu'illustré dans cette image :

Openspeedshop-source.png

Vous pouvez aussi identifier les chemins d'exécution les plus coûteux en cliquant sur l'icône HC. Vous obtenez alors une fenêtre ressemblant à celle-ci :

Openspeedshop-hotcallpaths.png

Si l'application est parallélisée avec des fils d'exécution, via OpenMP par exemple, vous pouvez aussi avoir des informations sur l'équilibre de la charge entre les fils en cliquant sur l'icône LB. Vous aurez alors une fenêtre ressemblant à celle-ci :

Openspeedshop-loadbalance.png

Vous pouvez ainsi déterminer si une portion significative du code est exécutée uniquement par un fil d'exécution. Si tel est le cas, vous aurez des temps d'exécution exclusif maximum, minimum et moyen tous égaux, et correspondant tous au même numéro de fil d'exécution posix. Via les temps d'exécution minimum, maximum et moyen, vous pouvez aussi jauger à quel point votre calcul est bien distribué sur tous vos fils d'exécution.

Compteurs d'événements matériels : osshwcsamp

L'expérience osshwcsamp utilise une technique d'échantillonnage statistique ainsi que les compteurs matériels rendus disponibles par PAPI afin de vous informer sur des événements couteux tels que les défauts de cache (cache miss). Les défauts de cache se produisent lorsque les données à traiter par le processeur ne sont pas disponibles dans sa mémoire cache. Il doit alors aller chercher ces données en mémoire vive. Grossièrement, on considère que chaque niveau de cache supplémentaire (les processeurs modernes en ont trois) est deux fois plus lent que le précédent. Ainsi, le cache de niveau 3 (L3) est deux fois plus lent que le cache de niveau 2 (L2), qui est lui-même deux fois plus lent que le cache de niveau 1 (L1). L'accès à la mémoire vive est quant à lui environ 10 fois plus lent que l'accès au cache L3, et l'accès au disque est environ un million de fois plus lent que l'accès à la mémoire vive.

Temps d'accès typique pour les unités de stockage de données
Unité de stockage Temps d'accès
Cache L1 quelques nanosecondes
Cache L2 quelques nanosecondes de plus que L1
Cache L3 quelques nanosecondes de plus que L2
Mémoire vive ~10-100 nanosecondes
Disques durs ~10-100 millisecondes

Comme la taille des unités de stockage décroît alors que leur vitesse s'accroît, il est généralement inutile d'essayer de minimiser les défauts de cache L1, qui a généralement une taille d'à peine 30 ko divisée pour les instructions et les données. Les meilleurs gains de performance sont obtenus en minimisant, dans cet ordre :

  1. Les accès disque
  2. Les accès mémoire (défauts de cache L3)
  3. Les accès au cache L3 (défauts de cache L2)

L'expérience osshwcsamp permet de profiler les points 2 et 3 ci-dessus en fournissant les données de défauts de cache L2 et L3. Pour exécuter l'expérience, utilisez la commande :

[nom@serveur $] osshwcsamp <executable> <compteurs>


La liste des compteurs disponibles peut être obtenue via la commande

[nom@serveur $] papi_avail | grep Yes


Notez que vous devriez exécuter cette commande sur un nœud de calcul (via une tâche interactive ou à l'intérieur d'un script de soumission), puisque les compteurs disponibles peuvent être différents sur les nœuds interactifs.

L'expérience suivante

[nom@serveur $] osshwcsamp executable PAPI_L2_DCM,PAPI_L2_DCH


enregistrera par exemple les défauts de cache de données et les accès en cache réussis pour le cache de niveau 2, alors que l'expérience

[nom@serveur $] osshwcsamp executable PAPI_L3_DCM,PAPI_L3_DCH


vous renseignera sur ces mêmes métriques, mais pour le cache de niveau 3.

Lorsque l'expérience est terminée, Open|SpeedShop génère un fichier nommé executable-hwcsamp.openss. En l'ouvrant via la commande

[nom@serveur $] openss -f executable-hwcsamp.openss


vous obtenez une fenêtre ressemblant à celle-ci :

Openspeedshop-hwc.png

Appels de fonctions MPI : ossmpi et ossmpit

Les expériences ossmpi et ossmpit permettent d'analyser les appels de fonctions MPI. Pour les utiliser, exécutez

[nom@serveur $] ossmpi "mpirun executable"


ou

[nom@serveur $] ossmpit "mpirun executable"


La différence entre ossmpi et ossmpit est que ossmpit garde la trace des appels de fonctions. Vous pouvez ainsi déterminer par quel chemin les fonctions MPI sont appelées. Note : Afin qu'Open|SpeedShop puisse regrouper les données de plusieurs nœuds, vous devez définir la variable d'environnement OPENSS_RAWDATA_DIR pour qu'elle pointe vers un répertoire sur un système de fichiers partagé entre tous les nœuds. La valeur par défaut est /tmp qui est généralement local à chaque nœud de calcul. Par exemple, exécutez (en Bash) :

[nom@serveur $] export OPENSS_RAWDATA_DIR=$HOME


En ouvrant le fichier résultant executable-mpi-openmpi.openss dans l'interface graphique, l'affichage ressemblera à

Openspeedshop-ossmpi.png

Comme pour les fils d'exécution, vous pouvez obtenir des informations sur l'équilibre de la charge des rangs via l'icône LB :

Openspeedshop-ossmpi-loadbalance.png

Écritures et lectures sur le système de fichiers : ossio et ossiot

Ces deux expériences analysent les appels de fonctions d'écriture et de lecture sur le système de fichiers. Vous les exécutez via

 
 [nom@serveur $] ossio executable
 [nom@serveur $] ossiot executable
 


ou

 
 [nom@serveur $] ossio "mpirun executable"
 [nom@serveur $] ossiot "mpirun executable"
 


dans le cas d'une application MPI. Tout comme dans le cas ossmpi et ossmpit, l'expérience ossiot rajoute l'information de pile d'exécution permettant de suivre les chemins menant à des appels d'entrée-sortie. En ouvrant le fichier résultant dans openss, l'affichage donne :

Openspeedshop-ossio.png

avec (dans un cas MPI) des informations d'équilibre de charge :

Openspeedshop-ossio-loadbalance.png

Extraire les données en ligne de commande

Open|SpeedShop fournit une interface en ligne de commande qui permet d'extraire des informations parfois plus facilement que via l'interface graphique. Vous pouvez y accéder avec l'option -cli.

Il est aussi possible de scripter l'analyse des résultats en lot via l'option -batch. Le script suivant est particulièrement utile pour extraire les informations d'une expérience pour chacun des fils d'exécution :

Fichier : analyse-fils.sh
#! /bin/bash
 
outputdir=$1
file=$2
cache=tmp.$$
 
rm -r $outputdir
mkdir -p $outputdir
 
echo "Getting thread IDs"
openss -batch -f $file > $cache << EOF
list -v threads
EOF
 
for threadid in $(cat $cache | grep "^[0-9]"); do
	echo "Getting data for thread $threadid"
	openss -batch -f $file > $outputdir/$threadid << EOF
expview -t $threadid
EOF
done
 
echo "Getting load balance info"
openss -batch -f $file > $outputdir/loadbalance << EOF
expview -m loadbalance -v functions
EOF
 
rm $cache


En bref, ce script récupère la liste des numéros de fil d'exécution via la commande Open|SpeedShop list -v threads, puis extrait les informations pour chacun des fils via la commande expview -t numéro_de_fil, ainsi que les informations d'équilibre de charge via la commande expview -m loadbalance -v functions. Le script prend deux arguments en paramètre : le répertoire dans lequel écrire les données (qui est créé s'il n'existe pas) et le nom du fichier .openss à analyser. Par exemple :

[nom@serveur $] ./analyse.sh resultat mon_application-usertime.openss


Le fichier resultat/loadbalance contiendra les mêmes informations que l'option LB via l'interface graphique, par exemple :

Fichier : loadbalance
[openss]: The restored experiment identifier is:  -x 1
 
        Max   Posix ThreadId          Min   Posix ThreadId      Average  Function (defining location)
  Exclusive           of Max    Exclusive           of Min    Exclusive
Time Across                   Time Across                   Time Across
      Posix                         Posix                         Posix
ThreadIds(s)                   ThreadIds(s)                   ThreadIds(s)
 
 223.057138  140169854267312   127.942855       1144858944   145.674997  gomp_iter_static_next (libgomp.so.1.0.0: iter.c,39)
 211.628567       1128073536   153.999997  140169854267312   193.735710  computeRhod<double> (exe_MEevolution_optimized_omp_v2.out: TMasterEquation.hpp,821)
 187.914282  140169854267312   137.485712       1119680832   162.339282  gomp_iter_ull_static_next (libgomp.so.1.0.0: iter_ull.c,40)
 167.371425       1092548928   155.742854       1111288128   161.321425  Tsdh_c_Tzduh<std::complex<double>, double> (exe_MEevolution_optimized_omp_v2.out: home_blas_template.hpp,1741)
 101.857141       1092548928    90.371427       1128073536    94.496427  Tsdg_cc_Tduh<double, std::complex<double> > (exe_MEevolution_optimized_omp_v2.out: home_blas_template.hpp,2337)
  84.057141       1136466240    26.571428  140169854267312    68.949999  do_spin (libgomp.so.1.0.0: wait.h,48)
  71.085713  140169854267312    43.371428       1144858944    58.339285  Tmdg_c_Tzduh<double, double> (exe_MEevolution_optimized_omp_v2.out: home_blas_template.hpp,1458)
  67.028570       1119680832    22.628571  140169854267312    55.074999  cpu_relax (libgomp.so.1.0.0: futex.h,145)
  56.114285       1128073536    54.314285       1100941632    55.117856  rkf45_apply._omp_fn.5 (libgsl.so.0.16.0: rkf45.c,322)
  54.599999       1119680832    42.028571       1128073536    47.082142  rkf45_apply._omp_fn.4 (libgsl.so.0.16.0: rkf45.c,306)
  48.485713       1119680832    38.285714  140169854267312    43.110713  rkf45_apply._omp_fn.3 (libgsl.so.0.16.0: rkf45.c,290)
  44.028571       1119680832    41.114285       1111288128    42.160713  rkf45_apply._omp_fn.6 (libgsl.so.0.16.0: rkf45.c,345)


alors que les fichiers avec un nom numérique contiendront l'information spécifique à chacun des fils d'exécution, par exemple :

Fichier : 1092548928
[openss]: The restored experiment identifier is:  -x 1
 
 Exclusive    Inclusive       % of  Function (defining location)
  CPU time  CPU time in      Total
        in     seconds.  Exclusive
  seconds.                CPU Time
188.285711   342.885707  14.064367  computeRhod<double> (exe_MEevolution_optimized_omp_v2.out: TMasterEquation.hpp,821)
167.371425   167.971425  12.502134  Tsdh_c_Tzduh<std::complex<double>, double> (exe_MEevolution_optimized_omp_v2.out: home_blas_template.hpp,1741)
140.828569   142.999997  10.519464  gomp_iter_ull_static_next (libgomp.so.1.0.0: iter_ull.c,40)
139.542854   140.971426  10.423425  gomp_iter_static_next (libgomp.so.1.0.0: iter.c,39)
101.857141   102.428569   7.608417  Tsdg_cc_Tduh<double, std::complex<double> > (exe_MEevolution_optimized_omp_v2.out: home_blas_template.hpp,2337)
 69.971427    69.971427   5.226652  Tmdg_c_Tzduh<double, double> (exe_MEevolution_optimized_omp_v2.out: home_blas_template.hpp,1458)
 68.342856   123.514283   5.105003  do_spin (libgomp.so.1.0.0: wait.h,48)
 55.942856    69.799999   4.178760  rkf45_apply._omp_fn.5 (libgsl.so.0.16.0: rkf45.c,322)
 55.171427    55.171427   4.121137  cpu_relax (libgomp.so.1.0.0: futex.h,145)
 52.457142    71.285713   3.918388  rkf45_apply._omp_fn.4 (libgsl.so.0.16.0: rkf45.c,306)
 45.514285    65.799999   3.399778  rkf45_apply._omp_fn.3 (libgsl.so.0.16.0: rkf45.c,290)
 41.457142    68.971427   3.096722  rkf45_apply._omp_fn.6 (libgsl.so.0.16.0: rkf45.c,345)
 37.942856    38.257142   2.834215  Tmdg_cc_Tduh<double, std::complex<double> > (exe_MEevolution_optimized_omp_v2.out: home_blas_template.hpp,2121)
 37.171428    57.857142   2.776592  rkf45_apply._omp_fn.2 (libgsl.so.0.16.0: rkf45.c,276)


Un script équivalent peut être utilisé pour une tâche MPI, afin d'extraire l'information pour chacun des rangs MPI :

Fichier : analyse-rangs.sh
#! /bin/bash
 
outputdir=$1
file=$2
cache=tmp.$$
 
rm -r $outputdir
mkdir -p $outputdir
 
echo "Getting rank IDs"
openss -batch -f $file > $cache << EOF
list -v ranks
EOF
 
for rankid in $(cat $cache | grep "^[0-9]"); do
	echo "Getting data for rank $rankid"
	openss -batch -f $file > $outputdir/$rankid << EOF
expview -r $rankid
EOF
done
 
echo "Getting load balance info"
openss -batch -f $file > $outputdir/loadbalance << EOF
expview -m loadbalance -v functions
EOF
 
rm $cache


Dans ce cas-ci, les informations du fichier loadbalance référeront au rang MPI plutôt qu'au numéro de fil d'exécution :

Fichier : exemple_loadbalance
[openss]: The restored experiment identifier is:  -x 1
 
        Max  Rank        Min  Rank     Average  Function (defining location)
  Exclusive    of  Exclusive    of   Exclusive
   I/O call   Max   I/O call   Min    I/O call
    time in          time in           time in
   seconds.         seconds.          seconds.
     Across           Across            Across
  Ranks(ms)        Ranks(ms)         Ranks(ms)
2018.246179     6   0.009193    13  979.827349  __write (libpthread-2.5.so)
  27.855668    14   0.011322     9    4.411268  read (libpthread-2.5.so)
  15.325733     0   0.513742     6    5.176433  open64 (libpthread-2.5.so)
   0.517390     0   0.025608     9    0.157019  close (libpthread-2.5.so)
   0.376123     0   0.007962     7    0.036721  __lseek64 (libpthread-2.5.so)


Particularités de chaque serveur

Pour utiliser Open|SpeedShop sur Colosse vous devez charger les modules apps/openspeedshop/2.1 :
[usager@colosse $] module load apps/openspeedshop/2.1


Les compteurs disponibles sur les nœuds de calcul sont les suivants :

[usager@colosse $] papi_avail | grep Yes
 PAPI_L1_DCM  0x80000000  Yes   No   Level 1 data cache misses
PAPI_L1_ICM  0x80000001  Yes   No   Level 1 instruction cache misses
PAPI_L2_DCM  0x80000002  Yes   Yes  Level 2 data cache misses
PAPI_L2_ICM  0x80000003  Yes   No   Level 2 instruction cache misses
PAPI_L1_TCM  0x80000006  Yes   Yes  Level 1 cache misses
PAPI_L2_TCM  0x80000007  Yes   No   Level 2 cache misses
PAPI_L3_TCM  0x80000008  Yes   No   Level 3 cache misses
PAPI_L3_LDM  0x8000000e  Yes   No   Level 3 load misses
PAPI_TLB_DM  0x80000014  Yes   No   Data translation lookaside buffer misses
PAPI_TLB_IM  0x80000015  Yes   No   Instruction translation lookaside buffer misses
PAPI_TLB_TL  0x80000016  Yes   Yes  Total translation lookaside buffer misses
PAPI_L1_LDM  0x80000017  Yes   No   Level 1 load misses
PAPI_L1_STM  0x80000018  Yes   No   Level 1 store misses
PAPI_L2_LDM  0x80000019  Yes   No   Level 2 load misses
PAPI_L2_STM  0x8000001a  Yes   No   Level 2 store misses
PAPI_BR_UCN  0x8000002a  Yes   No   Unconditional branch instructions
PAPI_BR_CN   0x8000002b  Yes   No   Conditional branch instructions
PAPI_BR_TKN  0x8000002c  Yes   No   Conditional branch instructions taken
PAPI_BR_NTK  0x8000002d  Yes   Yes  Conditional branch instructions not taken
PAPI_BR_MSP  0x8000002e  Yes   No   Conditional branch instructions mispredicted
PAPI_BR_PRC  0x8000002f  Yes   Yes  Conditional branch instructions correctly predicted
PAPI_TOT_IIS 0x80000031  Yes   No   Instructions issued
PAPI_TOT_INS 0x80000032  Yes   No   Instructions completed
PAPI_FP_INS  0x80000034  Yes   No   Floating point instructions
PAPI_LD_INS  0x80000035  Yes   No   Load instructions
PAPI_SR_INS  0x80000036  Yes   No   Store instructions
PAPI_BR_INS  0x80000037  Yes   No   Branch instructions
PAPI_RES_STL 0x80000039  Yes   No   Cycles stalled on any resource
PAPI_TOT_CYC 0x8000003b  Yes   No   Total cycles
PAPI_LST_INS 0x8000003c  Yes   Yes  Load/store instructions completed
PAPI_L1_DCH  0x8000003e  Yes   Yes  Level 1 data cache hits
PAPI_L2_DCH  0x8000003f  Yes   Yes  Level 2 data cache hits
PAPI_L1_DCA  0x80000040  Yes   No   Level 1 data cache accesses
PAPI_L2_DCA  0x80000041  Yes   No   Level 2 data cache accesses
PAPI_L3_DCA  0x80000042  Yes   Yes  Level 3 data cache accesses
PAPI_L1_DCR  0x80000043  Yes   No   Level 1 data cache reads
PAPI_L2_DCR  0x80000044  Yes   No   Level 2 data cache reads
PAPI_L3_DCR  0x80000045  Yes   No   Level 3 data cache reads
PAPI_L1_DCW  0x80000046  Yes   No   Level 1 data cache writes
PAPI_L2_DCW  0x80000047  Yes   No   Level 2 data cache writes
PAPI_L3_DCW  0x80000048  Yes   No   Level 3 data cache writes
PAPI_L1_ICH  0x80000049  Yes   No   Level 1 instruction cache hits
PAPI_L2_ICH  0x8000004a  Yes   No   Level 2 instruction cache hits
PAPI_L1_ICA  0x8000004c  Yes   No   Level 1 instruction cache accesses
PAPI_L2_ICA  0x8000004d  Yes   No   Level 2 instruction cache accesses
PAPI_L3_ICA  0x8000004e  Yes   No   Level 3 instruction cache accesses
PAPI_L1_ICR  0x8000004f  Yes   No   Level 1 instruction cache reads
PAPI_L2_ICR  0x80000050  Yes   No   Level 2 instruction cache reads
PAPI_L3_ICR  0x80000051  Yes   No   Level 3 instruction cache reads
PAPI_L2_TCH  0x80000056  Yes   Yes  Level 2 total cache hits
PAPI_L1_TCA  0x80000058  Yes   Yes  Level 1 total cache accesses
PAPI_L2_TCA  0x80000059  Yes   No   Level 2 total cache accesses
PAPI_L3_TCA  0x8000005a  Yes   No   Level 3 total cache accesses
PAPI_L1_TCR  0x8000005b  Yes   Yes  Level 1 total cache reads
PAPI_L2_TCR  0x8000005c  Yes   Yes  Level 2 total cache reads
PAPI_L3_TCR  0x8000005d  Yes   Yes  Level 3 total cache reads
PAPI_L2_TCW  0x8000005f  Yes   No   Level 2 total cache writes
PAPI_L3_TCW  0x80000060  Yes   No   Level 3 total cache writes
PAPI_FP_OPS  0x80000066  Yes   Yes  Floating point operations
PAPI_SP_OPS  0x80000067  Yes   Yes  Floating point operations; optimized to count scaled single precision vector operations
PAPI_DP_OPS  0x80000068  Yes   Yes  Floating point operations; optimized to count scaled double precision vector operations
PAPI_VEC_SP  0x80000069  Yes   No   Single precision vector/SIMD instructions
PAPI_VEC_DP  0x8000006a  Yes   No   Double precision vector/SIMD instructions
PAPI_REF_CYC 0x8000006b  Yes   No   Reference clock cycles
Pour utiliser Open|SpeedShop sur Mp2 vous devez charger les modules openss/2.0.2 et papi/5.1.1 :
[usager@ip01-mp2 $] module load openss/2.0.2 papi/5.1.1


Les compteurs disponibles sur les nœuds de calcul sont les suivants :

[usager@ip01-mp2 $] papi_avail | grep Yes
 PAPI_L1_DCM  0x80000000  Yes   No   Level 1 data cache misses
PAPI_L1_ICM  0x80000001  Yes   No   Level 1 instruction cache misses
PAPI_L2_DCM  0x80000002  Yes   No   Level 2 data cache misses
PAPI_L2_ICM  0x80000003  Yes   No   Level 2 instruction cache misses
PAPI_L1_TCM  0x80000006  Yes   Yes  Level 1 cache misses
PAPI_L2_TCM  0x80000007  Yes   No   Level 2 cache misses
PAPI_FPU_IDL 0x80000012  Yes   No   Cycles floating point units are idle
PAPI_TLB_DM  0x80000014  Yes   No   Data translation lookaside buffer misses
PAPI_TLB_IM  0x80000015  Yes   No   Instruction translation lookaside buffer misses
PAPI_TLB_TL  0x80000016  Yes   Yes  Total translation lookaside buffer misses
PAPI_STL_ICY 0x80000025  Yes   No   Cycles with no instruction issue
PAPI_HW_INT  0x80000029  Yes   No   Hardware interrupts
PAPI_BR_TKN  0x8000002c  Yes   No   Conditional branch instructions taken
PAPI_BR_MSP  0x8000002e  Yes   No   Conditional branch instructions mispredicted
PAPI_TOT_INS 0x80000032  Yes   No   Instructions completed
PAPI_FP_INS  0x80000034  Yes   No   Floating point instructions
PAPI_BR_INS  0x80000037  Yes   No   Branch instructions
PAPI_VEC_INS 0x80000038  Yes   No   Vector/SIMD instructions (could include integer)
PAPI_RES_STL 0x80000039  Yes   No   Cycles stalled on any resource
PAPI_TOT_CYC 0x8000003b  Yes   No   Total cycles
PAPI_L1_DCH  0x8000003e  Yes   Yes  Level 1 data cache hits
PAPI_L2_DCH  0x8000003f  Yes   Yes  Level 2 data cache hits
PAPI_L1_DCA  0x80000040  Yes   No   Level 1 data cache accesses
PAPI_L2_DCA  0x80000041  Yes   No   Level 2 data cache accesses
PAPI_L1_ICH  0x80000049  Yes   Yes  Level 1 instruction cache hits
PAPI_L2_ICH  0x8000004a  Yes   No   Level 2 instruction cache hits
PAPI_L1_ICA  0x8000004c  Yes   No   Level 1 instruction cache accesses
PAPI_L2_ICA  0x8000004d  Yes   No   Level 2 instruction cache accesses
PAPI_L1_ICR  0x8000004f  Yes   No   Level 1 instruction cache reads
PAPI_L1_TCH  0x80000055  Yes   Yes  Level 1 total cache hits
PAPI_L2_TCH  0x80000056  Yes   Yes  Level 2 total cache hits
PAPI_L1_TCA  0x80000058  Yes   Yes  Level 1 total cache accesses
PAPI_L2_TCA  0x80000059  Yes   No   Level 2 total cache accesses
PAPI_FML_INS 0x80000061  Yes   No   Floating point multiply instructions
PAPI_FAD_INS 0x80000062  Yes   No   Floating point add instructions (Also includes subtract instructions)
PAPI_FDV_INS 0x80000063  Yes   No   Floating point divide instructions (Counts both divide and square root instructions)
PAPI_FSQ_INS 0x80000064  Yes   No   Floating point square root instructions (Counts both divide and square root instructions)
PAPI_FP_OPS  0x80000066  Yes   No   Floating point operations
PAPI_SP_OPS  0x80000067  Yes   No   Floating point operations; optimized to count scaled single precision vector operations
PAPI_DP_OPS  0x80000068  Yes   No   Floating point operations; optimized to count scaled double precision vector operations
Pour utiliser Open|SpeedShop sur Guillimin vous devez charger les modules iomkl/2015b et OpenSpeedShop/2.2 :
[usager@guillimin $] module load iomkl/2015b OpenSpeedShop/2.2


Les compteurs disponibles sur les nœuds de calcul sont les suivants :

[usager@guillimin $] papi_avail | grep Yes
 PAPI_L1_DCM  0x80000000  Yes   No   Level 1 data cache misses
PAPI_L1_ICM  0x80000001  Yes   No   Level 1 instruction cache misses
PAPI_L2_DCM  0x80000002  Yes   Yes  Level 2 data cache misses
PAPI_L2_ICM  0x80000003  Yes   No   Level 2 instruction cache misses
PAPI_L1_TCM  0x80000006  Yes   Yes  Level 1 cache misses
PAPI_L2_TCM  0x80000007  Yes   No   Level 2 cache misses
PAPI_L3_TCM  0x80000008  Yes   No   Level 3 cache misses
PAPI_L3_LDM  0x8000000e  Yes   No   Level 3 load misses (Westmere)
PAPI_TLB_DM  0x80000014  Yes No/Yes Data translation lookaside buffer misses (Westmere/Sandy Bridge)
PAPI_TLB_IM  0x80000015  Yes   No   Instruction translation lookaside buffer misses
PAPI_TLB_TL  0x80000016  Yes   Yes  Total translation lookaside buffer misses
PAPI_L1_LDM  0x80000017  Yes   No   Level 1 load misses
PAPI_L1_STM  0x80000018  Yes   No   Level 1 store misses
PAPI_L2_LDM  0x80000019  Yes   No   Level 2 load misses (Westmere)
PAPI_L2_STM  0x8000001a  Yes   No   Level 2 store misses
PAPI_STL_ICY 0x80000025  Yes   No   Cycles with no instruction issue (Sandy Bridge)
PAPI_BR_UCN  0x8000002a  Yes No/Yes Unconditional branch instructions
PAPI_BR_CN   0x8000002b  Yes   No   Conditional branch instructions
PAPI_BR_TKN  0x8000002c  Yes No/Yes Conditional branch instructions taken
PAPI_BR_NTK  0x8000002d  Yes Yes/No Conditional branch instructions not taken
PAPI_BR_MSP  0x8000002e  Yes   No   Conditional branch instructions mispredicted
PAPI_BR_PRC  0x8000002f  Yes   Yes  Conditional branch instructions correctly predicted
PAPI_TOT_IIS 0x80000031  Yes   No   Instructions issued (Westmere)
PAPI_TOT_INS 0x80000032  Yes   No   Instructions completed
PAPI_FP_INS  0x80000034  Yes No/Yes Floating point instructions
PAPI_LD_INS  0x80000035  Yes   No   Load instructions
PAPI_SR_INS  0x80000036  Yes   No   Store instructions
PAPI_BR_INS  0x80000037  Yes   No   Branch instructions
PAPI_RES_STL 0x80000039  Yes   No   Cycles stalled on any resource (Westmere)
PAPI_TOT_CYC 0x8000003b  Yes   No   Total cycles
PAPI_LST_INS 0x8000003c  Yes   Yes  Load/store instructions completed (Westmere)
PAPI_L2_DCH  0x8000003f  Yes   Yes  Level 2 data cache hits
PAPI_L2_DCA  0x80000041  Yes   No   Level 2 data cache accesses
PAPI_L3_DCA  0x80000042  Yes   Yes  Level 3 data cache accesses
PAPI_L2_DCR  0x80000044  Yes   No   Level 2 data cache reads
PAPI_L3_DCR  0x80000045  Yes   No   Level 3 data cache reads
PAPI_L2_DCW  0x80000047  Yes   No   Level 2 data cache writes
PAPI_L3_DCW  0x80000048  Yes   No   Level 3 data cache writes
PAPI_L1_ICH  0x80000049  Yes   No   Level 1 instruction cache hits (Westmere)
PAPI_L2_ICH  0x8000004a  Yes   No   Level 2 instruction cache hits
PAPI_L1_ICA  0x8000004c  Yes   No   Level 1 instruction cache accesses (Westmere)
PAPI_L2_ICA  0x8000004d  Yes   No   Level 2 instruction cache accesses
PAPI_L3_ICA  0x8000004e  Yes   No   Level 3 instruction cache accesses
PAPI_L1_ICR  0x8000004f  Yes   No   Level 1 instruction cache reads (Westmere)
PAPI_L2_ICR  0x80000050  Yes   No   Level 2 instruction cache reads
PAPI_L3_ICR  0x80000051  Yes   No   Level 3 instruction cache reads
PAPI_L2_TCH  0x80000056  Yes   Yes  Level 2 total cache hits (Westmere)
PAPI_L2_TCA  0x80000059  Yes No/Yes Level 2 total cache accesses
PAPI_L3_TCA  0x8000005a  Yes   No   Level 3 total cache accesses
PAPI_L2_TCR  0x8000005c  Yes   Yes  Level 2 total cache reads
PAPI_L3_TCR  0x8000005d  Yes   Yes  Level 3 total cache reads
PAPI_L2_TCW  0x8000005f  Yes   No   Level 2 total cache writes
PAPI_L3_TCW  0x80000060  Yes   No   Level 3 total cache writes
PAPI_FDV_INS 0x80000063  Yes   No   Floating point divide instructions (Sandy Bridge)
PAPI_FP_OPS  0x80000066  Yes   Yes  Floating point operations
PAPI_SP_OPS  0x80000067  Yes   Yes  Floating point operations; optimized to count scaled single precision vector operations
PAPI_DP_OPS  0x80000068  Yes   Yes  Floating point operations; optimized to count scaled double precision vector operations
PAPI_VEC_SP  0x80000069  Yes No/Yes Single precision vector/SIMD instructions
PAPI_VEC_DP  0x8000006a  Yes No/Yes Double precision vector/SIMD instructions
PAPI_REF_CYC 0x8000006b  Yes   No   Reference clock cycles


Outils personnels
Espaces de noms

Variantes
Actions
Navigation
Ressources de Calcul Québec
Outils
Partager