Quu.h

Go to the documentation of this file.

#ifndef QUU_H
#define QUU_H

#include <pthread.h>
#include "stdinc.h"
#include <thread>
#include <mutex>
#include <condition_variable>
#include "Util.h"

using std::mutex;
using std::unique_lock;
using std::condition_variable;

namespace forest {

template<class T> class Quu {
public:                         Quu(int=10);
                                ~Quu();

                void            reset();
                void            resize(int);
                bool            empty() const;

                void            enq(T);
                T               deq();          
private:
                int             qMax;                                           

                int             count;                                          
                int             head;                                           
                int             tail;                                           

                T               *buf;                                           

                mutex mtx;                                      
                condition_variable emptyQ;      
                condition_variable fullQ;       
};

template<class T>
Quu<T>::Quu(int qMax1) {
                qMax = qMax1;
                count = head = tail = 0;
                buf = new T[qMax];
}

template<class T>
Quu<T>::~Quu() { delete [] buf; }

template<class T>
inline void Quu<T>::reset() {
                unique_lock<mutex> lck(mtx);
                count = tail = head = 0;
}

template<class T>
inline void Quu<T>::resize(int nuSiz) {
                unique_lock<mutex> lck(mtx);
                qMax = nuSiz; delete [] buf; buf = new T[qMax+1];
}

template<class T>
inline bool Quu<T>::empty() const { return count == 0; }

template<class T>
void Quu<T>::enq(T x) {
                unique_lock<mutex> lck(mtx);
                while (count == qMax) { fullQ.wait(lck); }

                buf[tail] = x;
                count++;
                tail = (tail + 1) % qMax;

                lck.unlock();
                emptyQ.notify_one();
}

template<class T> T Quu<T>::deq() {
                unique_lock<mutex> lck(mtx);
                while (count == 0) { emptyQ.wait(lck); }

                T x = buf[head];
                count--;
                head = (head + 1) % qMax;

                lck.unlock();
                fullQ.notify_one();
                return x;
}

} // ends namespace

#endif