Comment écrire un programme en C pour mesurer la vitesse du cache?

Vous devez trouver une heuristique qui obligea une cache de cache 100% (ou très proche) (espérons-le que vous avez un code OP d'invalidation de cache?) Et 100% de cache frappé. Hourra, cela fonctionne pour 1 niveau de cache. Maintenant, comment faire la même chose pour les niveaux 2 et 3?

En toute gravité, il n'y a probablement pas un moyen de le faire 100% de manière fiable sans matériel spécial et traces connectées à la CPU et à la mémoire, mais voici ce que je ferais:

Écrivez un "bouquet" de trucs à 1 emplacement en mémoire - Assez que vous pouvez être sûr que cela frappe le cache L1 constamment et enregistrez l'heure (qui affecte votre cache, donc méfiez-vous). Vous devriez faire cet ensemble d'écritures sans branches pour essayer de vous débarrasser des incohérences de prédiction des succursales. C'est le meilleur temps. Maintenant, de tous ces temps, écrivez une ligne de cache de données de la ligne de cache à un emplacement au hasard au hasard en RAM à la fin de votre emplacement connu à droite et enregistrez la nouvelle fois. Espérons que cela prend plus de temps. Continuez à faire cela en enregistrant les différents moments et espérons que vous verrez quelques timings qui ont tendance à se regrouper. Chacun de ces groupes "pourrait" montrer des timings pour les horaires d'accès à L2, L3 et à la mémoire. Le problème est qu'il y a tellement d'autres choses qui entrent dans la voie. Le système d'exploitation pourrait vous contacter et bousillez votre cache. Une interruption pourrait venir et traverser votre timing. Il y aura beaucoup de choses qui pourraient lancer les valeurs. Mais, espérons-le, vous obtenez suffisamment de signal dans vos données pour voir si cela fonctionne.

Ce serait probablement plus facile à faire sur un système de type plus simple et intégré dans lequel le système d'exploitation (le cas échéant) ne se mettra pas dans votre chemin.

Jetez un coup d'œil à Cachegrind-Valgrind :

Cachegrind simule la manière dont votre programme interagit avec le cache d'une machine hiérarchie et prédicteur de la branche (éventuellement). Il simule une machine avec des instructions et des caches de données indépendantes de premier niveau (I1 et D1), soutenu par un cache de second niveau unifié (L2). Cela correspond exactement à la Configuration de nombreuses machines modernes.

Voir Tese Belles questions, elles sont en quelque sorte liées:

1. Comment est-ce que je désactive programmatiquement la préfettration du matériel?
2. Comment détecteriez-vous génériquement Ligne de cache associativité du code de mode utilisateur?
3. Comment invalider le cache lors de l'analyse comparative?

Cela nécessite généralement une certaine connaissance de la "géométrie" du cache et d'autres aspects de celui-ci. Il est également utile d'avoir un certain contrôle du système au-delà d'un accès simple utilisateur à celui-ci et des éléments dépendants de la mise en œuvre, tels que la minuterie plus fin que pourraient être fournis via le mécanisme Standard C Clock .

Voici une approche initiale:

• Écrivez une routine qui prend un pointeur à la mémoire, une longueur et un certain nombre de répétitions et lit toute cette mémoire dans une commande consécutive, à plusieurs reprises.
• Écrivez une routine qui prend un pointeur à la mémoire, une longueur et un certain nombre de répétitions et écrit à la totalité de cette mémoire dans une commande consécutive, à plusieurs reprises.
• Les routines ci-dessus peuvent devoir convertir leurs pointeurs en volatile pour empêcher le compilateur d'optimiser les accès à l'extérieur qui n'ont aucun effet.
• allouer une grande quantité de mémoire.
• Appelez chacune des routines ci-dessus, obtenant l'heure actuelle avant et après chaque appel et appelez avec une variété de longueurs pour voir les temps pour différentes longueurs.

  Lorsque vous faites cela, vous verrez généralement des vitesses rapides (nombre d'octets en lecture / écriture par seconde) pour de petites longueurs et des vitesses plus lentes pour des longueurs plus longues. La baisse de la vitesse se produira lorsque les tailles des différents niveaux de cache sont dépassées. Donc, vous êtes assez susceptible de voir la taille du cache L1 et L2 reflété dans les données collectées à l'aide de la technique ci-dessus.

  Voici quelques raisons que l'approche est inadéquate:

  • Il ne contrôle pas les instructions utilisées pour lire ou écrire le cache. Le compilateur C peut générer des instructions de Word et de magasin de chargement, mais de nombreux processeurs modernes ont des instructions pouvant charger et stocker 16 octets à la fois, la lecture et l'écriture peuvent être plus rapides avec ces instructions qu'avec les instructions de mot de quatre octets.
  • Cache se comportera différemment lorsque vous accédez à séquentiellement que si vous y accédez au hasard. La plupart des caches ont une tentative de suivre lorsque des données sont utilisées, de sorte que les données récemment utilisées sont conservées dans le cache, tandis que d'autres données sont distribuées. Les parties d'accès des programmes réels diffèrent généralement des opérations consécutives décrites ci-dessus.
  • En particulier, les écrites consécutives à la mémoire peuvent être capables de remplir une ligne de cache entière, de sorte que rien ne doit être lu depuis la mémoire, alors qu'un modèle d'utilisation du monde réel qui écrit qu'un seul mot à un emplacement particulier peut avoir à être mis en œuvre en lisant la ligne de cache de la mémoire et la fusion dans les octets modifiés.
  • La concurrence d'autres processus de votre système interférera avec ce qui est en cache et avec la mesure.