source: trunk/IPs/systemC/processor/Morpheo/Documentation/Source/Documents/presentation_bull/fr/root.tex @ 88

\section{Motivations}
\ContentsCurrent

\slidetitle{Cadre de la thèse}
           {
             \begin{itemize}
             \item {\it Cadre :}\newline
               Collaboration avec Bull sur le projet PFC\newline
               (Plate-forme de confiance totale)
             \item {\it Notre contribution :}\newline
               Réalisation d'un générateur de processeur ouvert.
             \end{itemize}
           }
           {
             Expliquer PFC
           }

\slidetitle{Approche actuelle fondée sur le secret}
           {
             \begin{itemize}
             \item Composants fermés.
             \item Consortium de certification
               \begin{itemize}
               \item Trusted Computing Platform Alliance
%                \begin{itemize}
%                \item Next-Generation Secure Computing Base
%                \item Intel Trusted Execution Technology
%                \end{itemize}
               \end{itemize}
             \end{itemize}

             \printgraph{Logo-trusted_computing_group}{0.8}

             Limite de l'approche :

             \begin{itemize}
             \item Pas de confiance :
               \begin{itemize}
                 \item Chevaux de troie
               \end{itemize}
             \item Pas de pérennité : 
               \begin{itemize}
                 \item Arrêt de production
                 \item Changement de protocole
               \end{itemize}
             \end{itemize}
           }
           {
             Consortium : intel, amd, ibm, microsoft ...

             Le principe du TCG :

             \begin{itemize}
               \item Assigner une signature à chaque objet informatique (logiciel, par extension matériel).
               \item Déléguer à un {\it tiers de confiance} la tâche de vérifier si l'objet manipulé est autorisé à être utilisé sur le système local.
             \end{itemize}

             Enjeux commerciaux != Ouvert et Pérennité.
           }

\slidetitle{Nouvelle approche}
           {
             \begin{itemize}
             \item Composants ouverts
               \begin{itemize}
               \item Pas de fonctionnalités cachées.
               \item Pas de secret à conserver.
               \end{itemize}
             \item Intégration :
               \begin{itemize}
               \item Field-Programmable Gate Array (FPGA).
               \item System On Chip (SOC).
               \end{itemize}
             \end{itemize}

             \begin{center}
               \begin{minipage}{.4\textwidth}
                 \printgraph{Logo-opencores}{0.8}
               \end{minipage}
               \begin{minipage}{.4\textwidth}
                 \printgraph{Logo-soclib}{0.8}
               \end{minipage}
             \end{center}
           }
           {
             Composant matériel ouvert = code source disponible = FPGA = prototypage = SOC.
           }

\section{Cahier des charges}
\ContentsCurrent

\slidetitle{Besoins : Cahier des charges}
           {
             Il faut une architecture :
             \begin{description}
             \item [Ouverte :] Évite les fonctionnalités cachées.
             \item [Pérenne :] Évite les problèmes d'approvisionnements.
             \item [Paramétrable :] S'adapte aux critères de l'application.
             \item [Performante :] Applications nécessitant de la puissance de calculs.
             \end{description}
           }
           {
             Concevoir un cpu pour PFC :
             
             ouverte, pérenne, paramétrable, performante.

             Applications cibles : cryptographique.
           }

\subsection{Architecture Ouverte}
\slidetitle{Architecture Ouverte}
           {
             \begin{itemize}
             \item Instruction Set Architecture gratuite.
            %\item Présence d'une communauté autour de l'architecture logicielle.
             \item Chaîne de compilation disponible et ouverte.
             \item Modèle disponible :
               \begin{itemize}
                 \item Modèle systemC-CABA
                 \item Modèle VHDL-RTL
               \end{itemize}
             \end{itemize}
           }
           {
             Chaîne de compilation $\Rightarrow$ présence d'une communauté, espère une pérennité des logicielles.

             VHDL = FPGA

             SystemC = dévellopement
           }

