Temps d'accès à la mémoire CPU

Question

La moyenne des données et le temps d'accès aux instructions de la CPU dépendent-ils de la durée d'exécution d'une instruction? Par exemple, si le taux de ratés est de 0,1, 50% des instructions nécessitent un accès mémoire, L1 un temps d'accès de 3 cycles d'horloge, une pénalité de 20 et des instructions en 1 cycle.

Answer 1

Je suppose que vous parlez d'une architecture CISC où les instructions de calcul peuvent avoir des références de mémoire. Si vous avez une séquence d'ADD qui accèdent à la mémoire, alors les demandes de mémoire viendront plus souvent qu'une séquence du même nombre de DIV, car les DIV prennent plus de temps. Cela n'affectera pas l'heure de l'accès à la mémoire - seule la localité de référence affectera le temps moyen d'accès à la mémoire.

Si vous parlez d'une arche RISC, nous avons des instructions d'accès à la mémoire séparées. Si les instructions de mémoire ont un taux d'erreur de 10%, alors la latence d'accès moyenne sera le temps d'accès L1 (3 cycles pour le succès ou l'échec) plus la pénalité L1 ratée le taux d'échec (0.1 * 20), totalisant un temps d'accès moyen de 5 cycles.

Si la moitié de vos instructions sont des instructions de mémoire, alors cela prendrait en compte les horloges par instruction (CPI), ce qui dépendrait du taux d'échec et des blocages de dépendances. CPI sera également affecté par la mesure dans laquelle le temps d'accès mémoire peut chevaucher le calcul, ce qui serait le cas dans un processeur hors service.

Je ne peux pas répondre à votre question beaucoup mieux parce que vous n'êtes pas très précis. Pour réussir dans une classe d'architecture informatique, vous devrez apprendre à calculer comment calculer les temps d'accès moyens et l'IPC.

Answer 2

Eh bien, je vais aller de l'avant et de répondre à votre question, mais, s'il vous plaît lire mes commentaires ci-dessous pour mettre les choses dans une perspective moderne:

Time = Cycles * (1/Clock_Speed) [ unit check: seconds = clocks * seconds/clocks ] 

Donc, pour obtenir l'heure exacte, vous aurez besoin de connaître la vitesse d'horloge de votre machine, pour l'instant, ma réponse sera en termes de cycles

Avg_mem_access_time_in_cycles = cache_hit_time + miss_rate*miss_penalty 
           = 3 + 0.1*20 
           = 5 cycles 

Rappelez-vous, ici je suppose que votre taux de manque de 0,1 signifie 10% du cache accès manque le cache. Si vous voulez dire 10% des instructions, vous devez réduire de moitié (parce que seulement 50% des instrs sont des ops de mémoire).

Maintenant, si vous voulez que l'IPC moyen (cycles par instr)

CPI = instr% * Avg_mem_access_time + instr% * Avg_instr_access_time 
    = 0.5*5 + 0.5*1 = 3 cycles per instruction 

Enfin, si vous voulez que le temps d'exécution de instr moyenne, vous devez multiplier 3 par l'inverse de la fréquence (vitesse d'horloge) de votre machine.

Commentaires: Comp. Les classes d'arc vous apprennent essentiellement une manière très simplifiée de ce que fait le matériel. Les architectures actuelles sont beaucoup plus complexes et un tel modèle (c'est-à-dire les équations ci-dessus) est très irréaliste. D'une part, le temps d'accès aux différents niveaux de cache peut être variable (en fonction de l'endroit où se trouve physiquement le cache de réponse sur le processeur multi ou plusieurs cœurs); Le temps d'accès à la mémoire (généralement 100s de cycles) est également variable en fonction de la contention des ressources (par exemple, la bande passante) ... etc. Enfin, dans les processeurs modernes, les instructions s'exécutent généralement en parallèle (ILP) en fonction de la largeur du pipeline du processeur. Cela signifie que l'ajout de latences d'exécution d'instr est fondamentalement faux (à moins que votre processeur ne soit un processeur à un seul exemplaire qui exécute seulement un instr à la fois et bloque les autres instructions sur les événements manqués tels que miss miss et br mispredicts ...). Cependant, à des fins éducatives et pour des résultats «moyens», les équations sont correctes.

une chose, si vous avez une hiérarchie de cache multi-niveaux, le miss_penalty de cache de niveau 1 sera le suivant:

L1$ miss penalty = L2 access time + L1_miss_rate*L2_miss_penalty 

Si vous disposez d'un cache L3, vous faites une chose semblable à L2_miss_penalty et ainsi de suite