[BACK]Return to rpl.c CVS log [TXT] [DIR] Up to [local] / rpl / src

Diff for /rpl/src/rpl.c between versions 1.83 and 1.84

version 1.83, 2011/09/14 14:34:28 version 1.84, 2011/09/14 17:56:00
Line 114  rplinit(int argc, char *argv[], unsigned Line 114  rplinit(int argc, char *argv[], unsigned
     setvbuf(stdout, NULL, _IOLBF, 0);      setvbuf(stdout, NULL, _IOLBF, 0);
     setvbuf(stderr, NULL, _IOLBF, 0);      setvbuf(stderr, NULL, _IOLBF, 0);
   
       // mutex_liste_thread est dévérouillé par défaut.
       // mutex_gestionnaires_signaux et mutex_gestionnaires_signaux_atomique
       // sont verrouillés par défaut.
   
       pthread_mutex_lock(&mutex_gestionnaires_signaux_atomique);
   
 #   ifndef SEMAPHORES_NOMMES  #   ifndef SEMAPHORES_NOMMES
     sem_init(&semaphore_liste_threads, 0, 1);  
     sem_init(&semaphore_gestionnaires_signaux, 0, 0);      sem_init(&semaphore_gestionnaires_signaux, 0, 0);
     sem_init(&semaphore_gestionnaires_signaux_atomique, 0, 1);  
 #   else  #   else
     semaphore_liste_threads = sem_init2(1, sem_liste_threads);  
     semaphore_gestionnaires_signaux = sem_init2(0, sem_gestionnaires_signaux);      semaphore_gestionnaires_signaux = sem_init2(0, sem_gestionnaires_signaux);
     semaphore_gestionnaires_signaux_atomique = sem_init2(1,      
             sem_gestionnaires_signaux_atomique);      if (semaphore_gestionnaires_signaux == SEM_FAILED)
   
     if ((semaphore_liste_threads == SEM_FAILED) ||  
             (semaphore_gestionnaires_signaux == SEM_FAILED) ||  
             (semaphore_gestionnaires_signaux_atomique == SEM_FAILED))  
     {      {
         erreur = d_es_allocation_memoire;          erreur = d_es_allocation_memoire;
   
Line 189  rplinit(int argc, char *argv[], unsigned Line 188  rplinit(int argc, char *argv[], unsigned
     (*s_etat_processus).erreur_systeme = d_es;      (*s_etat_processus).erreur_systeme = d_es;
     (*s_etat_processus).erreur_execution = d_ex;      (*s_etat_processus).erreur_execution = d_ex;
     (*s_etat_processus).compteur_violation_d_acces = 0;      (*s_etat_processus).compteur_violation_d_acces = 0;
     (*s_etat_processus).tid_courant = pthread_self();  
   
     (*s_etat_processus).rpl_home = rpl_home;      (*s_etat_processus).rpl_home = rpl_home;
   
Line 204  rplinit(int argc, char *argv[], unsigned Line 202  rplinit(int argc, char *argv[], unsigned
             &attributs_mutex);              &attributs_mutex);
     pthread_mutexattr_destroy(&attributs_mutex);      pthread_mutexattr_destroy(&attributs_mutex);
   
 #   ifndef SEMAPHORES_NOMMES      pthread_mutexattr_init(&attributs_mutex);
     sem_init(&((*s_etat_processus).semaphore_fork), 0, 0);      pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
 #   else      pthread_mutex_init(&((*s_etat_processus).mutex_fork),
     if (((*s_etat_processus).semaphore_fork = sem_init2(0, sem_fork)) ==              &attributs_mutex);
             SEM_FAILED)      pthread_mutexattr_destroy(&attributs_mutex);
     {      pthread_mutex_lock(&((*s_etat_processus).mutex_fork));
         if ((*s_etat_processus).langue == 'F')  
         {  
             uprintf("+++Système : Mémoire insuffisante\n");  
         }  
         else  
         {  
             uprintf("+++System : Not enough memory\n");  
         }  
   
         return(EXIT_FAILURE);  
     }  
 #   endif  
   
     pthread_mutexattr_init(&attributs_mutex);      pthread_mutexattr_init(&attributs_mutex);
     pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);      pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
Line 334  rplinit(int argc, char *argv[], unsigned Line 320  rplinit(int argc, char *argv[], unsigned
         home = "";          home = "";
     }      }
   
     // Initialisation d'une clef  
   
     if (pthread_key_create(&semaphore_fork_processus_courant, NULL) != 0)  
     {  
         if ((*s_etat_processus).langue == 'F')  
         {  
             printf("+++Système : Mémoire insuffisante\n");  
         }  
         else  
         {  
             printf("+++System : Not enough memory\n");  
         }  
   
         return(EXIT_FAILURE);  
     }  
   
 #   ifndef SEMAPHORES_NOMMES  
     if (pthread_setspecific(semaphore_fork_processus_courant,  
             &((*s_etat_processus).semaphore_fork)) != 0)  
 #   else  
     if (pthread_setspecific(semaphore_fork_processus_courant,  
             (*s_etat_processus).semaphore_fork) != 0)  
 #   endif  
     {  
         if ((*s_etat_processus).langue == 'F')  
         {  
             printf("+++Système : Mémoire insuffisante\n");  
         }  
         else  
         {  
             printf("+++System : Not enough memory\n");  
         }  
   
         return(EXIT_FAILURE);  
     }  
   
     // Initialisation d'une pile de signal pour récupérer les      // Initialisation d'une pile de signal pour récupérer les
     // débordement de pile      // débordement de pile
   
Line 3530  rplinit(int argc, char *argv[], unsigned Line 3480  rplinit(int argc, char *argv[], unsigned
     pthread_mutex_destroy(&((*s_etat_processus).mutex));      pthread_mutex_destroy(&((*s_etat_processus).mutex));
     pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation));      pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation));
   
 #   ifndef SEMAPHORES_NOMMES      pthread_mutex_unlock(&((*s_etat_processus).mutex_fork));
     sem_post(&((*s_etat_processus).semaphore_fork));      pthread_mutex_destroy(&((*s_etat_processus).mutex_fork));
     sem_destroy(&((*s_etat_processus).semaphore_fork));  
 #   else  
     sem_post((*s_etat_processus).semaphore_fork);  
     sem_destroy2((*s_etat_processus).semaphore_fork, sem_fork);  
 #   endif  
   
     free((*s_etat_processus).localisation);      free((*s_etat_processus).localisation);
   
 #   ifndef SEMAPHORES_NOMMES      pthread_mutex_destroy(&mutex_liste_threads);
     sem_destroy(&semaphore_liste_threads);      pthread_mutex_destroy(&mutex_gestionnaires_signaux_atomique);
 #   else  
     sem_destroy2(semaphore_liste_threads, sem_liste_threads);  
 #   endif  
 #   ifndef SEMAPHORES_NOMMES  #   ifndef SEMAPHORES_NOMMES
     sem_post(&semaphore_gestionnaires_signaux);      sem_post(&semaphore_gestionnaires_signaux);
     sem_destroy(&semaphore_gestionnaires_signaux);      sem_destroy(&semaphore_gestionnaires_signaux);
     sem_destroy(&semaphore_gestionnaires_signaux_atomique);  
 #   else  #   else
     sem_post(semaphore_gestionnaires_signaux);      sem_post(semaphore_gestionnaires_signaux);
     sem_destroy2(semaphore_gestionnaires_signaux, sem_gestionnaires_signaux);      sem_destroy2(semaphore_gestionnaires_signaux, sem_gestionnaires_signaux);
     sem_destroy2(semaphore_gestionnaires_signaux_atomique,  
             sem_gestionnaires_signaux_atomique);  
 #   endif  #   endif
   
     destruction_queue_signaux(s_etat_processus);      destruction_queue_signaux(s_etat_processus);
Removed from v.1.83  
changed lines
  Added in v.1.84

CVSweb interface <joel.bertrand@systella.fr>