\subsection{Architecture Pérenne}
\slidetitle{Architecture Pérenne}
           {
             \begin{itemize}
             \item Instruction Set Architecture gratuite.
            %\item Présence d'une communauté autour de l'architecture logicielle.
             \item Chaîne de compilation disponible et ouverte.
             \item Technologie cible flexible : FPGA.
             \end{itemize}
           }
           {
             ISA et Modèle disponible = implémentation possible.
           }

\subsection{Architecture Paramétrable}
\slidetitle{Architecture Paramétrable}
           {
             S'adapter aux critères de l'application :
             \begin{itemize}
             \item Performance
             \item Surface
             \item Consommation
             \item Temps réel
             \item \dots
             \end{itemize}

             Pas un processeur mais plusieurs processeurs.\\
             \begin{itemize}
               \item[$\Rightarrow$] Générateur d'architecture.
               \item[$\Rightarrow$] Technologie cible : FPGA.
             \end{itemize}
           }
           {
             Aucune connaissance à priori des besoins des applications. Peuvent avoir des critères variés ...

             Pas 1CPU mais plusieurs CPU = ASIC trop onéreux 
           }

\subsection{Architecture Performante}
\slidetitle{Architecture Performante}
           {
             \begin{center}
               {\it Exécution de plusieurs instructions simultanément}
             \end{center}

             Exploitation de toutes les formes de parallélisme.

             \begin{description}
             \item[ILP :] Instruction Level Parallelism
             \item[TLP :] Thread      Level Parallelism
             \item[DLP :] Data        Level Parallelism
             \end{description}
           }
           {
           }

