\section{Experimentations}\label{experimentations}
Le SMT est une solution Bas coût d'obtenir une SMT. Elle à aussi l'avantage de tirer profit des systèmes Single Thread. Car Comme les ressources sont intégralement partagé, s'il n'y a qu'un seul thread à éxecuter, il pourra utiliser l'intégralité des ressources du processeur. Avoir plusieurs thread éxecutable en parralléle permet de mieux exploiter les ressources du processeur.

Malheuresement cette solution à deux problèmes importants. Le premier est que comme les threads sont en compétition pour obtenir les ressources, la rapidité d'execution d'un thread dépend des autres thread en compétition. Par exemple si tous les threads font des accès mémoires fréquents, l'unité mémoire va rapidement saturée. Le deuxième problème étant la polution des ressources partagées. Les meilleurs exemples sont les caches et la BTB (Branch Target Buffer). Suivant les activités des autres threads, des lignes de caches peuvent être désalloué à un thread en faveur à un autre même s'il elle lui était utile. De plus les actions comme le prefetch ou la prediciton de branchement risque de privé des threads de lignes utiles contre une hypothétique ligne utile pour le thread bénéficiaire.

Pour ces raisons, nous allons faire varier le degré de partage des ressources. Des travaux équivalent ont été réalisé. Dans \cite{2004_dolbeau}, ils étudient l'influence du partage des des unités à latence longue (multiplication, division ...), du prédicteur de branchement, ainsi que des caches Instructions et Données. Pour ce faire, ils ont implémentés l'architecture {\bf CASH} (CMP And SMP Hybrid) qui consiste en 4 cores. Dans un autre article, \cite{2004_kumar}, il y a une étude en terme de performance d'éxecution mais également en terme de surface du partage des unités flottantes, des ports du crossbar reliant les Caches à la mémoire et des caches instructions et données. Ici l'équipe de Tullsen à valider leur hypothèses sur un système à 8 cores. Le partage des ressources ce fait entre deux cores voisins.

Notre approche consiste à tester l'incidence du partage des caches, des Unités d'éxecutions et du Front End et Back end (Que les threads se partage tous les ressources qui ne sont pas les unités d'excutions).

Nous démominons les partage comme suit :
\begin{description}
\item[Cluster :] Les clusters ce partage les caches de niveaux 2 et les unités d'executions.
\item[Unité de lancement :] Les unités d'éxecutions ce partage les ports des caches de niveaux 1 et les unités d'éxecutions.
\item[Contexte :] Les contextes ce partages l'accès au décodeur, au icache et au prédicteur de branchement.
\end{description}

L'expérimentation ce fait avec le générateur de processeur MORPHEO (acronyme de ``Multi ORganisation for a Processor HEterogeneous and Open''). Une vue d'ensemble de l'architecture résultante peut être vue dans la figure \ref{MORPHEO_overview}. 

\printgraph{MORPHEO_overview}{0.45}{MORPHEO - Vue d'ensemble}

Notre allons analyser l'incidence du partage des ressources au niveau Cluster, UL et Contexte dans un système à 4 Threads, pouvant lancer à chaque cycle 8 instructions. Trois tableaux rémusent les caractérisques communes de chaque instance ainsi que les paramètres spécifiques pour les configurations avec 1,2 et 4 cores (nous définisions un core une UL ou un cluster). Le troisème résument le systèmes mémoires

\begin{center}
\begin{tabular}{|l|c|}
  \hline
  \multicolumn{2}{|c|}{Caractéristiques communes}               \\
  \hline
  Unité d'éxecutions                           & 8              \\
  Profondeur des Stations de Réservations      & 4		\\
  Nombre de branchements spéculés              & 8 		\\
  Return Address Stack                         & 16		\\
  Réseau de bypass                             & Complet        \\
  Nombre de port de lecture                    & 12		\\
  Nombre de port d'écriture                    & 8		\\
  \hline
\end{tabular}
\end{center}

\begin{center}
\begin{tabular}{|l|ccc|}
  \hline
  \multicolumn{4}{|c|}{Caractéristiques spécifiques}            \\
  \hline
                                               & 1 core		& 2 cores	& 4 cores	\\
  \hline
  Largeur du pipeline                          & 8 		& 4 		& 2 		\\
  Taille - Ifetch\_queue                       & 8 		& 4 		& 2 		\\
  Taille - Issue queue                         & 32		& 16 		& 8 		\\
  Taille - Re Order Buffer                     & 128		& 64 		& 32  		\\
  Taille - autres                              & 16		& 8 		& 4  		\\
  Largeur des fenêtres                         & 16		& 8 		& 4 		\\
  Branch Target Buffer                         & 256	        & 128 	        & 64 	        \\
  Méta prédicteur                              & 16k		& 8k		& 4k		\\
  Banc de Registres                            & 256        	& 128      	& 64      	\\
  \hline
\end{tabular}
\end{center}
   
\begin{center}
\begin{tabular}{|l|cc|}
  \hline
  \multicolumn{3}{|c|}{Caractéristiques du système mémoire}\\
  \hline
	                     & L1          & L2             \\
	                     & I/D séparé  & unifié         \\
	\hline
	Taille               & 8 ko        & 2 Mo           \\
	Nombre de lignes     & 128*        & 16k            \\
	Nombre de mots/ligne & 16          & 32             \\
	Associativité        & 4 voies     & 4 voies        \\
	Latence - Hit        & 2 cycles    & 6 cycles       \\
	Pénalités - Miss     & 4 cycles    & 100 cycles     \\
  \hline
\end{tabular}
\end{center}

(Le nombre de lignes du premier niveau de cache est divisé par le nombre de cluster).

Nous allons maintenant voir la méthodologie de test.
