Comment puis-je lire intentionnellement de la mémoire principale vs cache?

Question

Je suis en cours de montage enseigné et nous avons une mission qui est de trouver la différence de temps entre la lecture de la mémoire et la lecture du cache. Nous devons faire cela en créant 2 boucles et les timing. (On lit de la mémoire principale et l'autre du cache). La chose est, je ne sais pas et ne trouve rien qui me dit comment lire soit cache ou mémoire principale = /. Pourriez-vous les gars me aider? Je fais cela en MASM32. Je comprends comment faire des boucles et bien la plupart du langage assembleur mais je ne peux pas faire lire = /

---

Modifier

J'ai une question, je l'ai fait ...

mov ecx, 100 ;loop 100 times
xor eax, eax ;set eax to 0
_label:
mov eax, eax ;according to me this is read memory is that good?
dec ecx ;dec loop
jnz _label ;if still not equal to 0 goes again to _label

... serait-ce ok?

---

Edit 2:

eh bien, je ne l'intention de ne pas forcer et je vous remercie de votre aide, j'ai une autre question, puisque ce sont deux boucles que je dois faire. J'ai besoin de les comparer en quelque sorte, j'ai cherché une instruction de minuterie mais je ne l'ai pas trouvé tout ce que j'ai trouvé que: timeGetTime , GetTickCount et Compteur de performance , mais pour autant que je comprends ces instructions renvoient l'heure du système et non le temps qu'il faut pour la boucle pour terminer. Est-il un moyen de faire ce que je veux? ou je dois penser à une autre façon?

En outre, de lire différents registres dans la deuxième boucle (celle du cache ne pas lire) est-il ok si je donne diverses instructions « mov »? ou suis-je ici totalement hors de base?

Désolé pour toutes ces questions, mais encore une fois merci pour votre aide.

Answer 1

Pour lire à partir du cache. une boucle qui se lit de la même (ou très semblables) adresse de mémoire:

• La première fois que vous avez lu à partir de cette adresse, les valeurs de cette adresse mémoire (et d'autres, l'adresse mémoire à proximité) sera déplacé dans le cache
• suivant moment où vous lisez de cette même adresse, les valeurs sont déjà mises en cache et que vous lisez du cache.

Pour lire la mémoire non mise en cache, une boucle qui se lit de plusieurs, très différentes (à savoir plus espacés que la taille du cache) les adresses mémoire.

---

Pour répondre à votre deuxième question:

• Les choses que vous faites avec ECX et jnz regarder OK (je ne sais pas comment votre minuterie précise / est sensible, mais vous pourriez vouloir boucler plus de 100 fois)

• Le mov eax, eax n'est pas "lire la mémoire" ... il est un non-op, qui se déplace EAX dans eax. Au lieu de cela, je pense que la syntaxe MASM pour la lecture de la mémoire est quelque chose comme mov eax,[esi] ( « lire l'emplacement de la mémoire dont l'adresse est contenue dans esi »)

• En fonction de ce que O / S que vous utilisez, vous devez lire à partir d'une adresse mémoire qui existe réellement et est lisible. Sous Windows, par exemple, une application ne serait pas autorisé à faire mov esi, 0 suivie mov eax, [esi] parce qu'une application ne peut pas lire la mémoire dont l'adresse / emplacement est égal à zéro.

---

Pour répondre à votre troisième question:

  

timeGetTime, GetTickCount et compteur de performance

Votre mention timeGetTime, GetTickCount et compteur de performance implique que vous utilisez sous Windows.

Oui, ce retour l'heure actuelle, à diverses résolutions / exactitudes: par exemple, GetTickCount a une résolution d'environ 50 msec, il ne parvient pas à des événements de temps qui durent moins de 50 msec, est inexact minuter des événements qui durent seulement 50-100 msec. Voilà pourquoi je dis que 100 dans votre ecx est probablement pas assez grand.

La fonction QueryPerformanceCounter est probablement la minuterie la plus précise que vous avez.

Pour utiliser ces minuteries comme une temporisation:

• Obtenez le temps, avant de commencer à boucle
• Obtenez le temps à nouveau, après avoir terminé en boucle
• Soustraire ces deux fois: la différence est l'intervalle de temps

  

est-ce ok si je donne diverses instructions "mov"?

Oui, je pense. Je pense que vous pouvez le faire comme ça (méfiez-vous, je ne suis pas sûr / ne me souviens pas si cela est la bonne syntaxe MASM pour la lecture à partir d'un emplacement mémoire de nom) ...

mov eax,[memory1]
mov eax,[memory2]
mov eax,[memory3]
mov eax,[memory4]
mov eax,[memory5]

... où memory1 par memory5 sont des adresses de variables globales largement espacées dans votre segment de données.

Ou, vous pouvez faire ...

mov eax,[esi]
add esi,edx
mov eax,[esi]
add esi,edx
mov eax,[esi]
add esi,edx
mov eax,[esi]
add esi,edx
mov eax,[esi]

... où esi pointe vers le bas d'une longue partie de la mémoire, et EDX un certain incrément qui est égale à environ un cinquième de la longueur du tronçon.