[39] | 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 | |
---|
[41] | 40 | La requête est effective quand les signaux XXX\_VAL et XXX\_ACK valent tous les deux 1 à la fin d'un cycle. |
---|
[39] | 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\\ |
---|
[41] | 133 | RSP\_ERR & CACHE to CPU & {\it 1} bit\\ |
---|
[39] | 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 \\ |
---|
[41] | 159 | 0 & 1 & 0 & 0 & {\it non utilisé} \\ |
---|
[39] | 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. |
---|
[41] | 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. |
---|
[39] | 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} |
---|
[41] | 194 | \begin{tabular}{|c||l|} |
---|
[39] | 195 | \hline |
---|
[41] | 196 | b0 & Description \\ |
---|
[39] | 197 | \hline |
---|
| 198 | \hline |
---|
[41] | 199 | 0 & NOERR \\ |
---|
| 200 | 1 & BERR \\ |
---|
[39] | 201 | \hline |
---|
| 202 | \end{tabular} |
---|
| 203 | \end{center} |
---|
| 204 | \begin{description} |
---|
[41] | 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. |
---|
[39] | 208 | \end{description} |
---|
| 209 | |
---|
| 210 | \section{Protocole de communication} |
---|
| 211 | |
---|
[41] | 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. |
---|
[39] | 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} |
---|