S3FC project page

S3FC home page

---

               

---

s3_growable_fifo_queue.h

Go to the documentation of this file.

/*
 * Stone Three Foundation Class (s3fc) provides a number of utility classes.
 * Copyright (C) 2001 by Stone Three Signal Processing (Pty) Ltd.
 *
 * Authored by Stone Three Signal Processing (Pty) Ltd.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 * 
 * Please see the file 'COPYING' in the source root directory.
 */

#ifndef S3_GROWABLE_FIFO_QUEUE_H
#define S3_GROWABLE_FIFO_QUEUE_H

#include <pthread.h>
#include <queue>
#include <cassert>

#include <s3fc/s3_fifo_base.h>
#include <s3fc/s3_macros.h>

template <typename T>
class s3_growable_fifo_queue : public s3_fifo_base<T>
{
  private:
   pthread_mutex_t mutex;

   pthread_mutexattr_t m_attr;

   pthread_cond_t cond_not_empty;

   pthread_cond_t cond_not_full;

   std::queue<T> q;

   int max_size;
   
  public:
   s3_growable_fifo_queue(int n_max_size = -1) :
      max_size(n_max_size)
   {
      pthread_mutexattr_init(&m_attr);
      pthread_mutex_init(&mutex, &m_attr);
      pthread_cond_init(&cond_not_empty, NULL);
      pthread_cond_init(&cond_not_full, NULL);
   }
   
   virtual ~s3_growable_fifo_queue()
   {
      pthread_mutexattr_destroy(&m_attr);
      pthread_mutex_destroy(&mutex);
      pthread_cond_destroy(&cond_not_empty);
      pthread_cond_destroy(&cond_not_full);
   }
   
   void push(const T& t)
   {
      // set unlock handler and lock the state
      pthread_cleanup_push(s3_fifo_base<T>::unlock_mutex, &mutex);
      pthread_mutex_lock(&mutex);
      // put assert in block as it is macro and may span several lines [rfanner]
      if (max_size !=-1)
      {
    assert((int)q.size() <= max_size);
      }
      while ((int)q.size() == max_size)
      {
    // Queue is full, so wait for the signal.
    pthread_cond_wait(&cond_not_full,&mutex);
      }
      pthread_cond_signal(&cond_not_empty);
      // If we blocked on queue full, the queue will be full after this.
      q.push(t); 
      s3_fifo_base<T>::notify_consumers();   // let all the consumers know
      pthread_cleanup_pop(0);
      pthread_mutex_unlock(&mutex);
   }
   
   T pop()
   {
      T t;
      // set unlock handler and lock the state
      pthread_cleanup_push(s3_fifo_base<T>::unlock_mutex, &mutex);
      // We are gonna wait here until something arrives.
      pthread_mutex_lock(&mutex);
      if (max_size !=-1) assert((int)q.size() <= max_size);

      while ( q.empty() )
      {
    assert((int)q.size() == 0);
    // Release lock and wait on condition.
    pthread_cond_wait(&cond_not_empty,&mutex);
      }

      // Always signal "Not full" because it will always be true. This
      // Eliminates deadlocks caused by both consumers and producers
      // waiting on signals that will never come.
      pthread_cond_signal(&cond_not_full);
      
      t=q.front();
      assert(!q.empty());
      q.pop();
      s3_fifo_base<T>::notify_producers();   // let all the producers know
      pthread_cleanup_pop(0);
      pthread_mutex_unlock(&mutex);
      return t;
   }
   
   bool empty() const
   {
      bool res;
      pthread_mutex_lock(NONCONST_MUTEXP(&mutex));
      res = q.empty();
      pthread_mutex_unlock(NONCONST_MUTEXP(&mutex));
      return res;
   }

   bool full() const
   {
      bool res;
      pthread_mutex_lock(NONCONST_MUTEXP(&mutex));
      res = ((int)q.size() == max_size);
      pthread_mutex_unlock(NONCONST_MUTEXP(&mutex));
      return res;
   }
   
   unsigned int size() const
   {
      unsigned int s;
      pthread_mutex_lock(NONCONST_MUTEXP(&mutex));
      s = q.size();
      pthread_mutex_unlock(NONCONST_MUTEXP(&mutex));
      return s;
      
   }
   
};   

#endif

---

Send comments to: s3fc@stonethree.com