%\subsubsection{ILP}
\slidetitle{Instruction Level Paralelism}
           {
             \begin{center}
               {\it Exécution simultanée de plusieurs instructions provenant d'un même flux.}
             \end{center}
             \printgraph{GENERAL_ILP}{1  }
           }
           {
           }
%\slide
%          {
%            \begin{description}
%            \item[Avantages     :]~
%              \begin{itemize}
%              \item Exploitation implicite du point de vue logicielle.
%              \end{itemize}
%            \item[Inconvénients :]~
%              \begin{itemize}
%              \item Coût quadratique du contrôle.
%              \end{itemize}
%            \end{description}
%          }
%          {
%          }


%\subsubsection{TLP}
\slidetitle{Thread Level Paralelism}
           {
             \begin{center}
               {\it Exécution simultanée de plusieurs instructions provenant de différents flux.}
             \end{center}

             \printgraph{GENERAL_TLP}{1  }
           }
           {
           }

%\slide
%          {
%            \begin{description}
%            \item[Avantages     :]~
%              \begin{itemize}
%              \item Implantation très simple : duplication des coeurs
%              \item Ressources dédiés aux threads exécutés sur le coeur
%              \end{itemize}
%            \item[Inconvénients :]~
%              \begin{itemize}
%              \item Il doit avoir plus de thread que de coeurs afin d'éviter l'oisiveté des coeurs
%              \end{itemize}
%            \end{description}
%          }
%          {
%          }
%
%\slidetitle{TLP - Simulatenous Multi Threading (SMT)}
%          {
%            \printgraph{GENERAL_TLP-SMT}{1  }
%          }
%          {
%          }
%
%\slide
%          {
%            \begin{description}
%            \item[Avantages     :]~
%              \begin{itemize}
%              \item Implantation très simple et peu coûteuse en surface.
%              \item Meilleur exploitation des ressources
%              \end{itemize}
%            \item[Inconvénients :]~
%              \begin{itemize}
%              \item Dimensionner le nombre de threads proportionnellement à l'ILP exploitable.
%              \end{itemize}
%            \end{description}
%          }
%          {
%          }

%\subsubsection{DLP}
\slidetitle{Data Level Paralelism}
           {
             \begin{center}
               {\it Exécution d'instructions avec plusieurs données. (SIMD)}
             \end{center}

             \printgraph{GENERAL_DLP}{1  }
           }
           {
             Matrice 3x3 + 10
           }
%\slide
%          {
%            \begin{description}
%            \item[Avantages     :]~
%              \begin{itemize}
%              \item Une instruction SIMD est équivalente à beaucoup d'instructions SISD.
%              \end{itemize}
%            \item[Inconvénients :]~
%              \begin{itemize}
%              \item Pas adapter pour les applications qui n'exploite pas le DLP.
%              \item Exploitation explicite par le programmeur.
%              \end{itemize}
%            \end{description}
%          }
%          {
%          }
%

\slidetitle{Implémentation matérielle}
           {
             \printgraph{GENERAL_hardware}{.98}
           }
           {
             Streaming SIMD Extensions, généralement abrégé SSE, est un jeu de 70 instructions supplémentaires pour microprocesseurs x86, apparu sur le Pentium III. Le fonctionnement est de type SIMD.


             AltiVec est un ensemble d'instructions SIMD d'opérations en virgule flottante conçu par, et propriété de, Apple, IBM et Motorola (l'AIM alliance), et mis en application sur des versions du PowerPC telle le G4 de Motorola et le G5 d'IBM.
           }

\slide
           {
             \begin{description}
             \item[ILP]
               \begin{itemize}
               \item Super Scalaire\\
               \item \sout{VLIW}
                 \begin{itemize}
                   \item[$\Rightarrow$] Compilateur spécialisé.
                   \item[$\Rightarrow$] Pas scalable
                 \end{itemize}
               \end{itemize}
             \item[TLP]
               \begin{itemize}
               \item CMP
                 \begin{itemize}
                   \item[$\Rightarrow$] Scalable mais sous utilisation des ressources.
                 \end{itemize}
               \item SMT
                 \begin{itemize}
                   \item[$\Rightarrow$] Utilisation optimale des ressources mais peu scalable.
                 \end{itemize}
               \item Mixte
               \end{itemize}
             \item[DLP]
               \begin{itemize}
               \item Extension SIMD\\
               \end{itemize}
             \end{description}
           }
           {
             Mixte : tirer partie du CMP et SMT
           }

\section{État actuel}
\ContentsCurrent

\slidetitle{Processeurs libres existants}
           {
             \begin{tabular}{l|ccccc}
               
               {\it Processeur}    & {\it Date} & {\it ISA}            & \multicolumn{2}{c}{{\it Support}} \\
                             &      &                & {\it ASIC} & {\it FPGA}                 \\
               
               \hline
               OpenRISC 1200 & 2001 & or1000-ORBIS32 & X & X\\ %&Mono-core, Scalaire 5 étages, 32 bits\\
               LEON2         & 2003 & SPARC-V8       & X & X\\ %&Mono-core, Scalaire 5 étages, 32 bits\\
               LEON3         & 2005 & SPARC-V8e      & X & X\\ %&Mono-core, Scalaire 7 étages, 32 bits\\
               OpenSparcT1   & 2005 & UltraSPARC-V9  & X & X\\
               MANIK         & 2006 & MANIK          &   & X\\
               aeMB          & 2007 & Xilinx EDK 3.2 &   & X\\ %&Mono-core, Scalaire 3 étages, 32 bits\\
               OpenFIRE      & 2007 & Xilinx EDK 6.3 &   & X\\ %&Mono-core, Scalaire 3 étages, 32 bits\\
               OpenSparcS1   & 2007 & UltraSPARC-V9  & X & X\\
               OpenSparcT2   & 2007 & UltraSPARC-V9  & X & X\\
             \end{tabular}
           }
           {
             Xilinx EDK 3.2 : 2003

             Xilinx EDK 6.3 : 2004

             \begin{tabular}{l|cccc}
               
               {\it Processeur}    & FPGA & taille & freq (Mhz) & remarque\\
               
               \hline
               OpenRISC 1200 &  statix 2 & 3000 & 33 & sans cache\\
               LEON2         &  virtex 2 & 5000 + RAM & 80 & \\
               LEON3         &  ? & 3500 & 125 & \\
               MANIK         &  &  & & \\
               aeMB          &  &  & & \\
               OpenFIRE      &  virtex 2 & 641 & 100\\
             \end{tabular}

             
             Xilinx XC4VLX200   SPARC   FPU     CCX
             LUTs       134,973         13,863  25,090
             
             
             With FPGA\_SYN, FPGA\_SYN\_1THREAD, and FPGA\_SYN\_NO\_SPU options:
             Xilinx XC4VFX100   SPARC   FPU     CCX
             LUTs       40,613  9,398   26,051
             
             
             
             With FPGA\_SYN and FPGA\_SYN\_NO\_SPU options (4 threaded core):
             Xilinx XC4VFX100   SPARC   FPU     CCX
             LUTs       68,476  9,398   26,051
           }
           
\slidetitle{État actuel}
           {
             Il existe plusieurs processeurs libres, mais :

             \begin{itemize}
             \item Aucun processeur n'exploite l'ILP.
             \item Les paramètres concernent principalement le cache.
             \item Seuls les modèles de l'OpenSPARC exploitent le TLP.
             \end{itemize}
           }
           {
           }

%\slidetitle{Fonction de coûts}
%          {
%            Comparaison de deux instances du générateur :
%
%            \begin{itemize}
%            \item Soit : obtenir le meilleur compromis Performance / Complexité. 
%              \begin{itemize}
%              \item Performance : nombre de cycles nécessaire pour exécuter les Benchmarks.
%              \item Complexité  : surface occupée du FPGA.
%              \end{itemize}
%            \item Soit : obtenir le meilleur partage des ressources entre les contextes matériels. (Gain Performance / Coût surface).
%              \begin{itemize}
%              \item Gain en performance : rapport entre la performance MT sur la performance ST.
%              \item Coût en surface     : rapport entre la surface     MT sur la surface     ST.
%              \end{itemize}
%            \end{itemize}
%          }
%          {
%            benchmark : SPECINT2k, Dhrystone
%
%            
%          }

\section{Morpheo}
\ContentsCurrent

\subsection{Paramètres}
\slidetitle{Paramètres}
           {
             3 types :
             \begin{description}
             \item [Global] 
               \begin{itemize}
                 \item Occurrence de chaque entité %[1:8]
                 \item Nombre d'instructions pour chaque entité %[1:8]
               \end{itemize}
             \item [Local] 
               \begin{itemize}
                 \item Présence/Absence du réseau de bypass
                 \item Nombre de registres physiques %[32:512]
                 \item Nombre de ports du banc de registres %[2:16]
                 \item Taille des files d'attente (fetch\_queue, \dots) %[2:8]
                 \item Taille des structures internes (BTB, RAS, \dots)
                 \item Type et taille du prédicteur de branchement
                 \item Type des unités d'exécution
               \end{itemize}
             \item [Routage]
               \begin{itemize}
                 \item Entre les différentes entités
               \end{itemize}    
             \end{description}
           }
           {
           }

\subsection{Architecture interne}
\slidetitle{Architecture interne}
           {
             \printgraph{MORPHEO_micro_architecture-overview}{0.48}
           }
           {
             3 grandes parties :
             \begin{description}
             \item[Front end           :] Amène des paquets d'instructions en séquence, et les décodes. Calcules les adresses suivantes (spéculation) et maintiens l'état des threads (idle, wait, run ...)
             \item[Out Of Order Engine :] Renomme les registres (annulations des dépendances RAW, WAW et WAR). Re Order Buffer : mettre à jour l'état du contexte dans l'ordre d'arriver des threads.
             \item[Execution Loop      :] Boucle ``Read, execute, Write''. Ainsi que les bypass. Instructions peuvent ce lancer dans le désordres.
             \end{description}
           }

\slide
           {
             \printgraph{MORPHEO_micro_architecture-ex01}{0.48}
           }
           {
             Hypothèse de départ

             SMT 2
           }

\slide
           {
             \printgraph{MORPHEO_micro_architecture-ex02}{0.48}
           }
           {
             contexte x4 prédicteur dédié
           }

\slide
           {
             \printgraph{MORPHEO_micro_architecture-ex03}{0.48}
           }
           {
             Select ...
           }

\slide
           {
             \printgraph{MORPHEO_micro_architecture-ex04}{0.48}
           }
           {
             possibilité de CMP
           }


%\slidetitle{Micro Architecture : Front end}
%          {
%            \printgraph{MORPHEO_micro_architecture-front_end}{0.7}
%          }
%          {
%          }
%
%\slidetitle{Micro Architecture : Out Of Order Engine}
%          {
%            \printgraph{MORPHEO_micro_architecture-out_of_order_engine}{0.7}
%          }
%          {
%          }
%
%\slidetitle{Micro Architecture : Execution Loop}
%          {
%            \printgraph{MORPHEO_micro_architecture-execute_loop}{0.7}
%          }
%          {
%          }
%
\section{Méthodologie}
\ContentsCurrent

\subsection{Service offert}
\slidetitle{Service offert}
           {
             \printgraph{MORPHEO_service}{0.75}
           }
           {
           }

\subsection{Méthodologie pour le modèle systemC/CABA}
\slidetitle{Structure du modèle systemC/CABA}
           {
             Deux types de composants :
             \begin{description}
             \item[Comportementale : ]~\\
               \begin{itemize}
               \item 0-1 Fonction de Transition
               \item 0-1 Fonction de Moore
               \item 0-N Fonction de Mealy
               \end{itemize}
             \item[Structurelle : ] Contient des instances de composants comportementale et/ou structuelle.
             \end{description}

             Encapsulation des interfaces de chaque composant ainsi que les instanciations.
           }
           {
           }


\slide
           {
             Pour chaque composant du modèle
             \begin{itemize}
             \item<1->{\bf Construction :}~\\
               \begin{itemize}
               \item Vérification des paramètres
               \item Génération du modèle VHDL
               \item Création des compteurs d'activités
               \end{itemize}
             \item<2-> {\bf Run-time :} A chaque cycle~\\
               \begin{itemize}
               \item Evaluation des compteurs d'activités
               \item Enregistrement de l'état des interfaces
               \end{itemize}
             \item<3-> {\bf Destruction :}~\\
               \begin{itemize}
               \item Sauvegardes des compteurs d'activités dans un fichier au format XML
               \item Mise en forme des activités sur les interfaces afin de générer un test bench pour le modèle VHDL
               \end{itemize}
             \end{itemize}

           }
           {

           }

%\subsection{Validation du modèle systemC/CABA}
%
%\slidetitle{Environnement de simulation}
%          {
%            \begin{itemize}
%            \item Benchmark SPECINT2k.
%              \begin{tabular}{ll}
%                164.gzip   & Compression.                          \\
%                175.vpr    & Placement et routage de circuit FPGA. \\
%                181.mcf    & Optimisation combinatoire.            \\
%                255.vortex & Object-oriented Database.             \\
%                256.bzip2  & Compression.                          \\
%                300.twolf  & Simulateur de placement et de routage.\\
%              \end{tabular}
%            \item Appel système : librairie {\it newlib}.
%            \item Plate-forme matérielle ``custom''
%              \begin{itemize}
%                \item Gestion de l'endienness.
%                \item Pont entre la simulation et le système hôte.
%              \end{itemize}
%            \end{itemize}
%          }
%          {
%            sim2os :
%            \begin{itemize}
%             \item SERVICE\_OPEN 
%             \item SERVICE\_CLOSE
%             \item SERVICE\_READ 
%             \item SERVICE\_WRITE
%             \item SERVICE\_TIME 
%             \item SERVICE\_CLOCK
%             \item SERVICE\_LSEEK
%            \end{itemize}
%          }

%\slidetitle{Hypothèse de travail}
%          {
%            Architecture de références
%            \begin{itemize}
%              \item 4 Threads
%              \item 8 Unités d'exécutions 
%              \item 8 Instructions lancées par cycle
%            \end{itemize}
%            
%            Variation de l'architecture 
%            \begin{itemize}
%            \item Nombre de cache de premier niveau
%            \item Nombre d'unité de lancement (Front\_End et OoO\_Engine)
%            \item Nombre de contexte matériel
%            \item Partage des unités fonctionnelles
%            \end{itemize}
%          }
%          {
%          }
%
%\slidetitle{Résultats}
%          {
%            \begin{center}
%              Variation du partage des ressources entre les contextes matérielles.
%            \end{center}
%            %Rapport entre la performance MT sur la performance ST.
%
%            \printgraph{simulation_performance}{0.7}        
%          }
%          {
%            DIRE : ST / MT.
%
%            MT = exécution parallèle des benchmarks
%
%            ST = exécution séquentielle des benchmarks
%
%
%            ordonnée : IPC
%
%            abscisse : degré de partage
%          }
%
%\slide
%          {
%            %Rapport entre la performance MT sur la performance ST.
%
%            \printgraph{simulation_surface}{0.7}            
%          }
%          {
%          }

\subsection{Méthodologie pour le modèle VHDL/RTL}

\slidetitle{Passage du modèle systemC au modèle VHDL}
           {
             \begin{description}
               \item [Composants structurelles :]~\\
                 \begin{itemize}
                   \item Générés automatiquement.
                 \end{itemize}
               \item [Composants comportementales : ]~\\
                 \begin{itemize}
                 \item En tête et interfaces sont générés automatiquement.
                 \item Reste le corps du composant à écrire.
                 \end{itemize}
               \item [Tests :]~\\
                 \begin{itemize}
                 \item  Générés lors de la simulation systemC.
                 \end{itemize}
             \end{description}
           }
           {
           }

\slide%title{Méthodologie pour l'écriture du générateur VHDL}
           {
             \begin{minipage}{0.54\textwidth}
             \printgraph{VHDL_methodologie}{0.65}
             \end{minipage}
             \begin{minipage}{0.44\textwidth}
               \begin{itemize}
               \item Simulation systemC :\\{\it SystemCass   }
               \item Simulation VHDL    :\\{\it Modelsim            }
               \item Synthèse FPGA      :\\{\it Xilinx ISE   }
               \item FPGA cible         :\\{\it Virtex5LX 330}
               \end{itemize}
             \end{minipage}
           }
           {
             FPGA : virtex5LX 330
           }

%\slidetitle{Exemple : Banc de registres 512x32 bits}
%          {
%            \printgraph{synthese_FPGA-registerfile}{0.7}
%          }
%          {
%          }
%
%\slidetitle{Planning}
%          {
%            \begin{itemize}
%            \item Optimisation du modèle SytemC/CABA
%            \item Écriture du générateur de VHDL/RTL
%            \item Réalisation d'un démonstrateur : 
%              \begin{itemize}
%              \item synthèse sur un FPGA d'une instance du générateur.
%              \item exécution d'une application de test
%              \end{itemize}
%            \end{itemize}
%          }
%          {
%          }


\slidetitle{Conclusion}
           {
             \begin{itemize}
               \item Définition d'un processeur ouvert, haute performance, paramétrable et pérenne.
               \item Disposer d'un outil d'aide à l'exploration architecturale
             \end{itemize}
           }
           {
           }