\documentclass[a4]{article} \usepackage[latin1]{inputenc} \usepackage[T1]{fontenc} \usepackage[francais]{babel} \usepackage{graphicx} \title{SSAM :\\TP1 - Simulateur} \author{Guillaume Libersat} \date{11 mai 2007} \begin{document} \maketitle \section{Le simulateur} \subsection{Général} Le simulateur permet de modéliser des architectures matérielles constituées de composants et connexions. Chaque composant est représenté par au moins une fonction C qui permet d'exprimer le comportement du matériel de manière abstraite. Les connexions sont quant à elles spécifiques au simulateur. Il fournit un ensemble de fonctions permettant de les manipuler en entrée et sortie. Ces éléments sont régulés par une horloge interne virtuelle qui assure une synchronisation et une simulation du comportement matériel. Enfin, le simulateur fournit un ensemble de fonctions permettant la gestion des journaux. \subsection{Créer un simulateur} Afin de créer un simulateur, il faut effectuer ces étapes dans la fonction d'entrée du programme : \begin{enumerate} \item Initialiser le système \item Créer les composants \item Créer les connexions \item Démarrer le simulateur \item Quitter le simulateur Ces étapes doivent être réalisées dans l'ordre ci-dessus. \end{enumerate} \subsubsection{Initilisation} Elle se fait à l'aide de la fonction {\bf ssam\_init(int nombre)}. L'argument correspond au nombre de composants que l'ont pourra créer par la suite. \subsubsection{Les composants} Un composant est représenté par une fonction C. Elle doit avoir comme prototype : \begin{verbatim} void* function(); \end{verbatim} Les composants sont alors créés en utilisant la fonction {\bf ssam\_create\_component(void *f)}. A l'intérieur de ceux-ci, il est possible d'attendre le prochaine cycle à l'aide de la primitive {\bf ssam\_wait()} et {\bf ssam\_wait\_duration(int cycles)}. \subsubsection{Les connexions} Les connexions représentent le seul moyen de communication entre les différents composants. Une connexion sera du type {\em ssam\_cnct\_t}. Pour la créer, on utilisera la fonction {\bf ssam\_create\_connection(char *nom, ssam\_cnct\_type\_e type)}. Le premier argument est le nom de la connexion tandis que le second est son type. Ce dernier doit être parmis les suivants : \begin{itemize} \item {\em SSAM\_BOOL\_T}, pour les booléens \item {\em SSAM\_UINT\_T}, pour les entiers \item {\em SSAM\_DOUBLE\_T}, pour les doubles \end{itemize} Afin de lire et écrire dans ces connexions, les primitives suivantes sont fournies : \begin{itemize} \item {\bf ssam\_read(struct ssam\_cnct\_s *cnct, void *pval)}\\ La valeur contenue dans la connexion sera inscrite dans l'adresse mémoire pointée par {\em pval}. \item {\bf ssam\_write(struct ssam\_cnct\_s *cnct, void *pval)}\\ La valeur contenu dans {\em pval} sera inscrite dans le canal {\em cnct}. Attention, il faut attendre un cycle avant que la valeur soit effective. \end{itemize} \subsubsection{Démarrage} Le démarrage du simulateur est enfin assuré par la fonction {\bf ssam\_start(int duree, char *trace)}. Le premier arguement {\em duree} détermine le nombre de cycles de fonctionnement du simulateur. Le second, {\em trace}, est le chemin du fichier dans lequel la trace doit être inscrite. \subsubsection{Quitter le simulateur} Afin de quitter proprement le simulateur, il faut appeler la fonction {\bf ssam\_exit()}. Cette fonction retourne un code d'erreur s'il y a lieu. \subsection{Implantation} \subsubsection{Les composants} Chaque composant créé est lancé dans un thread POSIX. Contrairement à ce qui est écrit dans le sujet, il est nécessaire d'indiquer le nombre de composants qu'il sera possible d'utiliser. La signature de la fonction {\bf ssam\_init()} a donc été changée en {\bf ssam\_init(int nb\_composants)}. \subsubsection{Thread de trace} Le thread de trace est le thread principal. C'est lui qui est créé en premier, dans la fonction {\bf ssam\_start()}. Il va alors faire dérouler les cycles du simulateur. Un cycle du simulateur se déroule ainsi : \begin{enumerate} \item Se rendre maître de l'Abar \item Ecrire l'état des connexions \item Incrémenter le numéro de cycle \item Relacher l'Abar \end{enumerate} Et ceci, durant le nombre de cycles nécessaire. \subsubsection{Arrêt du simulateur} Il n'a pas été possible de quitter le simulateur réellement proprement. En effet, le fait de quitter abar avant la fin des threads provoque un crash du programme (car les threads sont encore en train de l'utiliser) et il n'est pas possible de tuer tous les threads avant car ils sont bloqués dans un appel à abar. La fonction {\bf abar\_destroy()} n'est donc jamais appelée. \section{Exemples} \subsection{Multiplication de matrices} Un exemple d'architecture disponible dans le fichier {\em add.c} décrit une machine uniprocesseur qui multiplie deux matrices. Il ne fonctionne que pour les matrices carrées. Deux composants sont écrits : \begin{enumerate} \item Un processeur (fonction {\bf cpu()}) qui va lire les lignes et colonnes depuis la mémoire pour les multiplier et inscrire le résultat dans la mémoire \item Une mémoire qui contient les données. Elle ne dispose que d'un seule port d'écriture pour les accès en lecture ET en écriture. \end{enumerate} La communication entre les deux processus est réalisée via 4 connexions : \begin{enumerate} \item {\bf rw} : l'opération à faire \item {\bf data} : la donnée à écrire/lue \item {\bf addr} : l'adresse à laquelle lire/écrire \item {\bf ack} : un drapeau signifiant que l'opération est terminée \end{enumerate} Le nombre de colonnes/lignes est définie par la macro {\bf MAT\_SIZE}. Le contenu de la mémoire est quant à lui dans la variable {\bf tab} dans la fonction {\bf mem()}. \begin{figure} \centering \includegraphics[scale=0.8]{images/exemple1.png} \caption{L'architecture 1} \end{figure} \subsection{Pipeline} Le fichier {\em pipe.c} reprend l'exemple de démonstration de SystemC en ajoutant une mémoire et en essayant d'optimiser le pipeline. Le premier étage prend deux entiers en mémoire et calcule l'addition et la différence. Il les passe alors au second étage afin qu'il calcule la multiplication et la division. Enfin, le dernier étage reçoit les éléments et émet la puissance. Les étages sont retardés au démarrage comme en témoigne l'utilise de la fonction {\bf ssam\_wait\_duration()} au début de chaque étage. Cela permet d'avoir un pipeline quasi continu. L'architecture correspondante au programme est décrite dans la figure suivante. \begin{figure} \centering \includegraphics[scale=0.8]{images/exemple2.png} \caption{L'architecture 2} \end{figure} \end{document}