\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}
