2020-03-03 22:30:21 +00:00
\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} } .
2004-02-26 11:36:30 +00:00
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 peuvent
ainsi <20> tre diffus<75> es instantan<61> ment, avec un risque minimis<69> de conflits lors des modifications du m{ \^ e} me code.
2020-03-03 22:30:21 +00:00
\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).
2004-02-26 11:36:30 +00:00
Cela afin de permettre <20> l'utilisateur de Microsoft Windows de pouvoir compiler et tester
la biblioth<74> que dans de meilleurs conditions que sous son syst<73> me initial\ldots
2020-03-03 22:30:21 +00:00
\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+''.
2004-02-26 11:36:30 +00:00
\par Le fichier ``\verb +/src/proto.h+'' est connu des logiciels qui utilisent
2020-03-03 22:30:21 +00:00
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
2004-02-26 11:36:30 +00:00
2020-03-03 22:30:21 +00:00
\par Nous avons quatre grandes { \em familles} de fonctions.
\begin { description}
2004-02-26 11:36:30 +00:00
\item [msgBuffer*] { Ce sont toutes les fonctions qui concernent les
buffers : cr<63> ation, attachement aux processus\ldots }
\item [msgPool*] { Ce sont les fonctions qui permettent de cr<63> er ou de
2020-03-03 22:30:21 +00:00
d<EFBFBD> truire une { \em pool} , de l'ouvrir ou encore de poser un ``verrou''.
\begin { description}
2004-02-26 11:36:30 +00:00
\item [msgPool*] { Fonctions servant <20> g<> rer une { \em pool} , qui
correspond <20> un ensemble de { \em buffers} .}
\item [msgPoolDataTab*] { Fonctions utiles pour la gestion des
2020-03-03 22:30:21 +00:00
informations d'une { \em pool} telles que la taille des { \em buffers} ,
2004-02-26 11:36:30 +00:00
leur nombre\dots }
2020-03-03 22:30:21 +00:00
\end { description}
2004-02-26 11:36:30 +00:00
}
\item [msgQueue*] { Toutes les fonctions g<> rant les ``queues'', { \em
files de messages} . On y trouve celle qui en cr<63> <72> une, celles i
qui v<> rifient si elle est disponible ou pas, celles qui ajoutent
un <20> l<EFBFBD> ment ou au contraire en enl<6E> ve un.
2020-03-03 22:30:21 +00:00
\begin { description}
2004-02-26 11:36:30 +00:00
\item [msgQueue*] { Rassemble toutes les fonctions servant <20> la gestion
des files de messages.}
\item [msgQueueElem*] { Les fonctions utiles pour g<> rer un <20> l<EFBFBD> ment
d'une file de messages.}
\item [msgQueue(Prot|Read)*] { Fonctions servant <20> prot<6F> ger une file
({ \em read} indique la disponibilit<69> d'une ressource en lecture,
{ \em Prot} la protection contre les modification).}
2020-03-03 22:30:21 +00:00
\end { description}
2004-02-26 11:36:30 +00:00
}
\item [msgSpace*] { Ensemble de fonctions qui g<> rent les espaces de
2020-03-03 22:30:21 +00:00
messages : cr<63> ation, ouverture, listes\ldots
\begin { description}
2004-02-26 11:36:30 +00:00
\item [msgSpace*] { Fonctions pour la cr<63> ation, ``ouverture'', ``fermeture''\dots d'un espace de messages.}
\item [msgSpaceList*] { Ce sont toutes les fonctions utiles pour la
gestion de la liste cha{ \^ i} n<EFBFBD> e des { \em msgSpace} existants.}
\item [msgSpaceListElem*] { Fonctions correspondant <20> la gestion d'un
<EFBFBD> l<EFBFBD> ment de la { \em msgSpaceList} .}
2020-03-03 22:30:21 +00:00
\end { description}
2004-02-26 11:36:30 +00:00
}
2020-03-03 22:30:21 +00:00
\end { description}
2004-02-26 11:36:30 +00:00
2020-03-03 22:30:21 +00:00
\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} .
\end { itemize}
\newpage
\section { Difficult<EFBFBD> s rencontr<74> es}
2004-02-26 11:36:30 +00:00
\subsection { Restrictions}
\par Nous n'avons pas eu de grosses difficult<6C> s <20> proprement parler.
2020-03-03 22:30:21 +00:00
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
2004-02-26 11:36:30 +00:00
seulement un segment de m<> moire partag<61> e en commun.
\par Il a donc fallu utiliser les diff<66> rentes { \em id} (c'est <20> dire les identifiants POSIX) des espaces de messages { \em msgSpace} , des { \em pools}
et autres types de donn<6E> es stock<63> es en m<> moire partag<61> e pour pouvoir permettre a tous les processus d'acc<63> der correctement aux donn<6E> es.
\subsection { Libert<EFBFBD> s d'impl<70> mentations de POSIX\ldots }
2020-03-03 22:30:21 +00:00
\par Le choix des identifiants ne fut pas simple non plus, car il
2004-02-26 11:36:30 +00:00
fallait en changer en fonction des diff<66> rentes impl<70> mentations de POSIX.
En effet la norme POSIX pr<70> cise que l'identifiant doit commencer par un ``\verb +/+'' et si possible ne pas en comporter d'autres.
\par Si cela est vrai sur certains syst<73> mes (comme GNU/Linux) d'autres
systemes (HP-UX, SunOS) requi<75> rent que cet identifiant corresponde
au chemin absolu (dans l'arborescence UNIX) d'un fichier sur lequel
on poss<73> de des droits\ldots
\par Nous avons donc choisi les identifiants du type
``\verb +/tmp/identifiant+'', qui pour les syst<73> mes avec la restrictions pr<70> c<EFBFBD> dente et ``\verb +/identifiant+'' sur les autres. i
Cela nous a <20> galement conduit <20> faire une distinction dans le \verb +Makefile+
entre les options de compilation pour { \em HP-UX} , { \em SunOS} ou { \em Linux} .
2020-03-03 22:30:21 +00:00
\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
2004-02-26 11:36:30 +00:00
compiler et fonctionner convenablement.
\par La seconde difficult<6C> li<6C> e <20> POSIX, est la projection de fichier
ou { \em mapping} avec { \em mmap} . Selon l'impl<70> mentation, l'offset (d<> calage par rapport au d<> but de l'addresse m<> moire du fichier) peut <20> ventuellement { \^ e} tre align<67> sur la taille des pages m<> moires\ldots
\par Ceci est assez g<> nant lorsque l'on veut acc<63> der <20> bloc de donn<6E> e
qui peut commencer n'importe o<> dans la zone de m<> moire partag<61> e.
Pour rem<65> dier <20> cela, nous { \em mappons} du d<> but de la zone m<> moire partag<61> e jusqu'<27> ``juste derri<72> re'' le bloc de donn<6E> e qui nous int<6E> resse.
\par Puis nous changeons les droits d'acces (\verb +mprotect+) pour nous autoriser la modifiction uniquement sur le bloc de donn<6E> es qui nous int<6E> resse.
\par Enfin nous op<6F> rons le d<> calage d'addresse ``<60> la main'' et renvoyons l'addresse qui correspond au d<> but du bloc de donn<6E> es demand<6E> .
