Profileur mémoire

Si la solution de profilage, développée précédemment pour notre mécanisme de contrôle dans la section 5.3.3, était suffisante pour détecter les phases applicatives générées par l’exé-cution de blocs de code, elle n’est pas assez précise pour évaluer exactement la consommation mémoire à la granularité d’une instruction. Nous avons donc effectué une évaluation des deux alternatives dont nous disposions pour tracer avec plus de précision les profils de consomma-tion mémoire de nos applicatifs.

La première reposait sur le développement d’un modèle précis de notre plate-forme ma-térielle comportant notamment le système mémoire et processeur pour pouvoir mesurer, par simulation, la consommation mémoire générée par la pile logicielle. La deuxième piste, ex-périmentale, consistait à étendre le profileur, que nous avons développé précédemment dans notre solution de contrôle sous la forme d’un module noyau, afin d’utiliser les compteurs de performances de notre matériel pour, par de multiples expériences, mesurer la consommation mémoire générée par la pile logicielle.

Les avantages de la première solution résident dans la possibilité de mettre en œuvre un profilage à grain fin permettant ainsi de caractériser le trafic mémoire généré par chaque ins-truction exécutée. En contrepartie, cette solution impliquait la création d’un modèle précis de la plate-forme matérielle ce qui est, par nature, complexe. Sa création, en outre, nécessite la présence de spécifications du matériel plus détaillées que celles fournies par les fondeurs pour valider la représentativité du modèle. La deuxième approche, que nous avons choisie, ne pos-sède pas ces inconvénients mais repose sur la confiance que l’on peut accorder aux compteurs du matériel.

6.1.1.1 Choix de conception

Un profil mémoire applicatif idéal devrait contenir une bijection entre chaque instruction de l’application exécutée sur le processeur et la consommation mémoire générée par ladite instruction. La mise en œuvre d’une telle approche, dans une démarche expérimentale, ne peut être réalisée que par une implémentation matérielle. Il s’agit, en effet, de taguer les requêtes mémoire générées par chaque instruction exécutée qui se propagent à travers la hiérarchie des caches en générant de nouvelles requêtes (lignes de caches sales évincées, . . . ), jusqu’au contrôleur MMDC chargé d’enregistrer le profil ainsi obtenu. Cette fonctionnalité n’étant pas présente sur notre plate-forme, nous avons donc choisi d’utiliser une approche logicielle par échantillonnage pour mesurer, à intervalles réguliers, la consommation mémoire générée par la plate-forme logicielle.

Dans une telle approche, la période d’échantillonnage utilisée par le profileur revêt une im-portance capitale. En effet, chaque échantillon mesuré représente une moyenne de la consom-mation mémoire effectuée entre deux mesures. Le choix d’une période d’échantillonnage trop grande peut donc engendrer un effet de lissage sur le profil mémoire occasionnant une sup-pression ou une diminution des pics de consommation mémoire. La capacité à mettre en œuvre un intervalle d’échantillonnage suffisamment petit pour obtenir une mesure précise est donc essentielle.

La solution usuelle pour effectuer un échantillonnage réside dans l’utilisation de tempori-sateurs tel que proposé par l’interface de programmationhrtimers du noyau Linux que nous avons utilisée dans la partie 5.3.3 du chapitre précédent. Cependant, Peter et al. [103], ont démontré que des temporisateurs réglés avec des intervalles de temporisation trop petit, n’ar-rivent pas à respecter le cadencement imposé. Afin de pouvoir effectuer un profilage, avec une résolution descendant jusqu’à 1 µs, nous avons donc choisi d’utiliser une technique d’échan-tillonnage reposant sur une boucle d’attente active exécutée sur un cœur dédié.

Nous avons mis en place un processus de profilage en plusieurs étapes :

1. Initialisation

Dans la première étape d’initialisation, effectuée avant le démarrage de l’application, le module alloue en mémoire vive un tampon de la taille ad hoc destiné à recueillir les va-leurs lues auprès des compteurs matériels. Un thread noyau est alors créé et verrouillé sur un cœur libre de toute application avec une politique d’ordonnancement FIFO et une priorité maximale. Il va, dans sa routine d’exécution, effectuer les étapes de configuration et d’initialisation des compteurs de mesure du trafic mémoire présents au sein du contrô-leur MMDC et du compteur de cycles du processeur, sur lequel le thread est ordonnancé pour, ensuite, se bloquer en attente sur une barrière de synchronisation.

