update

wangzhengquan

2021-01-26 0cb4f2b1acb16c1ee1bd86a40116300ea2e2cdaa

 src/queue/shm_queue.h

@@ -6,12 +6,14 @@
#define __SHM_QUEUE_H__

#include "hashtable.h"
#include "lock_free_queue.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 {

@@ -20,25 +22,21 @@

public:
  /// @brief constructor of the class
  SHMQueue(int key = 0, size_t qsize = LOCK_FREE_Q_DEFAULT_SIZE);
  SHMQueue(int key = 0, size_t qsize = 16);

  ~SHMQueue();

  void force_destroy();

  inline uint32_t size();
  uint32_t size();

  inline bool full();
  inline bool empty();
  bool full();
  bool empty();

  inline int push(const ELEM_T &a_data);
  inline int push_nowait(const ELEM_T &a_data);
  inline int push_timeout(const ELEM_T &a_data, const struct timespec *timeout);
  inline int pop(ELEM_T &a_data);
  inline int pop_nowait(ELEM_T &a_data);
  inline int pop_timeout(ELEM_T &a_data, struct timespec *timeout);
  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);

  inline ELEM_T &operator[](unsigned i);
  ELEM_T &operator[](unsigned i);

 // @deprecate
  static size_t remove_queues_exclude(int keys[], size_t length);
@@ -49,6 +47,7 @@
protected:
  /// @brief the actual queue-> methods are forwarded into the real
  ///        implementation

  LockFreeQueue<ELEM_T, SHM_Allocator> *queue;

private:
@@ -116,95 +115,75 @@
    queue = new LockFreeQueue<ELEM_T, SHM_Allocator>(qsize);
    hashtable_put(hashtable, key, (void *)queue);
  }
  queue->reference++;
  // queue->reference++;
  // LoggerFactory::getLogger()->debug("SHMQueue constructor reference===%d", queue->reference.load());
}

template <typename ELEM_T> SHMQueue<ELEM_T>::~SHMQueue() {
  if(queue == NULL) {
     // queue已经销毁
    return;
  }

  sem_wait(&(queue->mutex));
  queue->reference--;
  // LoggerFactory::getLogger()->debug("SHMQueue destructor  reference===%d",
  if (queue->reference.load() == 0) {
      delete queue;
      queue = NULL;
      hashtable_t *hashtable = mm_get_hashtable();
      hashtable_remove(hashtable, KEY);
      // 此时queue已经销毁，无需  sem_post(&(queue->mutex))
      // printf("SHMQueue destructor delete queue\n");
  } else {
      sem_post(&(queue->mutex));
  }
  
}

template <typename ELEM_T> void SHMQueue<ELEM_T>::force_destroy() {
  if(queue == NULL) {
    // queue已经销毁
    return;
  }

  SemUtil::dec(queue->mutex);
  LoggerFactory::getLogger()->debug("SHMQueue destroy");
  delete queue;
  queue = NULL;
  hashtable_t *hashtable = mm_get_hashtable();
  hashtable_remove(hashtable, KEY);
  // 此时queue已经销毁，无需 SemUtil::inc(queue->mutex)
  
}

template <typename ELEM_T> inline uint32_t SHMQueue<ELEM_T>::size() {
template <typename ELEM_T> uint32_t SHMQueue<ELEM_T>::size() {
  return queue->size();
}

template <typename ELEM_T> inline bool SHMQueue<ELEM_T>::full() {
template <typename ELEM_T> bool SHMQueue<ELEM_T>::full() {
  return queue->full();
}

template <typename ELEM_T> inline bool SHMQueue<ELEM_T>::empty() {
template <typename ELEM_T> bool SHMQueue<ELEM_T>::empty() {
  return queue->empty();
}

template <typename ELEM_T>
inline int SHMQueue<ELEM_T>::push(const ELEM_T &a_data) {
  return queue->push(a_data);
}
 

template <typename ELEM_T>
inline int SHMQueue<ELEM_T>::push_nowait(const ELEM_T &a_data) {
  return queue->push_nowait(a_data);
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>
inline int SHMQueue<ELEM_T>::push_timeout(const ELEM_T &a_data,
                                           const struct timespec *timeout) {
int SHMQueue<ELEM_T>::pop(ELEM_T &a_data, const struct timespec *timeout, int flag) {

  return queue->push_timeout(a_data, timeout);
}
  int rv = queue->pop(a_data, timeout, flag);
  if(rv == 0) {
    return 0;
  }

template <typename ELEM_T> inline int SHMQueue<ELEM_T>::pop(ELEM_T &a_data) {
  // printf("SHMQueue pop before\n");
  int rv = queue->pop(a_data);
  // printf("SHMQueue after before\n");
 
  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>
inline int SHMQueue<ELEM_T>::pop_nowait(ELEM_T &a_data) {
  return queue->pop_nowait(a_data);
}

template <typename ELEM_T>
inline int SHMQueue<ELEM_T>::pop_timeout(ELEM_T &a_data, struct timespec *timeout) {
  return queue->pop_timeout(a_data, timeout);
}

template <typename ELEM_T>
inline ELEM_T &SHMQueue<ELEM_T>::operator[](unsigned i) {
ELEM_T &SHMQueue<ELEM_T>::operator[](unsigned i) {
  return queue->operator[](i);
}




#endif