\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 à exécuter, il pourra utiliser l'intégralité des ressources du processeur. Avoir plusieurs threads exécutable parallèlement permet de mieux exploiter les ressources du processeur.

Malheureusement cette solution à deux problèmes importants. Le premier est que comme les threads sont en compétition pour obtenir les ressources, la rapidité d'exécution 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 pollution 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ées à un thread en faveur à un autre même s'il elle lui était utile. De plus les actions comme le prefetch ou la prédiction 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 SMT Hybrid) qui consiste en 4 cores. Dans un autre article, \cite{2004_kumar}, il y a une étude en terme de performance d'exécution 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'exécutions et du Front End et Back end (Que les threads se partage tous les ressources qui ne sont pas les unités d'exécutions).

Nous nommons les partages comme suit :
\begin{description}
\item[Cluster :] Les clusters ce partage les caches de niveaux 2 et les unités d'exécutions.
\item[Unité de lancement :] Les unités d'exécutions ce partage les ports des caches de niveaux 1 et les unités d'exécutions.
\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ésument les caractéristiques communes de chaque instance ainsi que les paramètres spécifiques pour les configurations avec 1,2 et 4 cores (nous définissons un core une UL ou un cluster). Le troisième résument le systèmes mémoires

\begin{center}
\begin{tabular}{|l|c|}
  \hline
  \multicolumn{2}{|c|}{Caractéristiques communes}               \\
  \hline
  Unité d'exécutions                           & 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.