\documentclass[a4paper]{report}

%\usepackage[top=2cm,bottom=3cm,left=3cm,right=3cm]{geometry}

\usepackage{pdfswitch}
\usepackage[latin1]{inputenc}
\usepackage[french]{babel}
\usepackage{alltt}
\usepackage{remark}
\usepackage{url}
\usepackage{xspace}
\usepackage{boxedminipage}


\def\linuxversion{2.6.10}

\DeclareRobustCommand{\FFxT}{F\kern-.1667em\lower.5ex\hbox{X}%
  \kern-.125emT\spacefactor1000}

\makeatletter
\DeclareRobustCommand{\FxT}{F\kern-.18em%
        %{\sbox\z@ x%
         %\vbox to\ht\z@{%
           \lower.5ex
           \hbox{\check@mathfonts%
                              \fontsize\sf@size\z@%
                              \math@fontsfalse\selectfont%
                              X}%
                          %\vss}%
        %}%
        \kern-.27em%
        T\spacefactor1000}
\makeatother

\title{FxT : manuel d'utilisation}

\author{Vincent Danjean}


% \newenvironment{etapes}{
%   \newcommand{\etape}[1]{\item \textbf{##1}}
%   \begin{enumerate}
%   }{
%   \end{enumerate}
% }
\newcounter{etapes}
\newenvironment{etapes}{
  \setcounter{etapes}{0}
  \newcommand{\etape}[1]{%
    \stepcounter{etapes}%
    \paragraph*{\arabic{etapes}.~##1}\hspace{0cm}%
    \bigskip%
  }
}

\newenvironment{options}{
  \newcommand{\option}[2]{\item[\code{##1}]~\\##2}
  \begin{description}
  }{
  \end{description}
}

\newcommand{\name}[1]{\textsc{#1}}
\newcommand{\code}[1]{\texttt{#1}}
\newenvironment{shell}{%
  \begin{alltt}%
  }{%
  \end{alltt}%
}

\newcommand{\note}[2][]{\par\smallskip\noindent\llap{\textbf{Note
      \ifthenelse{\equal{#1}{}}{}{(#1) }:} }#2\par\medskip}

\newcommand{\FXT}{\FxT\xspace}
\newcommand{\FKT}{\name{FKT}\xspace}
\newcommand{\FUT}{\name{FUT}\xspace}
\newcommand{\marcel}{\name{Marcel}\xspace}
\newcommand{\mad}{\name{Madeleine}\xspace}
\newcommand{\linux}{\name{Linux}\xspace}
\newcommand{\pmm}{\name{PM}$^2$\xspace}
\newcommand{\Paje}{\name{Paj}\xspace}

\newcommand{\ie}{\emph{i.e.}\xspace}
\newcommand{\cf}{\emph{c.f.}\xspace}
\newcommand{\etc}{etc.\xspace}

\newcommand{\fktrecord}{\code{fkt\_record}\xspace}
\newcommand{\fxtprint}{\code{fxt\_print}\xspace}
\newcommand{\sigmund}{\code{sigmund}\xspace}

\begin{document}

\title{{
    \huge Fast Traces
    \\[1em]
    \Huge \FxT
    \\[1em]}
  Manuel d'utilisation}

\maketitle

\tableofcontents

\newpage

\chapter{Prsentation}
Aujourd'hui, il est trs difficile d'observer et de comprendre
finement les performances des applications reposant sur des supports
d'excution multithreads, en particulier lorsque la plateforme de
threads utilise est complexe (ordonnancement multi-niveaux). \FXT
est un environnement permettant d'observer prcisment le
comportement des applications multithreades donnant ainsi accs  des
informations telles que le nombre de cycles consomms par une fonction
donne ou l'ordonnancement exact des threads utiliss.

\FXT est compos de deux parties indpendantes (\FKT et \FUT) pour la
rcolte de traces ainsi que d'outils pour l'analyse et l'exploitation
des traces rcolts.

\paragraph{\FKT}
\emph{Fast Kernel Trace} permet de rcolter des vnements relatifs au
noyau \linux grce  un ensemble de macros insres dans le code
source du noyau. Cette rcolte est ralise de manire trs efficace
et non intrusive.

\paragraph{\FUT}
\emph{Fast User Trace}, trs similaire  \FKT, permet de faire la mme
chose (rcolte d'vnements) en mode utilisateur.

On peut les utiliser indpendemment l'un de l'autre.

\paragraph{Les outils} Un ensemble d'outils permettent de manipuler et
d'exploiter les traces gnres par \FKT et \FUT. On peut ainsi les
parcourir mais aussi les fusionner pour gnrer une 
unique \emph{supertrace} dcrivant pour chaque vnement sur quel
processeur, dans quel thread noyau et dans quel thread utilisateur il
s'est excut. Il est alors possible de gnrer une trace au format du
logiciel \Paje afin de visualiser ces traces de manire graphique et
interactive.



\bigskip
Pour de plus amples informations sur le fonctionnement interne de \FKT et
\FUT, le lecteur se rfrera  \cite{DanWac05TSI}.

\newpage
\chapter{Installation}
  
\section{Rcuprer les logiciels}
\FXT est disponible sur le site
\url{http://savannah.nongnu.org/projects/fkt}. Pour bnficier
pleinement de \FXT avec des programmes utilisant des processus lgers
utilisateurs,
vous aurez galement besoin d'une version rcente de \marcel disponible
sur le site \url{http://runtime.bordeaux.inria.fr/marcel/}.
%Remarque~:
%\FXT pourrait galement fonctionner avec d'autres bibliothques de
%threads utilisateur, mais aucune autre que \pmm n'a pour l'instant t interface
%avec \FXT.

L'installation de FKT ncessite de patcher le noyau. L'installation de
FUT et de la libfxt ne ncessite pas de patcher le noyau.

\section{FKT}
\label{sec:install_fkt}
Les tapes ncessaires pour installer \FKT dans un noyau \linux sont
dcrites ici. On supposera par la suite que les fichiers du projets
\FXT ont t rapatries dans un rpertoire appel \code{FxT/}
ci-dessous.

\note{ ce jour, seule l'architecture \code{x86} contient les routines
assembleurs de \FXT. Un travail de portage serait ncessaire pour
utiliser \FXT sur d'autres architectures.}

\note[bis]{Pour une machine ddie o un programme utilisateur
  n'utilisera pas plus de threads noyaux que de processeurs (par
  exemple, un programme utilisant la bibliothque \marcel), \FXT n'est
  pas rellement ncessaire pour observer le comportement des
  threads.}


\begin{etapes}
  
  \etape{Rcuprer les sources d'un noyau \linux}

  Le noyau original \linuxversion{} est parfait. Une version patche
  devrait galement convenir, au moins pour la partie gnrique. Les
  patches de recueil d'vnements pourront ne pas s'appliquer
  directement~; il faudra alors les corriger manuellement.

  La partie gnrique devrait s'appliquer sur n'importe quel noyau 2.6
  rcent, mais les patches de recueil d'vnements doivent parfois
  tre modifis. Dans ce cas, vrifiez toujours qu'une nouvelle
  version de \FXT n'est pas disponible avec les patches adapts 
  votre noyau.

  Le rpertoire contenant les sources du noyau \linux sera appel
  \code{linux/} par la suite.

  \etape{Installer la partie gnrique de \FKT}

  Placez-vous dans le rpertoire contenant \FXT.
\begin{shell}
  cd FxT/
\end{shell}
 
  Modifiez \code{Makefile.config} pour indiquer o se situe votre
  rpertoire contenant les sources du noyau \linux, ainsi que la
  version des patches  essayer (indiquez la version exacte de votre
  noyau si elle est disponible, la plus proche sinon).  Les versions
  de patches disponibles sont les numros de version des rpertoires
  \code{linux-patches-...} dans le rpertoire de \FXT.

  Installez les fichiers gnriques (indpendant de la version du
  noyau)  l'aide de la commande suivante~:
\begin{shell}
  make install-fkt
\end{shell}
  Ceci copiera les fichiers \FKT, \ie les fichiers
  \code{arch/i386/kernel/fkt\_header.S}, \code{include/linux/fkt.h},
  \code{kernel/fkt.c} et \code{kernel/fkt-mod.c}. Tous ces fichiers
  sont indpendants de la version du noyau.

  Il faut ensuite modifier (patcher) quelques fichiers du noyau. Cela
  s'effectue avec la commande~:
\begin{shell}
  make install-sys
\end{shell}
  Si le noyau utilis correspond exactement  celui dclar dans
  \code{Makefile.config} (mme numro de version, aucun patch
  supplmentaire), alors cette tape doit se drouler sans
  aucun problme. Dans ce cas contraire, il sera peut-tre ncessaire
  corriger l'application des patches en les appliquant  la main. La
  figure \ref{fig:patchsys} peut aider  ce travail dans ce cas.

  \begin{figure}[htbp]
    \begin{center}
      \begin{boxedminipage}{.9\linewidth}
        \newcommand{\fichier}[1]{\item[\textnormal{\code{#1}}]}
        \newcommand{\raison}[1]{~\\ #1}
        \begin{itemize}
          \fichier{arch/i386/config.in} %
          \fichier{arch/i386/Kconfig} %
          \fichier{arch/i386/defconfig}%
          \fichier{arch/i386/kernel/Makefile}%
          \fichier{kernel/Makefile} %
          \raison{ajoute \FKT au systme de compilation. En cas de
            problme, l'application du patch est trs simple 
            raliser manuellement.
            % just added the compilation of fkt, it can be easily done
            % by hand if it didn't merge.
          }

          \fichier{include/linux/pagemap.h} %
          \fichier{mm/filemap.c} %
          \fichier{fs/read\_write.c} %
          \raison{ajoute quelques fonctions utilitaires. Pour les
            anciens noyaux 2.4, \code{sendfile} est galement modifie
            pour appeler \FKT comme il se doit. Facile  appliquer
            manuellement.
            % added helper functions, easy to apply by hand, but also
            % tinkered in sendfile functions to have fkt's called (not
            % needed in 2.6 kernels) Also removed the useless copy of
            % fkt pages.
          }

          \fichier{include/linux/mm.h}
          \fichier{include/linux/page-flags.h}
          \fichier{mm/page\_alloc.c} %
          \raison{dfinit un nouveau drapeau pour les pages \FKT
            afin d'avoir un compteur de rfrence non null si elle
            sont \code{Reserved}.
            % defined a new flag for FKT pages to see its usage
            % counter vary even if they are Reserved.
          }

          \fichier{include/linux/fs.h}
          \fichier{include/linux/buffer\_head.h} %
          \fichier{fs/buffer.c} %
          \raison{ajoute quelques fonctions utilitaires, facile 
            appliquer manuellement. Quelques prises de traces sont
            galement insres, mais elles ne sont utiles que pour le
            dboggage de l'criture des traces \FKT.
            % added helper functions, easy to apply by hand. It also
            % adds some probes, but they are only useful for debugging
            % fkt flushing.
          }

          \fichier{kernel/sched.c} %
          \fichier{fs/exec.c} %
          \fichier{include/linux/sched.h} %
          \fichier{kernel/pid.c} %
          \raison{ajoute des prises de traces ncessaires aux
            outils d'analyse pour suivre les fonctions \code{fork()},
            \code{exec()}, \code{switch\_to()} et \code{wait4()}.
          % added probe for the analysis tool to follow fork()s,
          % exec()s, switch_to()s and wait4()s
          }

          \fichier{arch/i386/kernel/entry.S} %
          \raison{ajoute des prises de traces pour tous les appels
            systmes ainsi que quelques appels systmes pour
            enregistrer des vnements sur demande des programmes
            utilisateurs. Ces modifications doivent tre fusionnes en
            faisant bien attention en cas de problmes.
            % added probes to every system call, and a few system
            % calls to be able to add probes to user programs.  As
            % long as user programs probes are not needed, the last
            % hunk failing is no hurt. But previous hunks should be
            % handled carefully if they didn't merge.
          }

          \fichier{include/asm-i386/unistd.h} %
          \raison{ajoute les appels systmes cit au-dessus
            % just system calls adding, same remark as above.
          }

          \fichier{include/asm-i386/hw\_irq.h} %
          \raison{ajoute des prises de traces pour les IRQs.  traiter
            avec attention en cas de problmes.
            % added probes to every irq. To be handled carefully if it
            % didn't merge.
          }

          \fichier{include/linux/interrupt.h} %
          \raison{ajoute une \code{softirq} pour \FKT. Facile 
            appliquer manuellement.
            % added a softirq for fkt, really easy to merge.
          }

          \fichier{kernel/timer.c} %
          \raison{
            ajoute des prises de traces pour nanosleep. Peut tre
            ignor en cas de problmes.
            % added probes to nanosleep, can be skipped if it didn't
            % merge.
          }
          
        \end{itemize}
      \end{boxedminipage}
    \end{center}
    \caption{Rsum des modifications apportes aux sources}
    \label{fig:patchsys}
  \end{figure}

  \etape{Insertion de prises de traces supplmentaires (facultatif)}
  \label{sec:install_fkt_patches}

  Si l'on dsire instrumenter plus en dtail le noyau, il existe dj
  des ensembles d'instrumentation prtes  l'emploi. \emph{Cette tape
    est compltement facultative.} Il est inutile d'appliquer ces
  patches si les vnements enregistrs ne sont pas intressants pour
  vous.

  Ces ensembles d'instrumentation ne sont disponibles que pour le
  noyau 2.4.21  l'heure actuel. Si vous utilisez un autre noyau, vous
  aurez probablement  grer des conflits manuellement lors de
  l'application de ces patches.

  Pour appliquer ces ensembles d'instrumentation, il faut donc
  positionner \code{KERN\_VERSION}  2.4.21 dans
  \code{Makefile.config}, puis utiliser une ou plusieurs des commandes
  suivantes~:

\begin{shell}
  make install-fs
\end{shell}
ajoute des prises de traces pour les oprations du systme de
fichier~: \code{lseek}, \code{read}, \code{write}, \code{ext2\_getblk},
\code{ll\_rw\_blk}
%will add probes to file system operations: lseek, read, write, ext2_getblk,
%ll_rw_blk
\begin{shell}
  make install-net
\end{shell}
ajoute des prises de traces dans la pile TCP/IP. Diffrentes couches
peuvent tre slectionnes grce au masque d'enregistrement (\cf
\ref{usage}  la page \pageref{usage})
%  will add probes to the whole tcp/ip stack. Different layers can then be
%selected or not according to the recording keymask (see README).
\begin{shell}
  make install-netdriver-3c59x or acenic or tulip
\end{shell}
ajoute des prises de traces dans le pilote de la carte rseau correspondante
%will add probes to the relevant network device driver.
\begin{shell}
  make install-scsigen
\end{shell}
ajoute des prises de traces dans le pilote SCSI generique et le
pilote CD SCSI
% will add probes to the generic scsi driver and scsi cd driver.

  \etape{Compilation du noyau}

  Une fois adapt, le noyau \linux doit tre compil en validant le
  support pour \FKT.

  Allez dans le rpertoire \code{linux} et configurez votre noyau~:
\begin{shell}
  cd linux/
  make config \emph{(ou} make oldconfig \emph{ou} make xconfig\emph{)}
\end{shell}
Vous devez valider le support (ventuellement en module) pour \FKT
(\texttt{CONFIG\_FKT}). \texttt{CONFIG\_FKT\_TIME\_ONLY} permet de
rduire la taille des traces en n'enregistrant pas les paramtres,
mais ce mode est  rserver  ceux qui veulent profiler le noyau (et
non pas profiler des applications en espace utilisateur).

Il faut ensuite compiler son noyau et l'installer. Par exemple, avec :
\begin{shell}
  make dep \&\& make clean \&\& make bzImage
  make install
\end{shell}

  \etape{Pour les utilisateurs}

  Il est galement ncessaire de crer le fichier priphrique
  \code{/dev/fkt}, par exemple avec la commande:
\begin{shell}
  mknod /dev/fkt b 60 0    
\end{shell}

  Pour les personnes ayant choisit de compiler \FKT en module, elles
  pourront ajouter  leur fichier \code{/etc/modules.conf} la ligne :
\begin{shell}
  alias block-major-60 fkt-mod
\end{shell}
  de sorte que le module puisse tre charg automatiquement.

  Pour restreindre l'utilisation de \FXT aux utilisateurs d'un certain
  groupe \code{group}, il est possible de modifier les permissions du
  fichier \code{/dev/fkt} :
\begin{shell}
  chgrp somegroup /dev/fkt
  chmod 440 /dev/fkt
\end{shell}

\end{etapes}

\section{FUT et les utilitaires}
  \FUT et les utilitaires de \FXT ont besoin de quelques
  bibliothques externes. Vous devrez probablement installer, si ce
  n'est pas dj fait, le package contenant la bibliothque
  \code{libbfd} (probablement le package \code{binutils-dev}).

  Il suffit ensuite d'utiliser le classique
\begin{shell}
  ./configure
  make 
  make install
\end{shell}
  Cela construit tous les fichiers ncessaires  l'utilisation de \FUT
  ainsi que les utilitaires qui permettront de rcolter et analyser
  les traces.

  Pour plus de facilit d'utilisation, vous pourrez installer les
  programmes dans un rpertoire de votre \code{PATH} ainsi que les
  bibliothques (fichiers \code{libfxt.*}) dans un rpertoire lu par
  le linker (\code{/usr/local/lib}, \code{/usr/lib}, \ldots) ou
  prsent dans votre variable d'environnement \code{LD\_LIBRARY\_PATH}.

\chapter{Prise de traces}
\FXT permet d'obtenir des traces prcises du droulement de
l'excution de flots d'excution. Ce chapitre explique brivement
comment placer des mesures dans les application et comment obtenir les
traces.

\section{FKT}

\FKT permet d'observer le comportement du noyau. Il y a deux objectifs
 cela : observer le fonctionnement du noyau lui-mme et obtenir des
traces utiles pour l'observation de programmes en espace utilisateur.

\subsection{Instrumentation du noyau}
L'installation des patch de \FKT (\cf partie \ref{sec:install_fkt})
dans les sources du noyau \linux insre les prises de traces ncessaires 
l'observation des programmes en espace utilisateur.  savoir, des
traces sont rcoltes pour
\begin{itemize}
\item chaque changement de contexte ;
\item chaque cration/destruction d'un flot d'excution (processus ou
  thread noyau) ;
\item chaque changement d'espace virtuel (\code{execve}) pour
  enregistrer le nom des nouveaux processus ;
\item chaque transition noyau/utilisateur (appels systmes,
  interruption matrielle, \etc).
\end{itemize}
Il est possible d'instrumenter plus finement le noyau. Quelques
patches sont fournis avec la distribution (\cf partie
\ref{sec:install_fkt_patches}), mais pour des besoins particuliers il
est parfaitement possible d'instrumenter soit-mme le noyau en
utilisant les mmes techniques que celles dveloppes ci-aprs pour
les programmes en espace utilisateur. 

\subsection{Rcolte des traces noyaux avec \fktrecord}
Pour enregistrer les traces rcoltes par le noyau, l'utilitaire
\fktrecord est fourni. Il s'utilise de la manire suivante :
\begin{shell}
   fkt_record [options..] [--] [program p1 p2 p3 ...]
\end{shell}
Si le programme n'est pas donne, \fktrecord dmarre un fils qui se
contentera de consommer du CPU.

Les options possibles sont :
\begin{options}
  \option{-f output\_file}{sauve la trace dans le fichier
    \code{output\_file}. Si cette option n'est pas fournie, \fktrecord
    utilise le contenu de la variable d'environnement
    \code{TRACE\_FILE} et en cas d'absence il cre le fichier
    \emph{trace\_file}}
%
  \option{-k mask}{masque  utiliser pour la rcolte d'vnements. Par
    dfaut, \fktrecord utilise la valeur 1 qui enregistre
    uniquement\footnote{Les changements de contexte sont
      \emph{toujours} enregistrs par \FKT, quelque soit le masque
      actif.} les transitions noyau/utilisateur (appels systmes, irq,
    \etc)}
%
  \option{-S System.map}{si ce fichier est indiqu, son contenu est
    fusionn avec celui de \code{/proc/kallsyms} ou
    \code{/proc/ksyms} en vrifiant qu'il n'y a pas d'incohrence. En
    effet, les symboles du noyau sont enregistrs au dbut de la trace
    pour permettre l'analyse de la trace par la suite}
%
  \option{-s size}{taille des blocks. Par dfaut, la taille des blocks
    du systme de fichier est utilise. Option  rserver aux
    experts.}
%
  \option{-p pow}{alloue $2^{pow}$ page mmoire pour contenir les
    traces avant criture sur disque. Par dfaut, 7 pages sont
    alloues. Il peut tre ncessaire d'augmenter cette quantit si on
    enregistre de grosses quantits de traces en un trs bref
    instant.}
%
  \option{-n}{aucun programme n'est lanc. La prise de trace
    s'arrtera lorsque l'utilisateur interrompra (avec \texttt{\^~C}
    par exemple) le programme \fktrecord.}
\end{options}

\section{FUT et \pmm}
\FXT fournit des outils pour permettre l'instrumentation des
programmes utilisateurs, mais ils ne sont pas aiss  manipuler
directement. C'est pourquoi il est conseiller d'utiliser une
bibliothque de processus lger intgrant dj le support pour \FXT.
\pmm et sa bibliothque de thread \marcel sont parfaitement intgrs
avec \FXT.

\subsection{Instrumentation des programmes}
Les traces utilisateurs proviennent de l'instrumentation des
programmes. \pmm propose plusieurs manire de le faire.
\begin{description}
\item[Instrumentation manuelle~:] un ensemble de macro est disponible
  pour prendre des traces automatiquement. Il est possible
  d'enregistrer tout types d'vnements. Les macros ncessitent un
  code unique (qui identifie le type d'vnement) et acceptent un
  nombre variable de paramtres, actuellement de 0  5, mais ce nombre
  peut tre augment jusqu' 254 sans difficults. L'ensemble de ces
  macros est disponible dans le fichier \code{fut.h}.
\item[Instrumentation automatique~:] en utilisant l'option
  \code{-finstrument-function} de \code{gcc}, les fonctions des
  fichiers objets compils ainsi auront automatiquement une trace
  gnre  l'entre et une  la sortie.
\end{description}

En outre, deux fonctions sont  utiliser dans le programme principal~:
\begin{shell}
  void profile_activate(int FUT_ENABLE, int fut_mask, int fkt_mask);
  void profile_stop();
\end{shell}
La premire permet de dmarrer et choisir les masques d'vnements
pour FKT et FUT, la seconde permet de stopper les traces et de les
sauver sur le disque.
\pmm sauve les traces dans les fichiers
\code{/tmp/prof\_file\_user|kernel\_\emph{login}[\_\emph{node}]}.

\note{le n\oe ud n'est sauv dans le fichier que si \pmm est utilis
  en rseau (\ie avec \mad).}
\note[bis]{\pmm active lui-mme FKT si ncessaire. Il n'y a alors pas
  besoin d'utiliser le programme \fktrecord.}

\subsection{Rcoltes des traces avec \pmm}

Pour rcolter les traces avec un programme \pmm, il suffit de le
lancer avec une \emph{flavor} contenant le support \FXT. Pour cela, au
moment du choix des options de la \emph{flavor}, il faut :
\begin{itemize}
\item inclure le module \code{profile}
\item prendre l'option \code{FKT} du module \code{profile} si l'on
  veut utiliser \FKT en plus de \FUT
\item choisir l'option \code{gcc-instrument} pour chacun des modules
  \pmm que l'on veut instrumenter automatiquement avec \code{gcc}
\item choisir l'option \code{profiling} pour chacun des modules \pmm
  afin d'utiliser les instrumentations manuelles dj prsentes
\end{itemize}
L'excution du programme ainsi compil gnrera automatiquement les
traces ( condition de bien dmarrer et arrter la prise de traces
avec \code{profile\_activate} et \code{profile\_stop}.

\chapter{Exploitation des traces}
Une fois les traces recueillies, il est ncessaire de les analyser.
\FUT fonctionnant sur deux architectures diffrentes (64bits et
32bits), il est ncessaire de prendre en compte cet aspect pour
utiliser les programmes : le format des traces binaires rcoltes ne
sera pas compatible.

\section{Analyse des traces rcoltes}
Dans un premier temps, l'utilitaire \fxtprint permet de convertir une
trace binaire rcoltes en une trace au format texte.
\begin{shell}
  fxt_print [-f trace_file] [-d] [-o]
\end{shell}
Les options disponibles sont les suivantes :
\begin{options}
  \option{-f trace\_file}{lit la trace dans le fichier
    \code{trace\_file}. Si cette option n'est pas fournie, \fxtprint
    utilise le contenu de la variable d'environnement
    \code{TRACE\_FILE} et en cas d'absence il lit le fichier
    \emph{trace\_file}}
%
  \option{-d}{permet de demander  \fxtprint de ne pas essayer de nomm
    les vnements et les fonctions, mais d'afficher les identifiants
    (codes) tels qu'ils sont stocks dans la trace (utile surtout pour
    le dbogage pour inspecter prcisment le contenu d'une trace)}
%
  \option{-o}{permet de demander  \fxtprint d'afficher non plus la
    date des vnements, mais le temps coul depuis le premier
    vnement (les dates sont dcales de sortes que le premier
    vnement survienne  la date 0)}
\end{options}
Cette conversion de la trace au format binaire en une trace ASCII doit
tre faite sur la mme architecture que la machine qui a rcolt les
traces.


\section{Visualisation graphique}

Les traces en ASCII peuvent ensuite tre visualises. Pour cela, elles
doivent tre mises en forme, ventuellement fusionnes (si on utilise
\FUT et \FKT), tries (les vnements ne sont pas ncessairement
enregistrs dans le bon ordre), \etc C'est le programme utilitaire
\code{sigmund} qui est responsable de cela :
\begin{shell}
  fxt_print [--user user_trace_file] [--kernel kernel_trace_file] [--paje]
\end{shell}
\begin{options}
  \option{--user user\_trace\_file}{indique une trace utilisateur
    (\FUT)  traiter. Cette trace doit avoir dj t convertie en
    ASCII avec \fxtprint }
%
  \option{--kernel kernel\_trace\_file}{indique une trace noyau (\FKT)
     traiter. Cette trace doit avoir dj t convertie en ASCII avec
    \fxtprint }
%
  \option{--paje}{gnre une trace complte au format \Paje}
\end{options}

\sigmund trie les traces, les fusionne si on lui en fourni
deux, insre les vnements d'ordonnancement manquants (prise de la
main au dbut des traces et dordonnancement des threads  la fin),
insre des pseudo-vnements (cration et destruction des
threads/LWPs/processeurs/\ldots), \etc Pour l'instant, il n'est pas
possible de choisir un sous-ensemble d'actions  effectuer. La
prochaine version de \sigmund le permettra.

Enfin, par dfaut, \sigmund affiche cette super-trace complte. Avec
l'option \code{--paje}, une tape supplmentaire est gnre de faon
 convertir cette super-trace en un format de trace acceptable par le
logiciel de visualisation graphique \Paje. 

\begin{figure}[phtb]
  \centering \hspace*{-2cm}\includegraphics{paje}
  \caption{Visualisation d'une trace avec \name{Paj}}
  \label{fig:paje}
\end{figure}

Sur la figure~\ref{fig:paje}, on peut observer un extrait du
droulement d'un programme multithread. Sur cet exemple, la machine a
quatre processeurs physiques (il s'agit d'un biprocesseur \name{Xeon
  SMT}).  L'application observe (nomme \texttt{traces}) utilise deux
threads noyaux pour ordonnancer ses quatre threads utilisateurs~:
trois threads sont destins aux calculs d'un produit de matrice
(nomms \texttt{calcul1}, \texttt{calcul2 } et \texttt{calcul3}) et le
quatrime assure des communications.  Les informations sont
reprsentes dans trois zones matrialisant les points de vue thread
utilisateur, thread noyau et processeur\footnote{Si tous les threads
  noyaux et tous les processeurs du systme sont reprsents, seuls
  les threads utilisateurs de l'application espionne sont
  observables.}.  Dtaillons ces diffrentes vues~:
\begin{description}

\item[Informations sur chaque thread noyau~:]~
  \begin{enumerate}
  \item identit du processeur physique utilis (lorsque ce thread est
  ordonnanc par le systme d'exploitation)~;
\item identit du thread utilisateur qu'il ordonnance (si le thread
  noyau excute l'application observe)~;
  \end{enumerate}

\item[Informations sur chaque processeur~:]~
  \begin{enumerate}
  \item identit du thread noyau excut~;
  \item identit du thread utilisateur excut (s'il s'agit de
    l'excution de l'application observe)~;
  \end{enumerate}

\item[Informations sur chaque thread utilisateur~:]~
  \begin{enumerate}
  \item identit du thread noyau propulseur (lorsqu'il est slectionn
    par l'ordonnanceur de l'application)~;
  \item identit du processeur physique lorsqu'il est rellement
    excut (il doit alors tre aussi ordonnanc par un thread noyau)~;
  \item embotement des appels de fonction et des vnements tracs
    dans l'application.
  \end{enumerate}
\end{description}
  

\chapter{Perspectives}
Le programme \fxtprint et la bibliothque \code{libfxt} vont tre
tendus pour permettre de lire des fichiers de traces produits sur une
machine d'architecture diffrente.

Le programme \sigmund va galement tre tendu afin de permettre de
mieux manipuler les flots de traces : filtrages en fonction du type
des vnements, de dates, de l'metteur des vnements, \etc. Cela
permettra de choisir facilement et prcisment les informations que
l'on souhaite visualiser dans le logiciel \Paje.

Les outils pour instrumenter les applications seront toffes afin de
permettre de dcrire facilement, rapidement et de manire gnrique
quelle reprsentation on souhaite dans \Paje pour chaque type
d'vnement de l'application.

\bibliographystyle{fr-plain}
\bibliography{FxT}
\addcontentsline{toc}{chapter}{\refname}
\nocite{*}
\end{document}

% LocalWords:  patches patch