2. Exécution

Lorsque l’application commence son exécution, le thread de profilage est débloqué de sa barrière et démarre alors les compteurs matériels. Il collecte ensuite de manière cyclique les différentes valeurs auprès des multiples compteurs activés, chaque valeur mesurée étant regroupée au sein d’un unique échantillon contenant le nombre d’octets lus, le nombre d’octets écrits et la valeur du compteur de cycles du processeur. Après chaque

opération de collecte, le thread effectue un appel à la fonction ndelay(unsigned long nsecs)du noyau Linux qui effectue une attente active durant nsecs nanosecondes. En paramétrant la valeur passée à la fonction ndelay nous pouvons faire varier le cadence-ment de l’échantillonnage. Chaque échantillon collecté est sauvegardé en mémoire vive dans le tampon préalablement alloué.

3. Terminaison

Une fois que l’application profilée a terminé son exécution, les différents compteurs ma-tériels sont stoppés et les multiples échantillons collectés en mémoire vive sont sauvegar-dés dans une mémoire de stockage de masse. La bande passante mémoire des applications est calculée hors ligne en utilisant, pour chaque échantillon collecté, le nombre d’octets lus et écrits et la durée d’échantillonnage. La boucle d’attente active utilisée dans notre approche produisant de petites variations temporelles entre chaque échantillon, nous uti-lisons la valeur du compteur de cycles présent dans chaque échantillon pour effectuer un réajustement temporel, le processeur étant cadencé à 1 GHz, un cycle du CPU s’exécute en une nanoseconde.

Pour éviter que le profileur n’interfère avec les applications, nous avons appliqué les disposi-tions déjà mises en œuvre dans la section 4.3.2. Les applicadisposi-tions profilées ont été verrouillées sur un seul cœur (Le cœur 0), le profileur étant verrouillé sur un autre cœur (Le cœur 1), les cœurs restants étant désactivés. Afin d’éviter toutes préemptions intempestives, les applications ob-servées et le thread de profilage sont ordonnancés en utilisant la politique SCHED_FIFO avec la plus forte priorité. Nous avons également désactivé le dispositif dit de Real Time throttling qui redonne le contrôle au système d’exploitation si une tâche est ordonnancée pendant une durée trop longue. Enfin, nous avons réduit les interférences mémoire entre les applications profilées et le profileur en partitionnant le cache L2 entre les différents cœurs.

Les avantages de cette approche résident dans la possibilité d’utiliser un intervalle de pro-filage le plus faible possible. En contrepartie, il est nécessaire de dédier un cœur au profileur ce qui, dans notre cas d’utilisation, n’est pas problématique.

6.1.1.2 Étude d’impact

Le choix de l’intervalle d’échantillonnage, utilisé par le profileur pour effectuer les me-sures, peut avoir un impact significatif sur le résultat et la précision du profilage. L’utilisation d’un long intervalle a pour effet de lisser la consommation mémoire, les valeurs profilées re-présentant une moyenne sur la période d’échantillonnage, ce qui entraîne une réduction de l’amplitude des pics de consommation mémoire dont la durée est plus courte que celle de l’in-tervalle. L’utilisation d’un intervalle d’échantillonnage plus court permet d’obtenir des infor-mations plus précises concernant les pics de consommation mais peut également provoquer une distorsion du profil mesuré. En effet, la mesure de la mémoire est effectuée globalement et prend en compte l’ensemble des consommations effectuées par les composants matériels de la plate-forme. Le profileur utilisant de la mémoire pour enregistrer les valeurs lues à chaque échantillon, est donc à l’origine d’une partie du trafic mesuré. De plus, ce trafic supplémentaire peut potentiellement retarder les accès effectués par l’application profilée et ainsi, par effet de bord, accroître son temps d’exécution.

Nous avons donc étudié l’impact de la consommation mémoire générée par le profileur sur les applications profilées. A cet effet, nous avons développé une application à faible empreinte mémoire qui incrémente un compteur allant de zéro à une borne maximale. En faisant varier la borne supérieure de notre application, nous pouvons contrôler le temps d’exécution du pro-gramme. La consommation mémoire générée par une telle application est faible et se concentre principalement au début de l’exécution lors du chargement du code dans les caches de niveaux un et deux, le trafic mémoire généré en continu étant inexistant. Le profilage de cette appli-cation nous permet donc d’isoler la bande passante mémoire générée par le profileur de celle applicative.

