14

Programme pour compter les cycles du cortex A8: v0.7

mai
3 Comments » |  Posted by Etienne SOBOLE |  Category:Ccc, Projets

La dernière version du compteur de cycle est en ligne.

J’ai maintenant pour objectif clair d’intégrer le compteur de cycles dans un éditeur assembleur (ebola), j’ai donc grandement changé le rendu du résultat.
Le rendu par défaut (et d’ailleurs le seul à présent) est le rendu de type “source”.
C’est à dire que le compteur de cycles n’ajoute aucune ligne, ni n’en supprime d’ailleurs.

Format de sortie

Toute l’information est contenue dans les 21 caractères qui précèdent l’instruction.
Dans cette chaîne ce trouve:

  • l’unité de calcul. (a pour ARM, n pour NEON et v pour VPf)
  • le cycle d’exécution de l’instruction (limite à 4 caractères ce qui devrait être suffisant)
  • le pipeline
  • le nombre de cycle que prend l’instruction
  • Si une bulle dans le pipeline existe et n’est pas due à un registre (par exemple l’attente du pipeline 0 pour effectuer une multiplication)
  • le dernier registre engendrant une ou plusieurs bulles dans le pipeline ainsi que le nombre de bulles engendrées par l’attente de ce registre. Cela revient a indiquer le nombre d’instruction que l’on pourrait placer avant cette instruction sans modifier les temps du programme !

Par exemple:

a.6-0    2c p0 r4:3  mla r4, r6, r7, r4

L’instruction MLA va s’exécuter dans l’ARM au cycle 6 et dans le pipeline 0.
L’instruction prend 2 cycles.
Elle nécessite d’attendre le pipeline 0 (p0 est mentionné uniquement parce que l’instruction à du attendre. Si elle n’avait pas eu besoin d’attendre, p0 ne sera pas mentionné)
Enfin l’instruction n’a pas pu s’exécuter plus tôt car r4 n’était pas disponible. Ce registre a généré 3 bulles dans l’un ou l’autre des pipelines.

Le mode détaillé n’existant plus, il n’est plus possible d’avoir une vision aussi clair des cycles d’attente. Dans une future version je remettrai dans un popup les informations affichées initialement dans ce mode.

Les nouvelles fonctionnalités

Cette nouvelle version du compteur de cycles exécute les boucles.
C’est à dire que lorsque le programme rencontre une instruction de branchement dont l’adresse est antérieure à l’instruction de branchement, il effectue réellement le branchement.

A quoi ça sert et comment ça marche ?
Lorsqu’un programme entre dans une boucle, l’état des pipelines peut être, durant les premières itérations, différent à chaque entrée dans la boucle.
Cet état fini par converger vers un état fixe (ou une séquence d’états). Les premières itérations ne sont donc pas représentatives du fonctionnement réel de la boucle.
Le nouveau compteur de cycles exécute la boucle jusqu’à trouver un état convergent (c’est à dire se répétant plusieurs fois).

Pour une boucle ARM, la convergence est assez rapide. Pour une boucle contenant des instructions NEON cela peut prendre plus de temps.

Au final, le résultat est meilleur puisqu’il ignore les premières itérations de la boucle. Il se base sur une itération plus représentative du temps réel de fonctionnement.

De plus chaque fois que le compteur de cycle détecte une boucle il remet le numéro de cycle d’exécution à 0. Cela permet de connaitre facilement le temps pris par une itération en allant lire le cycle auquel s’exécute le branchement. Evidemment, le compteur de cycle n’est pas capable de savoir combien de fois la boucle devrait être réellement exécuter. Il exécute donc la boucle jusqu’à atteindre la convergence. Concrètement, cela veut dire que si vous avez une boucle du type

for(i=0 ; i<4 ;i++)
{
}

Il est possible que le compteur de cycles exécute la boucle un nombre de fois bien plus élevé que les 4 itérations prévue.
Enfin les cycles d’exécution des instructions NEON peuvent surprendre. N’oubliez pas qu’a cause la file d’instruction NEON, il est probable que les instructions d’une itération de la boucles s’exécutent en fait réellement durant les itérations suivantes.

Les évolutions

  • Quelques instructions ont été ajoutées. (A priori il n’en manque plus beaucoup)
  • Les instructions d’accès mémoire NEON peuvent a présent être parallélisées avec une instruction de calcul.
  • Les expressions régulières sont à présent plus restrictives. On ne peut plus utiliser le registre r25 (qui n’existe pas) par exemple.
  • Certains contrôles sur la validité des valeurs immédiates ont été mis en place.
  • Ajout de la gestion des cycles de writeback pour les instructions nécessitant cette information.
  • Une première version de gestion des interactions entre les différentes unités de calcul a été ajoutée (VMOV r0, d0[1] par exemple).
  • J’ai fusionné les files d’attente NEON et VPf. J’ignore si c’était une bonne idée, mais ça a simplifié la gestion des interactions sans modifier le résultat du comptage des cycles
  • Enfin la gestion plus fine des interactions entre NEON et l’ARM a engendré des erreurs concernant les instructions VPf. Ce problème sera corrigé dans la prochaine version.
 | Tags:

3 Responses to “Programme pour compter les cycles du cortex A8: v0.7”

  1. ericb dit :

    Bonjour,

    Fervent -et régulier- lecteur de ce blog, je découvre l’architecture ARM car je fais le port d’un gros logiciel (pour lequel je souhaiterais faire des optimisations en assembleur).

    Je tiens à commencer par dire un gros merci pour toutes ces informations précieuses – en plus en français ! – qu’on trouve ici.

    D’un côté plus pratique, serait-il possible de discuter sur IRC des développements faits ici ? J’ai tellement de questions (certaines sont probablement stupides), que je pense que ce serait plus simple. (on peut me trouver sur #educooo, sur irc.freenode.net)

    Bravo, et bonne continuation !

  2. [...] This post is a translation of « Programme pour compter les cycles du cortex A8: v0.7. » [...]

  3. Etienne SOBOLE dit :

    Merci c’est sympa.
    je passerai te voir :)

Répondre

Human control : 4 + 1 =