IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C Discussion :

pthread_cond_wait & while


Sujet :

C

  1. #1
    Futur Membre du Club
    Profil pro
    Inscrit en
    Novembre 2010
    Messages
    27
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Novembre 2010
    Messages : 27
    Points : 8
    Points
    8
    Par défaut pthread_cond_wait & while
    Salut a tous,


    J'implemente une FIFO en c et j'ai un souci au niveau de la fonction enqueue qui est sensee ajouter un nouvel elemnt a la queue, je ne sais pas comment suspendre le thread appelant tant que la taille restante est insuffisante pour ajouter l'element a la file...

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    
    struct queue {
     
      pthread_mutex_t mutex;
      pthread_cond_t cond;
      size_t size_max;
      size_t total_size;
      struct list *list;
    
    };
    
    struct list {
      void * elt;
      size_t elt_size;
      struct list* next;
    
    };
    
    int enqueue(struct queue *q,const void *buf,size_t size, int blocking) {
      size_t taille;
      struct list* tmp;
      pthread_mutex_lock(&q->mutex);
      taille=q->size_max-q->total_size;
    
      if(blocking == 0){
        if (taille == 0 || taille < size ){
          errno = EAGAIN;
          pthread_mutex_unlock(&q->mutex);  
          return -1;
        }
      }else {
        
        pthread_cond_wait(&q->cond,&q->mutex); c'est la que je bloque,comment dire
    que tant que taille (restante dans la file)< size(taille de l'element), il faut attendre ?
      }		
    
      if (q->list->elt == NULL) {
       
        q->list->elt = malloc(size);
        memcpy(q->list->elt,buf,size); 
        q->list->elt_size = size;
        q->list->next = NULL;
        pthread_cond_signal(&q->cond);//Je signale que la file possede maintenant un element pour que dequeue puisse etre appelee
      } else {
        tmp=q->list;
        while (tmp->next != NULL) {
          tmp=tmp->next;
        }
        tmp->next = malloc(sizeof(struct list));
        tmp->next->elt = malloc(size);
        memcpy(tmp->next->elt,buf,size);   	
        tmp->next->elt_size=size;
      	
      }
    
      q->total_size+=size;
      pthread_mutex_unlock(&q->mutex);
      return 1;
    }
    
    int dequeue(struct queue *q,void *buf,size_t size, int blocking){
    
      struct list* tmp;
      pthread_mutex_lock(&q->mutex);
    
      if(blocking==0){  
        if (q->total_size == 0){
          errno = EAGAIN;
          pthread_mutex_unlock(&q->mutex);
          return -1;
        }else if (size < q->list->elt_size){
          errno=EMSGSIZE;
          pthread_mutex_unlock(&q->mutex);
          return -1;
        }
      }else{
        pthread_cond_wait(&q->cond,&q->mutex);
      }		
      memcpy(buf,q->list->elt,size);
      tmp=q->list;
      if(q->list->next != NULL){
        q->list=q->list->next;
        free(tmp->elt);
        free(tmp);
      }else{
        free(q->list->elt);
        free(q->list);
        q->list=malloc(sizeof(struct list));
        q->list->elt=NULL;
      }
      q->total_size-=size;
      pthread_mutex_unlock(&q->mutex);
      return size;
    }

    merci davance

  2. #2
    Nouveau membre du Club
    Homme Profil pro
    autre
    Inscrit en
    Décembre 2012
    Messages
    22
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : autre
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Décembre 2012
    Messages : 22
    Points : 26
    Points
    26
    Par défaut
    Salut,

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    if(blocking == 0){
        if (taille == 0 || taille < size ){
          errno = EAGAIN;
          pthread_mutex_unlock(&q->mutex);  
          return -1;
        }
      }else {
     
        pthread_cond_wait(&q->cond,&q->mutex); c'est la que je bloque,comment dire
    que tant que taille (restante dans la file)< size(taille de l'element), il faut attendre ?
      }
    Tu mets if (taille == 0 || taille < size ), on unlock et on return.
    Ce que tu cherches à faire, c'est plutôt tant que taille < size on rééssaye, non ?

    Tu veux faire ça ? :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    Tant que get(taille) < size
    {
    On sleep un peu de temps pour éviter de surcharger le processeur;
    }
    A ce que je sache, il n'y a pas de moyen de faire un callback ou un truc du genre ici (ou une fonction bloquante qui return que quand c'est ok)

Discussions similaires

  1. [CR8.5] Pbm d'affichage dans un While
    Par .:Tieri:. dans le forum SAP Crystal Reports
    Réponses: 1
    Dernier message: 14/07/2004, 11h17
  2. Réponses: 2
    Dernier message: 05/02/2004, 14h58
  3. [débutant]Documentation? boucle "while"? Session?
    Par o151181 dans le forum Servlets/JSP
    Réponses: 2
    Dernier message: 19/01/2004, 16h20
  4. Réponses: 3
    Dernier message: 25/11/2002, 15h15

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo