\section*{Introduction}
Ce document présente l'interface entre un processeur HighPerf et ses caches non bloquant.

Cette interface est décomposée en deux sous interfaces. Ceci permet de réaliser des échanges asynchrone :
\begin{itemize}
\item Une interface pour les requêtes allant du processeur vers la hiérarchie mémoire.
\item Une seconde permettant de remonter les réponses (lectures) ainsi que les évènements vers le processeur.
\end{itemize}

\section{Interface : Processeur - ICache}

\begin{center}
\begin{tabular}{l|ll}
Nom                & Direction    & Type \\
\hline
REQ\_VAL           & CPU to CACHE & {\it 1} bit\\
REQ\_ACK           & CACHE to CPU & {\it 1} bit\\
REQ\_TRDID         & CPU to CACHE & {\it SIZE\_TRDID} bits\\
REQ\_PKTID         & CPU to CACHE & {\it SIZE\_PKTID} bits\\
REQ\_ADDR          & CPU to CACHE & {\it SIZE\_ADDR} bits\\
REQ\_TYPE          & CPU to CACHE & {\it 2} bits\\
REQ\_UNC           & CPU to CACHE & {\it 1} bit\\
\hline
RSP\_VAL           & CACHE to CPU & {\it 1} bit\\
RSP\_ACK           & CPU to CACHE & {\it 1} bit\\
RSP\_TRDID         & CPU to CACHE & {\it SIZE\_TRDID} bits\\
RSP\_PKTID         & CPU to CACHE & {\it SIZE\_PKTID} bits\\
RSP\_INS           & CACHE to CPU & {\it NB\_INS * SIZE\_INS} bits\\
RSP\_ERR           & CACHE to CPU & {\it 1} bit\\
\end{tabular}
\end{center}

\subsection{Champ : XXX\_VAL et XXX\_ACK}

\begin{description}
\item [XXX\_VAL :] Indique si l'entité maîtresse de la sous interface désire initier une requête
\item [XXX\_ACK :] Indique si l'entité esclave   de la sous interface peut accepter  une requête.
\end{description}

La requête est effective quand les signaux XXX\_VAL et XXX\_ACK valent tous les 1 à la fin d'un cycle.

\subsection{Champ : REQ\_UNC}

Ce signal indique si la requête fait appel au fonctionnalité offerte par les caches.
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.

\subsection{Champ : REQ\_ADDR et RSP\_INS}

