View difference between Paste ID: L5VJTqcr and wfzW5eXq

 /* ----------------------------------------------------------------------------
    Fonction int ThreadInit(void)
    Cette fonction est utilisée pour pour initialiser la librairie. Elle doit être
    appelée avant la toute première utilisation de vos threads.
    La fonction retourne:
 	    1 si tout s'est bien passé
 	   -1 si vous avez une erreur lors de l'initialisation. */
 int ThreadInit(void){
 	// Allocation
 	TCB *mainThread = malloc (sizeof (struct TCB));
 	mainThread = malloc (sizeof(tid));
 	mainThread = malloc(sizeof(EtatThread));
 	mainThread = malloc(sizeof(ucontext_t));
 	mainThread->pSuivant = malloc(sizeof(struct TCB));
 	mainThread->pPrecedant = malloc(sizeof(struct TCB));
 	mainThread = malloc(sizeof(int));
 	mainThread->pWaitListJoinedThreads = malloc(sizeof(WaitList));
 	// Initialisation
 	mainThread->id = gNextTID;
 	mainThread->etat = THREAD_EXECUTE;
  	gNextTID++;
   	gNTCB++;
   	getcontext(&mainThread->ctx);
   	mainThread->ctx.uc_stack.ss_sp = malloc(TAILLE_PILE);
   	mainThread->ctx.uc_stack.ss_size = TAILLE_PILE;
   	mainThread->pSuivant = mainThread;
   	mainThread->pPrecedant = mainThread;
   	gpThreadCourant = mainThread;
   	if(GetPointerFromTid(100) == mainThread)
   	  return 1;
   	else
   	  return -1;
 }
 
 /* ----------------------------------------------------------------------------
    Fonction tid ThreadCreer(void (*fn)(void *), void *arg)
    Cette fonction va créer un thread et le placer dans la file d'ordonnancement.
    Les entrées sont :
    	  void (*fn)(void *) : une fonction fn qui sera le code exécuté par un thread.
    	  void *arg          : un pointeur sur les données passées au thread lors du démarrage.
    La fonction retourne :
 	    le tid du thread si tout s'est bien passé
 	   -1 si il y a une erreur. */
 tid ThreadCreer(void (*fn)(void *), void *arg){
 	//Allocation
  	TCB *thread = malloc (sizeof (struct TCB));
   	thread = malloc (sizeof(tid));
   	thread = malloc(sizeof(EtatThread));
   	thread = malloc(sizeof(ucontext_t));
   	thread->pSuivant = malloc(sizeof(struct TCB));
   	thread->pPrecedant = malloc(sizeof(struct TCB));
   	thread = malloc(sizeof(int));
   	thread->pWaitListJoinedThreads = malloc(sizeof(WaitList));
 	// Initialisation
   	thread->id = gNextTID;
  	gNextTID++;
   	thread->waitingCount = 0;
   	thread->etat = THREAD_PRET;
 	thread->pSuivant = thread;
 	thread->pPrecedant = thread;
   	getcontext(&thread->ctx);
   	thread->ctx.uc_stack.ss_sp = malloc(TAILLE_PILE);
   	thread->ctx.uc_stack.ss_size = TAILLE_PILE;
   	makecontext(&thread->ctx, (void *)&fn, 1, arg);
   	InsertTCBAfter(gpThreadCourant, thread);
   	gpThreadCourant = thread;
   	if(GetPointerFromTid(thread->id) == thread)
   	  return thread->id;
   	else
   	  return -1;
 }
 
 /* ----------------------------------------------------------------------------
    Fonction void ThreadCeder(void)
    Cette fonction va faire passer le fil d'exécution au prochain thread (dans la file
    d'ordonnacement) qui est prêt à être exécuté. L'ordonnancement se fait selon
    l'algorithme du tourniquet. Il faut que le prochain thread à exécuter soit dans
    l'état THREAD_PRET. Il faut donc sauter tous les threads qui sont dans les
    états THREAD_BLOQUE ou THREAD_TERMINE. */
 void ThreadCeder(void){
   TCB *threadCourant = gpThreadCourant;
   printf("ThreadCeder():\n");
   while(gpThreadCourant->pSuivant != threadCourant)
   {
     printf("ThreadID:%d\tÉtat:%c\n", ThreadId(), ThreadEtat(gpThreadCourant->etat) );
     gpThreadCourant = gpThreadCourant->pSuivant;
   }
   printf("ThreadID:%d\tÉtat:%c\n", ThreadId(), ThreadEtat(gpThreadCourant->etat) );
   gpThreadCourant = gpThreadCourant->pSuivant;
   threadCourant = gpThreadCourant;
   while(gpThreadCourant->pSuivant->etat == THREAD_BLOQUE || gpThreadCourant->pSuivant->etat == THREAD_TERMINE)
   {
     gpThreadCourant = gpThreadCourant->pSuivant;
   }
   gpThreadCourant->pSuivant->etat = THREAD_EXECUTE;
-  gpThreadCourant->etat = THREAD_EXECUTE;
+
 
   swapcontext(&threadCourant->ctx, &gpThreadCourant->ctx);
 }
 /* ----------------------------------------------------------------------------
    Fonction int ThreadJoindre(tid ThreadAJoindre)
    Cette fonction va joindre le thread en cours à l'exécution du thread ThreadAJoindre.
    Cela signifie que a) le thread qui appelle cette fonction bloquera en passant à
    l'état THREAD_BLOQUE b) lorsque le thread ThreadAJoindre quitte, il devra "réveiller"
    le thread appelant. Cette fonction devra invoquer ultimement la fonction ThreadCeder()
    pour faire exécuter un autre thread. La fonction retourne :
    		 -1 si ThreadAJoindre n'existe pas
    		 -2 si ThreadAJoindre a déjà terminé (i.e. est dans l'état THREAD_TERMINE).
    		  1 si tout se passe bien. */
 int ThreadJoindre(tid ThreadAJoindre){
 
   TCB *TCBThreadAJoindre = GetPointerFromTid(ThreadAJoindre);
 
   if(TCBThreadAJoindre == NULL)
     return -1;
   else if(TCBThreadAJoindre->etat == THREAD_TERMINE)
     return -2;
   while(gpThreadCourant->etat != THREAD_EXECUTE)
   {
     gpThreadCourant = gpThreadCourant->pSuivant;
   }
   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;
 }