\section{Méthodologie}\label{methodologie}

\subsection{Charge de travails}

Dans un premier temps, nous avons sélectionné 6 benchmarks parmi les SPECINT2000 (164.gzip, 175.vpr, 181.mcf, 255.vortex, 256.bzip2, 300.twolf). Nous ne les avons pas tous sélectionnée afin de ne pas avoir trop de simulations à effectuer et car tous les benchmarks ne fonctionnes pas (problème de compatibilité avec gcc 4 et avec notre modèle).


Le nombre de software soumit au architecture est décrite par la combinaison $C_{nb\_benchmarks}^{nb\_threads}$. Comme le nombre de benchmark est de 6 pour 4 threads possible, nous obtenons une charge de travails composée de 15 simulations.

Pour les libraries standard (libc et libm) ainsi que les fonctions bas niveaux (read, write, open, close ...) qu'un système d'exploitation ce doit d'offrir, nous utilisons la librairie {\it Newlib}.

\subsection{Simulation}

Pour les simulations, nous avons prit 14 instances de notre modèle. Elle sont déterminer par le nombre de cluster (A), le nombre d'ULs de chaque cluster (B) et le nombre de contexte de chaque UL (C). De plus chaque UL n'a accès qu'a un sous ensemble distinct d'ALUs. Le nombre d'ALUs accessible par un core est définit par la taille du groupe (D).

Si E=A*B*C, nous nommerons une instance x$E$\_$A$\_$B$\_$C$-$D$. Le tableau suivant récapitules toutes les instances que nous avons sélectionnés.

\begin{tabular}{ccccc}
Nom          & Cluster & UL & Contexte & Taille groupe d'ALUs\\
x4-1\_1\_4-8 & 1       & 1  & 4        & 8\\
x4-1\_2\_2-8 & 1       & 2  & 2        & 8\\
x4-1\_2\_2-4 & 1       & 2  & 2        & 4\\
x4-1\_4\_1-8 & 1       & 4  & 1        & 8\\
x4-1\_4\_1-2 & 1       & 4  & 1        & 2\\
x4-2\_1\_2-8 & 2       & 1  & 2        & 8\\
x4-2\_1\_2-4 & 2       & 1  & 2        & 4\\
x4-2\_2\_1-8 & 2       & 2  & 1        & 8\\
x4-2\_2\_1-4 & 2       & 2  & 1        & 4\\
x4-2\_2\_1-2 & 2       & 2  & 1        & 2\\
x4-4\_1\_1-8 & 4       & 1  & 1        & 8\\
x4-4\_1\_1-4 & 4       & 1  & 1        & 4\\
x4-4\_1\_1-2 & 4       & 1  & 1        & 2\\
\end{tabular}

Nous simulerons 110 millions de cycles. Les 10 premiers millions seront ignorés afin de ne pas dégrader les résultats avec des miss à froid des caches et des unités de spéculations. Pour chaque instance, nous prenons le nombre d'instructions exécutée des 15 simulations. Ce résultat est comparé à la moyenne des 6 benchmarks exécutés dans la version Single Thread du processeur (execution séquentiels des 6 benchmarks avec la même instance).

Nous pouvons remarque que les instances ne vont pas être comparé entre eux par une instance de référence, mais serons comparer avec le speedup de la version MT par rapport à la version ST. Ceci à la bonne propriété d'avoir une borne maximal au speed up qui est le nombre de thread (ici 4). 