\begin{description}
\item [REQ\_ADDR :] Adresse de l'accès mémoire\\
{\it Remarque : } Pour le cache d'instruction, l'adresse est alignés par rapport au nombre d'instruction contenus dans un paquet.
\item [RSP\_INS  :] (Paquet d') Instruction(s) contenu à l'adresse donnée par REQ\_ADDR
\end{description}

\subsection{Champ : XXX\_TRDID et XXX\_PKTID}

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 :
\begin{description}
\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.
\item [XXX\_PKTID :] Un même contexte peut réaliser plusieurs requêtes, ce champ est utilisé pour les identifier.
\end{description}

Le processeur doit garantir que le couple (REQ\_TRDID,REQ\_PKTID) représente une requête unique.

\subsection{Champ : REQ\_TYPE}

Voici les différents types de transaction demandé au cache instructions :

\begin{center}
\begin{tabular}{|cc||l|}
  \hline
  b1& b0& Description          \\
  \hline
  \hline
  0 & 0 & Read                 \\
  0 & 1 & Lock                 \\
  1 & 0 & Invalidate           \\
  1 & 1 & Prefetch             \\
  \hline
\end{tabular}
\end{center}
\begin{description}
\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.
\item[Lock       :] La ligne de cache contenant l'adresse fournit ne doit plus être évincé par le cache.\\ 
{\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.
\item[Prefetch   :] Demande de lecture d'un (Paquet d') Instruction(s). Aucune réponse ne devra être envoyée au processeur.\\
{\it Remarque :} La présence de ce type de requêtes n'oblige pas le cache à implémenter cette fonctionnalité.
\item[Invalidate :] Invalide la ligne de cache contenant l'adresse fournit.\\
{\it Remarque :} L'invalidation va implicitement déverrouiller la ligne de cache.
\end{description}

\subsection{Champ : RSP\_ERR}

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 :

\begin{center}
\begin{tabular}{|c||l|}
  \hline
  b0  & Description \\
  \hline
  \hline
  0   & NOERR       \\  
  1   & BERR        \\
  \hline
\end{tabular}
\end{center}
\begin{description}
\item[NOERR      : ] indique qu'il n'y a aucune erreur lors de la requête.
\item[BERR       : ] indique qu'il y a eu une erreur de transmission lors d'un accès mémoire.\\
{\it Remarque : } Seul les requêtes de type {\it Read} peuvent générer cette erreur.
\end{description}

\section{Interface : Processeur - DCache}

\begin{center}
\begin{tabular}{l|ll}
Nom                & Direction & Type \\
\hline
REQ\_VAL           & CPU to CACHE & {\it 1} bit\\
REQ\_ACK           & CACHE to CPU & {\it 1} bit\\
REQ\_TRDID         & CPU to CACHE & {\it SIZE\_TRDID} bits\\
REQ\_PKTID         & CPU to CACHE & {\it SIZE\_PKTID} bits\\
REQ\_ADDR          & CPU to CACHE & {\it SIZE\_ADDR} bits\\
REQ\_WDATA         & CPU to CACHE & {\it SIZE\_DATA} bits\\
REQ\_TYPE          & CPU to CACHE & {\it 4} bits\\
REQ\_UNC           & CPU to CACHE & {\it 1} bit\\
\hline
RSP\_VAL           & CACHE to CPU & {\it 1} bit\\
RSP\_ACK           & CPU to CACHE & {\it 1} bit\\
RSP\_TRDID         & CPU to CACHE & {\it SIZE\_TRDID} bits\\
RSP\_PKTID         & CPU to CACHE & {\it SIZE\_PKTID} bits\\
RSP\_RDATA         & CACHE to CPU & {\it SIZE\_DATA} bits\\
RSP\_ERR           & CACHE to CPU & {\it 2} bits\\
\end{tabular}
\end{center}

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.

\subsection{Champ : REQ\_WDATA et RSP\_RDATA}

\begin{description}
\item [REQ\_WDATA :] Donnée à écrire à l'adresse donnée par REQ\_ADDR.\\
{\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. 
\item [RSP\_RDATA :] Donnée lut      à l'adresse donnée par REQ\_ADDR.\\
\end{description}


\subsection{Champ : REQ\_TYPE}
\begin{center}
\begin{tabular}{|cccc||l|}
  \hline
  b3 & b2 & b1 & b0& Description              \\
  \hline
  \hline
  0 & 0 & 0 & 0 & Read                        \\
  0 & 0 & 0 & 1 & Lock                        \\
  0 & 0 & 1 & 0 & Invalidate                  \\
  0 & 0 & 1 & 1 & Prefetch                    \\
  0 & 1 & 0 & 0 & Write 8  bits ack           \\
  0 & 1 & 0 & 1 & {\it non utilisé}           \\
  0 & 1 & 1 & 0 & Flush                       \\
  0 & 1 & 1 & 1 & {\it non utilisé}           \\
  \hline
  1 & 0 & 0 & 0 & Write 8  bits               \\
  1 & 0 & 0 & 1 & Write 16 bits               \\
  1 & 0 & 1 & 0 & Write 32 bits               \\
  1 & 0 & 1 & 1 & Write 64 bits               \\
  1 & 1 & 0 & 0 & {\it Réservé}               \\
  1 & 1 & 0 & 1 & {\it Réservé}               \\
  1 & 1 & 1 & 0 & {\it Réservé}               \\
  1 & 1 & 1 & 1 & {\it Réservé}               \\
  \hline
\end{tabular}
\end{center}

\begin{description}
\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.
\item[Lock       :] La ligne de cache contenant l'adresse fournit ne doit plus être évincé par le cache.\\ 
{\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.
\item[Prefetch   :] Demande de lecture d'une donnée. Aucune réponse ne devra être envoyée au processeur.\\
{\it Remarque :} La présence de ce type de requêtes n'oblige pas le cache à implémenter cette fonctionnalité.
\item[Invalidate :] Invalide la ligne de cache contenant l'adresse fournit.\\
{\it Remarque :} L'invalidation va implicitement déverrouiller la ligne de cache.
\item[Flush      :] Invalide la ligne de cache contenant l'adresse fournit, et propage les éventuelles écritures jusqu'à la mémoire\\
{\it Remarque :} Le flush va implicitement déverrouiller la ligne de cache.
\item[Write      :] Demande de l'écriture d'une donnée. Aucun acquittement ne sera retourné au processeur.
\item[Write ack  :] 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.
\end{description}

\subsection{Champ : RSP\_ERR}

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 :

\begin{center}
\begin{tabular}{|cc||l|}
  \hline
  b1 & b0 & Description \\
  \hline
  \hline
  0  & 0  & NOERR            \\  
  0  & 1  & BERR\_PRECISE    \\
  1  & 1  & BERR\_UNPRECISE  \\
  \hline
\end{tabular}
\end{center}
\begin{description}
\item[NOERR           : ] indique qu'il n'y a aucune erreur lors de la requête.
\item[BERR\_PRECISE   : ] indique qu'il y a eu une erreur de transmission lors d'un accès mémoire.
{\it Remarque : } Seul les requêtes de type {\it Read}, {\it Write 8 bits ack} peuvent générées cette erreur.
\item[BERR\_UNPRECISE : ] indique qu'il y a eu une erreur de transmission lors d'un accès mémoire.
{\it Remarque : } Seul les requêtes de type {\it Write 8 bits}, {\it Write 16 bits}, {\it Write 32 bits}, {\it Write 64 bits} peuvent générées cette erreur.
\end{description}

Au contraire de l'exception BERR\_PRECISE qui ne peut être provoqué que par des requêtes demandant un acquittement, l'exception BERR\_UNPRECISE est provoqué par des requête qui ne demande pas d'acquittement. Le processeur doit être capable de traiter ce genre d'erreur.

\section{Protocole de communication}

Il y a un échange sur une des sous interface si VAL AND ACK = 1.

Lors d'une requête de lecture, la hiérarchie mémoire envoie la donnée sur le port des réponses de manière asynchrone et de manière non ordonnée (une requête de lecture ancienne peut répondre après une requête de lecture nouvelle. C'est au processeur de gérer le ré-ordonnancement)

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?)

\section{Paramètres des interfaces du cache}
\begin{center}
\begin{tabular}{ll}
%{\it NB\_PORT    } & Nombre d'occurence des interfaces            \\
{\it SIZE\_DATA  } & Nombre de bits composant une donnée          \\
{\it NB\_INS     } & Nombre d'instruction composant un paquet d'instructions     \\
{\it SIZE\_INS   } & Nombre de bits composant une instruction     \\
{\it SIZE\_ADDR  } & Nombre de bits composant une adresse         \\
{\it SIZE\_TRDID } & Nombre de bits composant l'identifiant du propriétaire\\
{\it SIZE\_PKTID } & Nombre de bits composant l'identifiant de transaction   \\
\end{tabular}
\end{center}
