---

Implantation des threads
[Implémentation de FRED]

Composants
struct	FredThreadDesc
	Descripteur de threads. Plus de détails...
Définitions des types
typedef FredThreadDesc	FredThreadDesc
	Descripteur de threads.
Fonctions
void *	leonCode (void *x)
	Le code du nettoyeur leon.
void	LeonInit ()
	Initialisation de leon le nettoyeur.
void *	watchDogCode (void *x)
	Le code du chien de garde watchdog.
void	WatchDogInit ()
	Initialisation du chien de garde watchdog.
void	QuantumHandler (int i)
	Traitement d'interruption de fin de quantum.
void	TimeSharingInit (long int uS)
	Initialisation du temps partagé.
void	FredThreadHarness ()
	Code initial des threads.
void	MainThreadInit ()
	Initialisation du pseudo thread principal.
Variables
int volatile	nbFredThreads
	Compteur du nombre de threads créés non terminés.
FredThread	current
	Le thread actif.
FredQueue	readyQ
	File d'attente des threads prêts.
FredQueue	deadQ
	File d'attente des threads morts dont la pile est à libérer (réservée à leon le nettoyeur) Un thread terminant s'inscrit dans cette file et réveille leon s'il n'est pas déja réveillé ( cf leonCode() ).
FredThread	leon
	Le nettoyeur leon.
FredQueue	leonQ
	File d'attente de leon.
FredQueue	endQ
	File d'attente de terminaison (réservée au mainThread ).
FredThreadDesc	mainThreadBlock
	Descripeur du thread associé à la procédure main().
FredThread	watchdog
	Thread chien de garde.
long int	quantum
	Valeur du quantum en microseconde.

---

Documentation du type

typedef struct FredThreadDesc FredThreadDesc

Le champ FredThreadDesc::err est la sauvegarde de la variable globale errno qui contient le code d'erreur du programme. On la sauve et la restaure à chaque commutation de thread.

---

Documentation de la fonction

void FredThreadHarness (    )

Comme on ne peut retourner de façon normale de la procédure initiale d'un thread et comme le retour de celle-ci est le retour standard généré par le compilateur C, on utilise une procédure qui encadre (harnache) le démarrage et la fin d'un thread. Implantation Ce harnais appelle la procédure initiale du thread, récupére son résultat et délégue à leon la libération de la pile sans oublier les masquages et décomptages nécessaires. {/* on démarre masqué */ FredThread old; /* lancer le décomptage */ FredCountDownStart(quantum); /* démasquage */ FredMaskOff(); /* appel de la procédure initiale avec ou sans récupération dec résultat */ if(current->resref){ /* on attend un résultat */ *(current->resref)=current->entry(current->val); }else{ current->entry(current->val); } /* arrêt décomptage */ FredCountDownStop(); /* début exclusion mutuelle */ FredMaskOn(); /* réveil de leon */ FredThreadWakeUp(&leonQ); /* un thread ne peut libérer la mémoire dans laquelle il s'exécute. Il délègue cela a leon en s'inscrivant dans la file des threads défunts */ FredThreadSuspend(&deadQ); /* on ne revient jamais la */ FredAbort(" erreur fatale dans threadHarness"); }

void* leonCode (  void *    x )

Il est en charge de la libération de mémoire des threads morts et de la détection de terminaison. Implantation leon attend qu'un thread mourant le réveille dans sa file d'attente spécifique leonQ . Il trouve les threads décédés dans la file deadQ et libère la mémoire. Il décrémente le compte de threads nbFredThreads et détecte la terminaison. Dans ce cas, il réveille le thread principal si nécessaire. { FredThread t; while(1){ FredMaskOn();/* début d'exclusion mutuelle */ /* libérer la mémoire des threads défunts */ while((t=FredQueueGetFirst(&deadQ))){ free(t->stack);free(t); nbFredThreads--; } /* si terminaison, on réveille le thread l'attendant */ if(nbFredThreads==2)FredThreadWakeUp(&endQ); /* leon attend de nouveaux décès */ FredThreadSuspend(&leonQ); FredMaskOff(); } /* on ne revient jamais la */ FredAbort(" erreur fatale dans leon"); }

void LeonInit (    )

Implantation On lance leon après avoir initialiser les 2 files leonQ et deadQ . { FredQueueInit(&deadQ); /* file vide */ FredQueueInit(&leonQ); /* file vide */ leon=FredThreadSpawn(20000,leonCode,(void*)0,(void**)0); }

void MainThreadInit (    )

Implantation La procédure principale main() initialise la file d'attente de terminaison, son bloc descripteur et devient le thread courant. A partir de la, elle peut utiliser l'interface FRED comme tout thread normal (synchronisation etc..). Elle peut attendre la terminaison des autres threads via la file endQ (cf. FredWaitTerminate() ). { /* file d'attente de disparition des autres threads */ FredQueueInit(&endQ); /* file vide */ /* allocation decripteur */ mainThread=&mainThreadBlock; /* thread actif */ current=mainThread; }

void QuantumHandler (  int    i )

Implantation On recycle en fin de readyQ le thread courant. On choisit le suivant qu'on relance avec un nouveau décomptage de quantum. { FredThread old; /* interruption de fin de quantum on est masqué contre l'it quantum*/ /* printf("+"); */ FredMaskOn(); /* début d'exclusion mutuelle */ current->err=errno; /* sauver errno */ old=current; FredQueuePutLast(&readyQ,current); current=FredQueueGetFirst(&readyQ); if(current!=old)FredContextSwitch(old->ctx,current->ctx); /* on reviendra ici lors de son réveil : on relance le décomptage du quantum */ FredCountDownStart(quantum); errno=current->err;/* restaurer errno */ FredMaskOff();/* fin d'exclusion mutuelle */ }

void TimeSharingInit (  long int    uS )

Implantation On initialise le quantum avec une valeur donnée et on attache le traitement d'interruption de fin de quantum au décompteur. { /* attaché à une interuption un traitant d'IT */ FredCountDownAttach(QuantumHandler); /* valeur du quantum */ quantum=uS; }

void* watchDogCode (  void *    x )

Il évite d'avoir une file readyQ vide à traiter. Implantation C'est un boucle infinie qui ne fait que passer la main à un autre thread prêt. { while(1){ FredThreadYield(); /* attraper les interruptions externes */ } /* on ne revient jamais la */ FredAbort(" erreur fatale dans chien de garde"); }

void WatchDogInit (    )

Implantation { watchdog=FredThreadSpawn(20000,watchDogCode,(void*)0,(void**)0); }

---

Documentation de la variable

FredThread current

FredQueue deadQ

FredThread leon

Comme un thread terminant ne peut libérer la pile dans laquelle il s'exécute, ce travail est assuré par un thread spécifique de nettoyage : leon . Il attend qu'un thread mourant le réveille dans une file d'attente spécifique leonQ . Il trouve les threads décédés dans la file deadQ ( cf leonCode() ) Il assure aussi la détection de terminaison.

int volatile nbFredThreads

Seuls les threads créés par FredThreadSpawn() sont comptés. Ce compteur sert à détecter la terminaison du programme FRED (cf FredWaitTerminate() ).

FredQueue readyQ

Elle n'est jamais vide du fait de l'existence du chien de garde watchdog

FredThread watchdog

Son rôle est d'éviter une file readyQ vide. Il ne fait que passer la main. ( cf. watchDogCode() ).

---