Publicité
+ Répondre à la discussion
Affichage des résultats 1 à 2 sur 2
  1. #1

    Profil pro Anthony
    Inscrit en
    novembre 2010
    Messages
    27
    Détails du profil
    Informations personnelles :
    Nom : Anthony

    Informations forums :
    Inscription : novembre 2010
    Messages : 27
    Points : -3
    Points
    -3

    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 :
    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 : 25
    Points
    25

    Par défaut

    Salut,

    Code :
    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 :
    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)

Liens sociaux

Règles de messages

  • Vous ne pouvez pas créer de nouvelles discussions
  • Vous ne pouvez pas envoyer des réponses
  • Vous ne pouvez pas envoyer des pièces jointes
  • Vous ne pouvez pas modifier vos messages
  •