1 | \section*{Introduction} |
---|
2 | Ce document présente l'interface entre un processeur HighPerf et ses caches non bloquant. |
---|
3 | |
---|
4 | Cette interface est décomposée en deux sous interfaces. Ceci permet de réaliser des échanges asynchrone : |
---|
5 | \begin{itemize} |
---|
6 | \item Une interface pour les requêtes allant du processeur vers la hiérarchie mémoire. |
---|
7 | \item Une seconde permettant de remonter les réponses (lectures) ainsi que les évènements vers le processeur. |
---|
8 | \end{itemize} |
---|
9 | |
---|
10 | \section{Interface : Processeur - ICache} |
---|
11 | |
---|
12 | \begin{center} |
---|
13 | \begin{tabular}{l|ll} |
---|
14 | Nom & Direction & Type \\ |
---|
15 | \hline |
---|
16 | REQ\_VAL & CPU to CACHE & {\it 1} bit\\ |
---|
17 | REQ\_ACK & CACHE to CPU & {\it 1} bit\\ |
---|
18 | REQ\_TRDID & CPU to CACHE & {\it SIZE\_TRDID} bits\\ |
---|
19 | REQ\_PKTID & CPU to CACHE & {\it SIZE\_PKTID} bits\\ |
---|
20 | REQ\_ADDR & CPU to CACHE & {\it SIZE\_ADDR} bits\\ |
---|
21 | REQ\_TYPE & CPU to CACHE & {\it 2} bits\\ |
---|
22 | REQ\_UNC & CPU to CACHE & {\it 1} bit\\ |
---|
23 | \hline |
---|
24 | RSP\_VAL & CACHE to CPU & {\it 1} bit\\ |
---|
25 | RSP\_ACK & CPU to CACHE & {\it 1} bit\\ |
---|
26 | RSP\_TRDID & CPU to CACHE & {\it SIZE\_TRDID} bits\\ |
---|
27 | RSP\_PKTID & CPU to CACHE & {\it SIZE\_PKTID} bits\\ |
---|
28 | RSP\_INS & CACHE to CPU & {\it NB\_INS * SIZE\_INS} bits\\ |
---|
29 | RSP\_ERR & CACHE to CPU & {\it 1} bit\\ |
---|
30 | \end{tabular} |
---|
31 | \end{center} |
---|
32 | |
---|
33 | \subsection{Champ : XXX\_VAL et XXX\_ACK} |
---|
34 | |
---|
35 | \begin{description} |
---|
36 | \item [XXX\_VAL :] Indique si l'entité maîtresse de la sous interface désire initier une requête |
---|
37 | \item [XXX\_ACK :] Indique si l'entité esclave de la sous interface peut accepter une requête. |
---|
38 | \end{description} |
---|
39 | |
---|
40 | La requête est effective quand les signaux XXX\_VAL et XXX\_ACK valent tous les deux 1 à la fin d'un cycle. |
---|
41 | |
---|
42 | \subsection{Champ : REQ\_UNC} |
---|
43 | |
---|
44 | Ce signal indique si la requête fait appel au fonctionnalité offerte par les caches. |
---|
45 | Si le signal vaut 1, alors la requête doit adressé directement le contenu de la mémoire. Les éventuelles données rapportés ne doivent pas être stockés dans le cache. |
---|
46 | |
---|
47 | \subsection{Champ : REQ\_ADDR et RSP\_INS} |
---|
48 | |
---|
49 | \begin{description} |
---|
50 | \item [REQ\_ADDR :] Adresse de l'accès mémoire\\ |
---|
51 | {\it Remarque : } Pour le cache d'instruction, l'adresse est alignés par rapport au nombre d'instruction contenus dans un paquet. |
---|
52 | \item [RSP\_INS :] (Paquet d') Instruction(s) contenu à l'adresse donnée par REQ\_ADDR |
---|
53 | \end{description} |
---|
54 | |
---|
55 | \subsection{Champ : XXX\_TRDID et XXX\_PKTID} |
---|
56 | |
---|
57 | Le cache non bloquant peut être connecté à un processeur à lancement spéculatif et multi contexte. Pour cela nous avons besoin de 2 champs d'identification : |
---|
58 | \begin{description} |
---|
59 | \item [XXX\_TRDID :] Identifiant permettant de spécifier le contexte propriétaire de la requête. L'identifiant peut par exemple être le numéro du contexte. |
---|
60 | \item [XXX\_PKTID :] Un même contexte peut réaliser plusieurs requêtes, ce champ est utilisé pour les identifier. |
---|
61 | \end{description} |
---|
62 | |
---|
63 | Le processeur doit garantir que le couple (REQ\_TRDID,REQ\_PKTID) représente une requête unique. |
---|
64 | |
---|
65 | \subsection{Champ : REQ\_TYPE} |
---|
66 | |
---|
67 | Voici les différents types de transaction demandé au cache instructions : |
---|
68 | |
---|
69 | \begin{center} |
---|
70 | \begin{tabular}{|cc||l|} |
---|
71 | \hline |
---|
72 | b1& b0& Description \\ |
---|
73 | \hline |
---|
74 | \hline |
---|
75 | 0 & 0 & Read \\ |
---|
76 | 0 & 1 & Lock \\ |
---|
77 | 1 & 0 & Invalidate \\ |
---|
78 | 1 & 1 & Prefetch \\ |
---|
79 | \hline |
---|
80 | \end{tabular} |
---|
81 | \end{center} |
---|
82 | \begin{description} |
---|
83 | \item[Read :] Demande de lecture d'un (Paquet d') Instruction(s). Une fois prête, elle (il) sera retourné(e) au processeur par l'intermédiaire de l'interface de réponse. |
---|
84 | \item[Lock :] La ligne de cache contenant l'adresse fournit ne doit plus être évincé par le cache.\\ |
---|
85 | {\it Remarque :} La présence de ce type de requêtes n'oblige pas le cache à implémenter cette fonctionnalité. De plus le cache ne doit pas permettre le verrouillage de toute les lignes d'un même ensemble. Pour cela au cache de déverrouiller un ensemble. |
---|
86 | \item[Prefetch :] Demande de lecture d'un (Paquet d') Instruction(s). Aucune réponse ne devra être envoyée au processeur.\\ |
---|
87 | {\it Remarque :} La présence de ce type de requêtes n'oblige pas le cache à implémenter cette fonctionnalité. |
---|
88 | \item[Invalidate :] Invalide la ligne de cache contenant l'adresse fournit.\\ |
---|
89 | {\it Remarque :} L'invalidation va implicitement déverrouiller la ligne de cache. |
---|
90 | \end{description} |
---|
91 | |
---|
92 | \subsection{Champ : RSP\_ERR} |
---|
93 | |
---|
94 | Si RSP\_ERR est non nul, alors il y a eu une erreur avec une requête précédente. Le codage actuelle est le suivant : |
---|
95 | |
---|
96 | \begin{center} |
---|
97 | \begin{tabular}{|c||l|} |
---|
98 | \hline |
---|
99 | b0 & Description \\ |
---|
100 | \hline |
---|
101 | \hline |
---|
102 | 0 & NOERR \\ |
---|
103 | 1 & BERR \\ |
---|
104 | \hline |
---|
105 | \end{tabular} |
---|
106 | \end{center} |
---|
107 | \begin{description} |
---|
108 | \item[NOERR : ] indique qu'il n'y a aucune erreur lors de la requête. |
---|
109 | \item[BERR : ] indique qu'il y a eu une erreur de transmission lors d'un accès mémoire.\\ |
---|
110 | {\it Remarque : } Seul les requêtes de type {\it Read} peuvent générer cette erreur. |
---|
111 | \end{description} |
---|
112 | |
---|
113 | \section{Interface : Processeur - DCache} |
---|
114 | |
---|
115 | \begin{center} |
---|
116 | \begin{tabular}{l|ll} |
---|
117 | Nom & Direction & Type \\ |
---|
118 | \hline |
---|
119 | REQ\_VAL & CPU to CACHE & {\it 1} bit\\ |
---|
120 | REQ\_ACK & CACHE to CPU & {\it 1} bit\\ |
---|
121 | REQ\_TRDID & CPU to CACHE & {\it SIZE\_TRDID} bits\\ |
---|
122 | REQ\_PKTID & CPU to CACHE & {\it SIZE\_PKTID} bits\\ |
---|
123 | REQ\_ADDR & CPU to CACHE & {\it SIZE\_ADDR} bits\\ |
---|
124 | REQ\_WDATA & CPU to CACHE & {\it SIZE\_DATA} bits\\ |
---|
125 | REQ\_TYPE & CPU to CACHE & {\it 4} bits\\ |
---|
126 | REQ\_UNC & CPU to CACHE & {\it 1} bit\\ |
---|
127 | \hline |
---|
128 | RSP\_VAL & CACHE to CPU & {\it 1} bit\\ |
---|
129 | RSP\_ACK & CPU to CACHE & {\it 1} bit\\ |
---|
130 | RSP\_TRDID & CPU to CACHE & {\it SIZE\_TRDID} bits\\ |
---|
131 | RSP\_PKTID & CPU to CACHE & {\it SIZE\_PKTID} bits\\ |
---|
132 | RSP\_RDATA & CACHE to CPU & {\it SIZE\_DATA} bits\\ |
---|
133 | RSP\_ERR & CACHE to CPU & {\it 1} bit\\ |
---|
134 | \end{tabular} |
---|
135 | \end{center} |
---|
136 | |
---|
137 | Les champs {\it XXX\_VAL }, {\it XXX\_ACK }, {\it XXX\_TRDID}, {\it XXX\_PKTID}, {\it REQ\_ADDR }, {\it REQ\_UNC } ont les mêmes spécificités que pour le cache d'instruction. |
---|
138 | |
---|
139 | \subsection{Champ : REQ\_WDATA et RSP\_RDATA} |
---|
140 | |
---|
141 | \begin{description} |
---|
142 | \item [REQ\_WDATA :] Donnée à écrire à l'adresse donnée par REQ\_ADDR.\\ |
---|
143 | {\it Remarque :} Le processeur doit aligner la donnée à écrire dans les octets les moins significatifs. Par exemple pour une écriture de 16 bits, la donnée est contenue dans les 2 octets les moins significatifs. |
---|
144 | \item [RSP\_RDATA :] Donnée lut à l'adresse donnée par REQ\_ADDR.\\ |
---|
145 | \end{description} |
---|
146 | |
---|
147 | |
---|
148 | \subsection{Champ : REQ\_TYPE} |
---|
149 | \begin{center} |
---|
150 | \begin{tabular}{|cccc||l|} |
---|
151 | \hline |
---|
152 | b3 & b2 & b1 & b0& Description \\ |
---|
153 | \hline |
---|
154 | \hline |
---|
155 | 0 & 0 & 0 & 0 & Read \\ |
---|
156 | 0 & 0 & 0 & 1 & Lock \\ |
---|
157 | 0 & 0 & 1 & 0 & Invalidate \\ |
---|
158 | 0 & 0 & 1 & 1 & Prefetch \\ |
---|
159 | 0 & 1 & 0 & 0 & {\it non utilisé} \\ |
---|
160 | 0 & 1 & 0 & 1 & {\it non utilisé} \\ |
---|
161 | 0 & 1 & 1 & 0 & Flush \\ |
---|
162 | 0 & 1 & 1 & 1 & {\it non utilisé} \\ |
---|
163 | \hline |
---|
164 | 1 & 0 & 0 & 0 & Write 8 bits \\ |
---|
165 | 1 & 0 & 0 & 1 & Write 16 bits \\ |
---|
166 | 1 & 0 & 1 & 0 & Write 32 bits \\ |
---|
167 | 1 & 0 & 1 & 1 & Write 64 bits \\ |
---|
168 | 1 & 1 & 0 & 0 & {\it Réservé} \\ |
---|
169 | 1 & 1 & 0 & 1 & {\it Réservé} \\ |
---|
170 | 1 & 1 & 1 & 0 & {\it Réservé} \\ |
---|
171 | 1 & 1 & 1 & 1 & {\it Réservé} \\ |
---|
172 | \hline |
---|
173 | \end{tabular} |
---|
174 | \end{center} |
---|
175 | |
---|
176 | \begin{description} |
---|
177 | \item[Read :] Demande de lecture d'une donnée. Une fois prête, elle (il) sera retourné(e) au processeur par l'intermédiaire de l'interface de réponse. |
---|
178 | \item[Lock :] La ligne de cache contenant l'adresse fournit ne doit plus être évincé par le cache.\\ |
---|
179 | {\it Remarque :} La présence de ce type de requêtes n'oblige pas le cache à implémenter cette fonctionnalité. De plus le cache ne doit pas permettre le verrouillage de toute les lignes d'un même ensemble. Pour cela au cache de déverrouiller un ensemble. |
---|
180 | \item[Prefetch :] Demande de lecture d'une donnée. Aucune réponse ne devra être envoyée au processeur.\\ |
---|
181 | {\it Remarque :} La présence de ce type de requêtes n'oblige pas le cache à implémenter cette fonctionnalité. |
---|
182 | \item[Invalidate :] Invalide la ligne de cache contenant l'adresse fournit.\\ |
---|
183 | {\it Remarque :} L'invalidation va implicitement déverrouiller la ligne de cache. |
---|
184 | \item[Flush :] Invalide la ligne de cache contenant l'adresse fournit, et propage les éventuelles écritures jusqu'à la mémoire\\ |
---|
185 | {\it Remarque :} Le flush va implicitement déverrouiller la ligne de cache. |
---|
186 | \item[Write :] Demande de l'écriture d'une donnée. Une fois effectué, un acquittement sera retourné au processeur par l'intermédiaire de l'interface de réponse. |
---|
187 | \end{description} |
---|
188 | |
---|
189 | \subsection{Champ : RSP\_ERR} |
---|
190 | |
---|
191 | Si RSP\_ERR est non nul, alors il y a eu une erreur avec une requête précédente. Le codage actuelle est le suivant : |
---|
192 | |
---|
193 | \begin{center} |
---|
194 | \begin{tabular}{|c||l|} |
---|
195 | \hline |
---|
196 | b0 & Description \\ |
---|
197 | \hline |
---|
198 | \hline |
---|
199 | 0 & NOERR \\ |
---|
200 | 1 & BERR \\ |
---|
201 | \hline |
---|
202 | \end{tabular} |
---|
203 | \end{center} |
---|
204 | \begin{description} |
---|
205 | \item[NOERR : ] indique qu'il n'y a aucune erreur lors de la requête. |
---|
206 | \item[BERR : ] indique qu'il y a eu une erreur de transmission lors d'un accès mémoire. |
---|
207 | {\it Remarque : } Seul les requêtes de type {\it Read}, {\it Write 8 bits}, {\it Write 16 bits}, {\it Write 32 bits}, {\it Write 64 bits} peuvent générées cette erreur. |
---|
208 | \end{description} |
---|
209 | |
---|
210 | \section{Protocole de communication} |
---|
211 | |
---|
212 | Il y a un échange sur une des sous interface si VAL AND ACK = 1. Toute requête entraîne une réponse. Les réponses n'arrive pas dans l'ordre émisent sur l'interface des réponses. |
---|
213 | |
---|
214 | Sur le port des requêtes, si le cache est occupé, le processeur peut changer au cycle suivant sa requête (typiquement donne la main à un autre thread). Par contre sur le port des réponses, tant que le processeur est occupé, le cache maintient sa réponse. (Ceci permet d'éviter les questions : quand réémettre la réponse? et quel évènement déclenche la remise de la réponse?) |
---|
215 | |
---|
216 | \section{Paramètres des interfaces du cache} |
---|
217 | \begin{center} |
---|
218 | \begin{tabular}{ll} |
---|
219 | %{\it NB\_PORT } & Nombre d'occurence des interfaces \\ |
---|
220 | {\it SIZE\_DATA } & Nombre de bits composant une donnée \\ |
---|
221 | {\it NB\_INS } & Nombre d'instruction composant un paquet d'instructions \\ |
---|
222 | {\it SIZE\_INS } & Nombre de bits composant une instruction \\ |
---|
223 | {\it SIZE\_ADDR } & Nombre de bits composant une adresse \\ |
---|
224 | {\it SIZE\_TRDID } & Nombre de bits composant l'identifiant du propriétaire\\ |
---|
225 | {\it SIZE\_PKTID } & Nombre de bits composant l'identifiant de transaction \\ |
---|
226 | \end{tabular} |
---|
227 | \end{center} |
---|