l3.libnazgul/doc/rapport/devel.tex

\chapter{Le d<>veloppement}

\section{Outils utilis<69>s pour le d<>veloppement}

\subsection{Travail collaboratif}

\par Nous avons travaill<6C> ensemble gr{\^a}ce <20> CVS (Concurrent Versions System). Notre projet est h<>berg<72> chez Sourceforge\footnote{\url{http://www.sourceforge.net}}.
Le CVS permet la modification du code du projet en m{\^e}me temps par plusieurs personnes. Les modifications et les mises <20> jour de chacun des membres du projet sont diffus<75>es instantan<61>ment, avec un risque minimis<69> de conflits lors des modifications du m{\^e}me code.


\subsection{Moyens techniques}

\par Chacun selon nos pr<70>f<EFBFBD>rences, nous avons utilis<69>s des machines sous GNU/Linux ou Microsoft Windows et cod<6F> avec Vim.
La personne sous Microsoft Windows avait une session graphique sur un serveur GNU/Linux, appartenant a un autre membre du projet,
gr{\^a}ce <20> l'utilisation de VNC\footnote{\url{http://www.realvnc.com}} (Virtual Network Computing).
Cela afin de permettre <20> l'utilisateur de Microsoft Windows de pouvoir
tester la biblioth<74>que dans les meilleures conditions, car sous
Microsoft Windows l'utilisateur n'est pas pr<70>venu des
{\em segmentation fault} et autres erreurs syst<73>me. 


\section{Programmation}

\subsection{Description des fonctions et de leurs effets}

\par Nous allons dresser un descriptif de l'utilit<69> des fonctions
utilis<EFBFBD>es dans notre biblioth<74>que. Vous trouverez tous les prototypes
des fonctions dans le fichier \\``\verb+/src/proto.h+'', avec en 
commentaire le fichier d'o<> il est issu. Par contre pour les fonctions
qui g<>n<EFBFBD>rent les {\em ids}, leur prototype est dans le fichier ``\verb+/src/ids.h+'', g<>n<EFBFBD>r<EFBFBD> par ``\verb+/src/ids.c+''.
Le fichier ``\verb+/src/proto.h+'' est connu des logiciels qui utilisent
notre biblioth<74>que, tandis que ``\verb+/src/ids.h+'' non.
Nous allons donc vous d<>crire nos diff<66>rentes fonctions en les classant
par famille.
\newline
\par Nous avons quatre grandes {\em familles} de fonctions.

\begin{description}
\item{\sc msgBuffer*} Ce sont toutes les fonctions qui concernent les
buffers : comment on les cr<63><72>s, les ``attachent'' aux processus. 
\item{\sc msgPool*} Ce sont les fonctions qui permettent de cr<63>er ou de 
d<EFBFBD>truire une {\em pool}, de l'ouvrir ou encore de poser un ``verrou''.
\begin{description}
\item{\sc msgPool*}
\item{\sc msgPoolDataTab*}
\end{description}
\item{\sc msgQueue*} Toutes les fonctions g<>rant les ``queues'', {\em 
	files de maessages}. On y 
trouve celle qui en cr<63><72> une, celles qui v<>rifient si elle est 
disponible ou pas, celles qui ajoutent un <20>l<EFBFBD>ment ou au contraire en 
enl<EFBFBD>ve un.
\begin{description}
\item{\sc msgQueue*}
\item{\sc msgQueueElem*}
\item{\sc msgQueue(Prot/Read)*}
\end{description}
\item{\sc msgSpace*} Ensemble de fonctions qui g<>rent les espaces de 
messages : cr<63>ation, ouverture, listes\ldots
\begin{description}
\item{\sc msgSpace*}
\item{\sc msgSpaceList*}
\item{\sc msgSpaceListElem*}
\end{description}
\end{description}

\subsection{D<EFBFBD>tails sur certaines fonctions}

\par Nous d<>taillerons ici quelques fonctions qui peuvent ne pas 
par{\^i}tre claires, malgr<67> les explications au-dessus, ou qui n'ont
pas encore <20>t<EFBFBD> abord<72>es.

\par Voici la liste des fonctions non abord<72>es dans la partie
pr<EFBFBD>c<EFBFBD>dente, mais n<>anmoins utiles pour la compr<70>hension de notre
bibliot<EFBFBD>que. Les fonctions pour la g<>n<EFBFBD>ration d'{\em ids} ne seront
pas trait<69>es ici, car leur utilit<69> est d<>crite dans la partie {\sc Difficult<6C>s recontr<74>es}.

\begin{itemize}
\item{\sc msgAllocate(\dots)} Prend en argument : un espace de mesage 
{\em msgSpace *}, un num<75>ro de {\em pool} qui est un {\em int}, une 
taille {\em int} et une option {\em int}. Cette fonction, comme 
sp<EFBFBD>cifi<EFBFBD> dans l'<27>nonc<6E>, alloue un buffer
dans le {\em pool} sp<73>cifi<66>, ou sinon dans le {\em pool} le plus proche
en taille (sup<75>rieure ou <20>gale) et qui sera ``potentiellement'' libre
le plus rapidement, sauf s'il l'est d<>j<EFBFBD>. Pour cela, on regarde le
nombre de {\em locks},  qu'il y a dessus gr{\^a}ce aux s<>maphores. On
choisit le buffer dont le {\em pool} a le moins de ``locks'' en fonction
du nombre de ses buffers.
\item{\sc msgFree(\dots)} Cette fonction prend en argument un espace de 
message {\em msgSpace *} et l'adresse d'un buffer {\em void *}. Celle-ci
restitue le buffer au {\em pool} d'o<> il a <20>t<EFBFBD> extrait.
\item{\sc msgGet(\dots)} Notre fonction {\em void * msgGet(\dots)}, est
telle qu'elle corresponde bien <20> l'<27>nonc<6E>. Elle prend en argument un 
espace de messages {\em msgSpace *}, un num<75>ro de file, ou {\em queue},
{\em int} et l'adresse d'un buffer {\em void *}. Elle renvoie l'adresse
du buffer en t{\^e}te de la file du num<75>ro donn<6E> dans l'espace de 
messages sp<73>cifi<66>s. Lors d'un appel <20> cette fonction, celle-ci
``locke'' d'abord le s<>maphore qu'il y a sur la {\em queue}. Si la file
est vide, cela bloque le {\em get}.\\
{\sc Remarque :} Nous n'avons pas impl<70>ment<6E> le cas du \verb+ANYFILE+.
\item{\sc msgPut(\dots)} Cette fonction fait exactement ce qu'elle est
sens<EFBFBD>e faire tel que <20>nonc<6E> dans le rapport. Elle prend en argument un 
espace de messages {\em msgSpace *}, un num<75>ro de file, ou {\em queue}, {\em int} et 
l'adresse d'un buffer {\em void *}. Elle ins<6E>re le buffer dans le num<75>ro
de file de messages de l'espace de messages. Lorsque l'on appelle cette
fonction, <20> la fin, on ``d<>locke'' le s<>maphore sur la {\em queue}.
\item{\sc msgSpaceState(\dots)} Cette fonction prend en argument, un
``id'' d'espace de message, {\em msgSpaceId}, et permet de conna{\^i}tre
l'<27>tat de l'espace de message dont l'``id'' est donn<6E>e en argument.
\end{itemize}
\section{Difficult<EFBFBD>s rencontr<74>es}

\par Nous n'avons pas eu de grosses difficult<6C>s <20> proprement parl<72>.
Nous avions juste quelques restrictions, comme le fait de ne pas
pouvoir utiliser de pointeurs absolus, car l'espace d'adressage entre
les diff<66>rents processus n'est pas forc<72>ment le m{\^e}me. Ils ont
seulement un segment de m<>moire partag<61>e en commun. Il a donc
fallu utiliser les diff<66>rentes {\em id} des espaces de messages {\em msgSpace}, ou
encore des {\em pools} pour pouvoir faire en sorte que les processus peuvent
bien acc<63>der aux {\em buffers} situ<74>s dans la m<>moire partag<61>e.

\par Le choix des identifiants ne fut pas simple non plus, car il
fallait en changer en fonction des diff<66>rentes impl<70>mentations. Par
exemple nous pouvions avoir des identifiants du type ``\verb+/tmp/identifiant+'',
qui ne marchaient que sur un type de machines. Sur les autres il 
fallait en avoir un du type ``\verb+/identifiant+''. Cela nous a amener
<EFBFBD> faire une distinction de cas et g<>n<EFBFBD>rer un identifiant diff<66>rent
selon que l'on soit sur une machine de type {\em HP-UX}, {\em SunOS} 
ou {\em Linux}. 
\par Malheureusement le fait de travailler sur plusieurs types de 
machines n'<27>tait pas seulement g{\^e}nant pour les identifiants, 
mais <20>galement pour cr<63>er la biblioth<74>que. En effet, il faut ajouter
plus ou moins d'options <20> la compilation: soit il faut ajouter \verb+-lrt+, dans un cas ou \verb+-lrt -lpthread+ dans l'autre. Ceci afin 
d'inclure les bonnes librairies pour que notre biblioth<74>que puisse
fonctionner convenablement.
\par Ces distinctions se font dans les {\em Makefile}, \verb+/src/Makefile+ et \verb+/test/Makefile+.
\par Encore une autre difficult<6C> d{\^u}e <20> Posix, est la 
projection de fichier ou {\em mapping} avec {\em mmap}. L'offset
peut {\^e}tre align<67> sur les pages m<>moires sur 
certains syst<73>mes. Or ceci est emb{\^e}tant lorsque l'on veut
acc<EFBFBD>der <20> un fichier qui commence n'importe o<> dans le bloc m<>moire.
Pour rem<65>dier <20> cela, nous {\em mappons} jusqu'<27> ``juste derri<72>re le
buffer''. Nous autorisons le buffer en lecture/<2F>criture et nous d<>pla<6C>ons
l'adresse obtenue au d<>but du buffer.