La figure 6.1 présente la bande passante obtenue lors du profilage de notre application à faible empreinte mémoire, avec des durées d’exécutions applicatives variant de 1 ms à 50 ms, soit une variation correspondant au temps d’exécution de nos applications temps réel de tests, et avec des temps d’échantillonnage allant de 50 µs à 1 µs ce qui permet, en émettant l’hypothèse optimiste que le processeur est capable d’exécuter une instruction par cycle, de capturer le trafic mémoire toutes 1000 instructions exécutées.

50 10 1

Intervalles d échantillonnage (us) 0 2 4 6 8 10 12 Bande passante (MB/s) Durée de la tâche : 1 ms 10 ms 20 ms 30 ms 40 ms 50 ms

Figure 6.1 – Bande passante mémoire générée par le profileur

Nous observons, un comportement mémoire quasiment identique entre les applications pro-filées avec une résolution de 50 µs et celles propro-filées avec une résolution de 10 µs. Les applica-tions dont le temps d’exécution est de 1 ms ont une bande passante qui varie autour des 8 MB/s, avec un important écart type, pour au fur et à mesure que les temps d’exécution des applications augmentent, assister à une diminution de la bande passante mesurée qui décroît aux alentours des 3,5 MB/s, pour un temps d’exécution de 10 ms jusqu’à descendre en dessous de 1 MB/s pour les temps d’exécution les plus grands. Ce comportement peut être expliqué par le coût en bande passante mémoire que représente le chargement de l’application dans les caches. Plus la durée de l’application est longue, plus le coût fixe de chargement de l’application est dilué dans le temps d’exécution qui ne génère aucun trafic mémoire.

L’importante variation des temps d’exécution, pour les applications ayant une durée d’1 ms, s’explique par les perturbations du système d’exploitation décrites ultérieurement dans la sec-tion 6.3, la présence de pics mémoire ayant lieu toutes les 10 ms, une exécusec-tion sur 10 se voit

donc imputer un surcroît de bande passante.

Nous pouvons également remarquer que la comparaison deux à deux des applications, ayant une même durée d’exécution, pour les intervalles d’échantillonnages 50 µs et 10 µs, montre que les bandes passantes mesurées pour l’intervalle d’échantillonnage 10 µs sont légèrement supé-rieures à celles mesurées avec l’intervalle d’échantillonnage de 50 µs reflétant ainsi la consom-mation mémoire supérieure nécessaire à la sauvegarde des échantillons supplémentaires.

Lorsque la fréquence d’échantillonnage de 1 µs est utilisée, l’application d’une durée de 1 ms a un trafic mémoire quasiment égal à celui mesuré pour des fréquences d’échantillonnage plus grande, l’impact du plus grand nombre d’échantillon généré par la fréquence d’échantillonnage plus intensive n’étant pas visible eut égard à la faible durée de l’application.

Quand le temps d’exécution des applications augmente jusqu’à atteindre 20 ms, la bande passante mesurée décroît, le coût de chargement de l’application dans les caches étant amorti par la durée plus grande de l’application. Nous pouvons néanmoins remarquer que la bande passante mesurée pour les applications 10 ms et 20 ms profilées en 1 µs est supérieure à celle mesurée avec un profilage de 10 µs ce qui traduit la consommation mémoire accrue nécessaire à la sauvegarde des échantillons additionnels.

En revanche, le comportement des bandes passantes mesurées pour des temps d’exécution de 30 ms, 40 ms et 50 ms diverge fondamentalement de celui observé pour des résolutions de profilages plus importantes. En effet, l’accroissement de la taille mémoire nécessaire pour sau-vegarder les échantillons surnuméraires entraîne une augmentation de la consommation mé-moire qui prend le dessus sur l’effet de lissage du surcoût de chargement de l’application dans les caches observé précédemment. La bande passante maximale atteinte est alors de 11 MB/s pour une application dont la durée d’exécution est de 50 ms.

Pour finir, nous avons estimé que les perturbations induites par la bande passante de 11 MB/s générée par le profileur restaient en dessous d’un seuil tolérable pour nos travaux. Enfin, nous n’avons pas observés de différences significatives dans les temps d’exécution des applications profilées avec différentes périodes d’échantillonnage.

Dans la section suivante, nous allons réaliser une étude des profils applicatifs tracés à l’aide de notre profileur pour de multiples résolutions d’échantillonnage.