/**
|
* encapsulate lock_free_queue, populate in userspace
|
*/
|
|
#ifndef __SHM_QUEUE_H__
|
#define __SHM_QUEUE_H__
|
|
#include "hashtable.h"
|
|
#include "logger_factory.h"
|
#include "sem_util.h"
|
#include "shm_allocator.h"
|
#include "usg_common.h"
|
#include "array_lock_free_sem_queue.h"
|
#include "lock_free_queue.h"
|
#include "bus_error.h"
|
|
template <typename ELEM_T> class SHMQueue {
|
|
private:
|
const int mkey;
|
hashtable_t * hashtable;
|
// 是否是key对应的共享队列的真正拥有者，也就是说是bind到key上的，不是attach到key上的对象
|
bool owner;
|
size_t mqsize;
|
|
public:
|
/// @brief constructor of the class
|
SHMQueue(size_t qsize = 16);
|
|
~SHMQueue();
|
|
bool bind(int key, bool force) ;
|
bool attach(int key);
|
|
int get_key();
|
|
uint32_t size();
|
|
bool full();
|
bool empty();
|
|
int push(const ELEM_T &a_data, const struct timespec *timeout=NULL, int flag=0);
|
int pop(ELEM_T &a_data, const struct timespec *timeout=NULL, int flag=0);
|
|
ELEM_T &operator[](unsigned i);
|
|
|
private:
|
protected:
|
/// @brief the actual queue-> methods are forwarded into the real
|
/// implementation
|
|
LockFreeQueue<ELEM_T, SHM_Allocator> *queue;
|
|
private:
|
/// @brief disable copy constructor declaring it private
|
SHMQueue<ELEM_T>(const SHMQueue<ELEM_T> &a_src);
|
};
|
|
|
|
|
|
template <typename ELEM_T>
|
SHMQueue<ELEM_T>::SHMQueue(size_t qsize): mqsize(qsize) {
|
|
hashtable = mm_get_hashtable();
|
owner = false;
|
mkey = 0;
|
// queue = (LockFreeQueue<ELEM_T, SHM_Allocator> *)hashtable_get(hashtable, key);
|
// if (queue == NULL || (void *)queue == (void *)1) {
|
// queue = new LockFreeQueue<ELEM_T, SHM_Allocator>(qsize);
|
// hashtable_put(hashtable, key, (void *)queue);
|
// }
|
// queue->reference++;
|
// LoggerFactory::getLogger()->debug("SHMQueue constructor reference===%d", queue->reference.load());
|
}
|
|
template <typename ELEM_T> SHMQueue<ELEM_T>::~SHMQueue() {
|
LoggerFactory::getLogger()->debug("SHMQueue destroy");
|
if(owner) {
|
delete queue;
|
hashtable_remove(hashtable, mkey);
|
}
|
|
|
}
|
|
template <typename ELEM_T>
|
bool SHMQueue<ELEM_T>::bind(int key, bool force) {
|
|
|
hashtable_lock(hashtable);
|
void *tmp_ptr = hashtable_get(hashtable, key);
|
if (tmp_ptr == NULL || tmp_ptr == (void *)1 || force) {
|
queue = new LockFreeQueue<ELEM_T, SHM_Allocator>(mqsize);
|
hashtable_put(hashtable, key, (void *)queue);
|
mkey = key;
|
owner = true;
|
hashtable_unlock(hashtable);
|
return true;
|
}
|
|
hashtable_unlock(hashtable);
|
return false;
|
}
|
|
template <typename ELEM_T>
|
bool SHMQueue<ELEM_T>::attach(int key) {
|
void *tmp_ptr = hashtable_get(hashtable, key);
|
if (tmp_ptr == NULL || tmp_ptr == (void *)1) {
|
return false;
|
}
|
mkey = key;
|
queue = (LockFreeQueue<ELEM_T, SHM_Allocator> *)tmp_ptr;
|
return true;
|
}
|
|
template <typename ELEM_T> int SHMQueue<ELEM_T>::get_key() {
|
return mkey;
|
}
|
|
|
template <typename ELEM_T> uint32_t SHMQueue<ELEM_T>::size() {
|
return queue->size();
|
}
|
|
template <typename ELEM_T> bool SHMQueue<ELEM_T>::full() {
|
return queue->full();
|
}
|
|
template <typename ELEM_T> bool SHMQueue<ELEM_T>::empty() {
|
return queue->empty();
|
}
|
|
|
|
|
template <typename ELEM_T>
|
int SHMQueue<ELEM_T>::push(const ELEM_T &a_data, const struct timespec *timeout, int flag) {
|
|
|
int rv = queue->push(a_data, timeout, flag);
|
if(rv == 0) {
|
return 0;
|
}
|
if(rv == ETIMEDOUT)
|
return EBUS_TIMEOUT;
|
else {
|
LoggerFactory::getLogger()->error("LockFreeQueue push_timeout: %s", bus_strerror(rv));
|
return rv;
|
}
|
}
|
|
|
template <typename ELEM_T>
|
int SHMQueue<ELEM_T>::pop(ELEM_T &a_data, const struct timespec *timeout, int flag) {
|
|
int rv = queue->pop(a_data, timeout, flag);
|
if(rv == 0) {
|
return 0;
|
}
|
|
|
if(rv == ETIMEDOUT)
|
return EBUS_TIMEOUT;
|
else {
|
LoggerFactory::getLogger()->error("LockFreeQueue pop_timeout: %s", bus_strerror(rv));
|
return rv;
|
}
|
return rv;
|
|
}
|
|
template <typename ELEM_T>
|
ELEM_T &SHMQueue<ELEM_T>::operator[](unsigned i) {
|
return queue->operator[](i);
|
}
|
|
|
|
|
#endif
|
