ThreadSpotter
ThreadSpotter est un outil logiciel produit par l'entreprise américaine Rogue Wave Software [Quand ?]. Il diagnostique les problÚmes de performances liés à la localité des données, à l'utilisation du cache et à l'interaction des threads.
De maniĂšre gĂ©nĂ©rale, la bande passante du bus mĂ©moire n'a pas connu les mĂȘmes amĂ©liorations que les augmentations de performances des CPU (une observation parfois appelĂ©e memory wall (en)), et avec les systĂšmes multi-cĆur, la bande passante disponible est partagĂ©e entre tous les cĆurs. Cela fait de la prĂ©servation de cette bande passante l'une des tĂąches les plus importantes Ă accomplir afin d'obtenir des performances optimales.
ThreadSpotter détermine les schémas des modÚles d'accÚs mémoire sous-optimaux et leur applique une heuristique afin de les catégoriser, d'en expliquer les causes et de proposer des pistes d'améliorations du code.
L'outil dispose de capacités prédictives permettant de modéliser les caractéristiques des performances d'un code en fonction d'une architecture donnée (taille de cache, modÚle de processeur...). Cette possibilité d'analyse autorise l'exploration de différents scénarios à partir d'un échantillonnage unique.
Localité spatiale
[modifier | modifier le code]La Localité Spatiale fait référence à la propriété avantageuse d'accéder à des emplacements mémoires proches les uns des autres. Une faible localité spatiale est pénalisante pour différentes raisons :
- Accéder à des données trÚs éparpillées aura pour conséquence négative de transférer des données inutiles puisque ces données transitent par blocs (chunks). Cela accroßt les besoins en bande passante mémoire et impose dans la pratique des limites de performances et d'évolutivité de l'application.
- Des données inutiles vont occuper les caches, réduisant ainsi leur taille effective. Cela cause des évictions plus fréquentes et davantage d'accÚs à la mémoire.
- Les données non utilisées vont réduire la probabilité de rencontrer plus d'un élément de données utile dans une ligne de cache mappée.
ThreadSpotter indique lorsqu'au moins l'un des points suivants devient pénalisant en matiÚre de Localité Spatiale :
- Utilisation du Fetching
- Ăcriture diffĂ©rĂ©e
- Boucles imbriquées
- Partitionnement de boucles (aussi connu sous le nom de loop tiling (en))
- Fusion de boucles (en) (spatiale)
Localité temporelle
[modifier | modifier le code]La Localité Temporelle fait référence à la réutilisation des données. Réutiliser des données alors qu'elles sont encore dans le cache diminue la quantité de fetchs nécessaires et réduit généralement la charge du bus mémoire. ThreadSpotter classe ces possibilités d'optimisation en :
- Partitionnement temporel
- Fusion de boucles (en) (temporelle)
Latence mémoire
[modifier | modifier le code]Le temps qu'il faut pour initier un chargement mémoire (memory fetch) est appelé latence mémoire. Pendant ce temps, le CPU est bloqué. La pénalité induite par cette latence est de l'ordre de 100 cycles d'horloge.
Les caches ont Ă©tĂ© conçus pour masquer de tels problĂšmes, en traitant une quantitĂ© limitĂ©e de donnĂ©es Ă partir d'une mĂ©moire de petite taille, mais extrĂȘmement rapide. Cette mĂ©thode est efficace si l'ensemble des donnĂ©es peut ĂȘtre contraint Ă ĂȘtre contenu dans le cache.
Il existe une autre technique appelĂ©e prĂ©chargement mĂ©moire (memory prefetch), oĂč le transfert de donnĂ©es est effectuĂ© explicitement ou automatiquement avant que celles-ci ne soient requises. L'objectif est de faire que ces donnĂ©es soient dĂ©jĂ prĂ©sentes dans le cache avant qu'elles ne soient sollicitĂ©es.
ThreadSpotter identifie dans ce domaine les problÚmes suivants :
- Instruction de préchargement trop proche de l'utilisation des données
- Instruction de prĂ©chargement trop Ă©loignĂ©e de l'utilisation des donnĂ©es (les donnĂ©es peuvent ĂȘtre Ă©vincĂ©es avant usage)
- Instruction de préchargement inutile (car les données sont déjà présentes dans le cache)
De plus, l'outil évalue l'efficacité du mécanisme matériel de préchargement (hardware prefetcher) en modélisant son comportement et en enregistrant les cas de :
- Schémas d'accÚs mémoire irréguliers
Ăviter la pollution du cache
[modifier | modifier le code]Si les données occupent une quantité de mémoire plus grande que le cache disponible et qu'il n'y a pas de maniÚre pratique de réorganiser les schémas d'accÚs pour améliorer la réutilisation des données, alors il n'y a aucun avantage à stocker en premier lieu ces données dans le cache. Certains processeurs disposent à cet effet d'instructions spéciales permettant de contourner l'utilisation des caches.
ThreadSpotter trouve des opportunités de :
- Remplacer les instructions d'écriture avec des instructions d'écriture non-temporelles.
- Insérer des instructions de prefetching non-temporel afin d'éviter que les données ne soient mappées dans des caches de plus haut niveau.
Cohérence de cache
[modifier | modifier le code]Lorsqu'il y a plusieurs caches dans un systĂšme, la consistance des uns envers les autres doit ĂȘtre assurĂ©e. Les activitĂ©s gĂ©rant cette cohĂ©rence des donnĂ©es prennent un certain temps pour ĂȘtre menĂ©es Ă bien. De la mĂȘme maniĂšre qu'il est important d'observer les propriĂ©tĂ©s de localitĂ© dans la façon dont vous accĂ©dez aux emplacements de la mĂ©moire vive, il est important de prĂȘter attention et de limiter le trafic liĂ© Ă cette cohĂ©rence.
Par exemple, dans un scĂ©nario producteur / consommateur oĂč deux threads utilisent un morceau de mĂ©moire partagĂ©e pour transfĂ©rer des donnĂ©es entre elles, le propriĂ©taire de cette mĂ©moire va Ă plusieurs reprises passer de cache producteur Ă cache consommateur. Si toutes les donnĂ©es dans une ligne de cache ne sont pas entiĂšrement consommĂ©es, mais que le producteur visite Ă nouveau la ligne de cache, alors on est dans le cas d'un modĂšle de communication pauvre. Il serait plus appropriĂ© de remplir la ligne de cache dans son intĂ©gralitĂ© avant de la remettre au consommateur.
Interaction des threads
[modifier | modifier le code]Si deux threads utilisent chacun leur propre variable, mais si ces variables sont amenĂ©es Ă partager une mĂȘme ligne de cache, alors son appartenance va tour Ă tour passer d'un thread Ă l'autre. Ce problĂšme peut gĂ©nĂ©ralement ĂȘtre rĂ©solu en forçant les variables Ă ne pas rĂ©sider sur la mĂȘme ligne de cache. ThreadSpotter identifie ce phĂ©nomĂšne comme cas de :
Effets du partage de cache
[modifier | modifier le code]Pour les CPU disposant de plusieurs niveaux de caches, leur topologie est parfois asymĂ©trique dans le sens oĂč le coĂ»t de communication entre deux caches de mĂȘme niveau n'est pas uniforme.
Liens externes
[modifier | modifier le code]- (fr) ThreadSpotter, sur le site de Rogue Wave Software (archive du )
