View difference between Paste ID: 4BU9gwWE and eNZMWf15

-/* Q4 HUE HUE (ノ ゜Д゜)ノ ︵ ┻━┻
+
-   Francois "Rondoudou" Lebeau et Gabriel "Jesus Freak" Tessier */
+
    Cette fonction est utilisée pour pour initialiser la librairie. Elle doit être
-/**************************************************************************
+
-    Travail pratique No 2 : Thread utilisateurs
+
-
+
-    Ce fichier est l'implémentation de la librarie des threads utilisateurs.
+
-
+
-	Systemes d'explotation GLO-2001
+
-	Universite Laval, Quebec, Qc, Canada.
+
-	(c) 2015 Philippe Giguere
+
- **************************************************************************/
+
-#include <stdio.h>
+
-#include <stdlib.h>
+
-#include <unistd.h>
+
-#include <string.h>
+
-#include <ucontext.h>
+
-#include <time.h>
+
-#include "ThreadUtilisateur.h"
+
   gNTCB++;
-/* Définitions privées, donc pas dans le .h, car l'utilisateur n'a pas besoin de
+
-   savoir ces détails d'implémentation. OBLIGATOIRE. */
+
-typedef enum {
+
-	THREAD_EXECUTE=0,
+
-	THREAD_PRET,
+
-	THREAD_BLOQUE,
+
-	THREAD_TERMINE
+
-} EtatThread;
+
     return 1;
-#define TAILLE_PILE 4096   // Taille de la pile utilisée pour les threads
+
     return -1;
-/* Structure de données pour créer une liste chaînée simple sur les threads qui ont fait un join.
+
-   Facultatif */
+
-typedef struct WaitList {
+
-	struct TCB *pThreadWaiting;
+
-	struct WaitList *pNext;
+
-} WaitList;
+
    	  void (*fn)(void *) : une fonction fn qui sera le code exécuté par un thread.
-/* TCB : Thread Control Block. Cette structure de données est utilisée pour stocker l'information
+
-   pour un thread. Elle permet aussi d'implémenter une liste doublement chaînée de TCB, ce qui
+
-   facilite la gestion et permet de faire un ordonnanceur tourniquet sans grand effort.
+
-   Facultatif. */
+
-typedef struct TCB {  // Important d'avoir le nom TCB ici, sinon le compilateur se plaint.
+
-	tid                 id;        // Numero du thread
+
-	EtatThread			etat;      // Etat du thread
+
-	ucontext_t          ctx;       // Endroit où stocker le contexte du thread
+
-	struct TCB         *pSuivant;   // Liste doublement chaînée
+
-	struct TCB         *pPrecedant; // Liste doublement chaînée
+
-	struct WaitList	   *pWaitListJoinedThreads; // Liste chaînée simple des threads en attente.
+
-  	int					waitingCount;
+
-} TCB;
+
   thread->pWaitListJoinedThreads = malloc(sizeof(WaitList));
 
   thread->id = gNextTID;
 
   gNextTID++;
-// Pour que les variables soient cachées à l'utilisateur, on va les déclarer static. Facultatif.
+
-static TCB *gpThreadCourant;	    //Thread en cours d'execution
+
-static int gNTCB = 0;
+
-static int gNextTID = 100;
+
   getcontext(&thread->ctx);
   thread->ctx.uc_stack.ss_sp = malloc(TAILLE_PILE);
-/* Cette fonction insère le TCB pToInsert dans la liste doublement chaînée, juste après
+
-   pActual. */
+
-int InsertTCBAfter(TCB *pActual, TCB *pToInsert) {
+
-    // Mettre à jour le TCB précédent
+
-	TCB *pNext = pActual->pSuivant; // pNext == thread 100
+
- 	pActual->pSuivant = pToInsert;
+
   else
-	// Mettre à jour le TCB inséré
+
-	pToInsert->pSuivant   = pNext; // pToInsert->pSuivant == 101
+
-	pToInsert->pPrecedant = pActual;
+
-
+
-	// Et aussi celui après
+
-	pNext->pPrecedant = pToInsert;
+
    d'ordonnacement) qui est prêt à être exécuté. L'ordonnancement se fait selon
-	// On incrémente le nombre de TCB
+
-	return ++gNTCB;
+
    états THREAD_BLOQUE ou THREAD_TERMINE. */
 void ThreadCeder(void){
-/* Cette fonction retire le TCB pActual de la liste doublement chaînée. */
+
-int RemoveTCB(TCB *pActual) {
+
-    // Mettre à jour le TCB inséré
+
- 	pActual->pSuivant->pPrecedant = pActual->pPrecedant;
+
-	pActual->pPrecedant->pSuivant = pActual->pSuivant;
+
-	// Mettre à jour le TCB inséré
+
-	pActual->pSuivant   = NULL;
+
-	pActual->pPrecedant = NULL;
+
-
+
-	// On décrémente le nombre de TCB
+
-	return --gNTCB;
+
   {
     gpThreadCourant = gpThreadCourant->pSuivant;
-/* Cette fonction retourne le TCB correspondant au ThreadID fourni. */
+
-TCB *GetPointerFromTid(tid ThreadID) {
+
-	/* On inspecte la liste circulaire pour la traduction. Pas super rapide. */
+
-	int i;
+
   swapcontext(&threadCourant->ctx, &gpThreadCourant->ctx);
-	TCB *pTCB = gpThreadCourant;
+
-	for (i=0; i< gNTCB; i++) {
+
-		if (pTCB->id == ThreadID) { return pTCB;}
+
-
+
-		pTCB = pTCB->pSuivant;
+
-
+
-	}
+
-	return NULL;
+
    		 -1 si ThreadAJoindre n'existe pas
    		 -2 si ThreadAJoindre a déjà terminé (i.e. est dans l'état THREAD_TERMINE).
-char ThreadEtat(const EtatThread etat) {
+
-  switch(etat){
+
-    case 0:
+
-    	return 'E';
+
-    case 1:
+
-    	return 'P';
+
-    case 2:
+
-    	return 'B';
+
-    case 3:
+
-    	return 'T';
+
   {
     gpThreadCourant = gpThreadCourant->pSuivant;
-/*********************** CA C'EST LE POINT H CA LÀ LÀ ************************/
+
   gpThreadCourant->etat = THREAD_BLOQUE;
   int i;
   for(i = 0; i < gpThreadCourant->waitingCount; i++)
   {
     TCBThreadAJoindre->pWaitListJoinedThreads->pThreadWaiting = TCBThreadAJoindre->pWaitListJoinedThreads->pNext->pThreadWaiting;	// On trouve un espace libre pour ajouter un thread qui attend dans la waiting list
   }
   TCBThreadAJoindre->pWaitListJoinedThreads->pThreadWaiting = gpThreadCourant;	// On dit que le thread main attend après ce thread (ThreadAJoindre)
   gpThreadCourant->waitingCount++;
   ThreadCeder();
   return 1;
 }