update

wangzhengquan

2021-02-05 14c345b38d57fd814f217eb8465963a08ca79f7e

 src/queue/shm_queue.h

@@ -18,15 +18,22 @@
template <typename ELEM_T> class SHMQueue {

private:
  const int KEY;
  const int mkey;
  hashtable_t * hashtable;
  // 是否是key对应的共享队列的真正拥有者，也就是说是bind到key上的，不是attach到key上的对象
  bool owner;
  size_t mqsize;

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

  ~SHMQueue();

  void force_destroy();
  bool bind(int key, bool force) ;
  bool attach(int key);

  int get_key();

  uint32_t size();

@@ -40,8 +47,6 @@

 // @deprecate
  static size_t remove_queues_exclude(int keys[], size_t length);
  static size_t remove_queues(int keys[], size_t length);
  static size_t remove_queue(int key);

private:
protected:
@@ -56,77 +61,95 @@
};

// @deprecate
template <typename ELEM_T>
size_t SHMQueue<ELEM_T>::remove_queues_exclude(int keys[], size_t length) {
  hashtable_t *hashtable = mm_get_hashtable();
  std::set<int> *keyset = hashtable_keyset(hashtable);
  std::set<int>::iterator keyItr;
  LockFreeQueue<ELEM_T, SHM_Allocator> *mqueue;
  bool found;
  size_t count = 0;
  for (keyItr = keyset->begin(); keyItr != keyset->end(); keyItr++) {
    found = false;
    for (size_t i = 0; i < length; i++) {
      if (*keyItr == keys[i]) {
        found = true;
        break;
      }
    }
    if (!found) {
      // 销毁共享内存的queue
      mqueue = (LockFreeQueue<ELEM_T, SHM_Allocator> *)hashtable_get(hashtable, *keyItr);
      delete mqueue;
      hashtable_remove(hashtable, *keyItr);
      count++;
    }
  }
  delete keyset;
  return count;
}
// template <typename ELEM_T>
// size_t SHMQueue<ELEM_T>::remove_queues_exclude(int keys[], size_t length) {
//   hashtable_t *hashtable = mm_get_hashtable();
//   std::set<int> *keyset = hashtable_keyset(hashtable);
//   std::set<int>::iterator keyItr;
//   LockFreeQueue<ELEM_T, SHM_Allocator> *mqueue;
//   bool found;
//   size_t count = 0;
//   for (keyItr = keyset->begin(); keyItr != keyset->end(); keyItr++) {
//     found = false;
//     for (size_t i = 0; i < length; i++) {
//       if (*keyItr == keys[i]) {
//         found = true;
//         break;
//       }
//     }
//     if (!found && *keyItr > 100) {
//       // 销毁共享内存的queue
//       mqueue = (LockFreeQueue<ELEM_T, SHM_Allocator> *)hashtable_get(hashtable, *keyItr);
//       delete mqueue;
//       hashtable_remove(hashtable, *keyItr);
//       count++;
//     }
//   }
//   delete keyset;
//   return count;
// }



template <typename ELEM_T>
size_t SHMQueue<ELEM_T>::remove_queues(int keys[], size_t length) {
  hashtable_t *hashtable = mm_get_hashtable();
  LockFreeQueue<ELEM_T, SHM_Allocator> *mqueue;
  size_t count = 0;
  for(int i = 0; i< length; i++) {
    // 销毁共享内存的queue
    mqueue = (LockFreeQueue<ELEM_T, SHM_Allocator> *)mm_get_by_key(keys[i]);
    delete mqueue;
    hashtable_remove(hashtable, keys[i]);
    count++;
  }
  return count;
}
SHMQueue<ELEM_T>::SHMQueue(size_t qsize): mqsize(qsize) {

template <typename ELEM_T>
size_t SHMQueue<ELEM_T>::remove_queue(int key) {
  int keys[] = {key};
  return remove_queues(keys, 1);
}

template <typename ELEM_T>
SHMQueue<ELEM_T>::SHMQueue(int key, size_t qsize) : KEY(key) {

  hashtable_t *hashtable = mm_get_hashtable();
  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);
  }
  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");
  delete queue;
  queue = NULL;
  hashtable_t *hashtable = mm_get_hashtable();
  hashtable_remove(hashtable, KEY);
  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();
@@ -139,6 +162,7 @@
template <typename ELEM_T> bool SHMQueue<ELEM_T>::empty() {
  return queue->empty();
}


 

@@ -167,6 +191,7 @@
    return 0;
  }

 
  if(rv == ETIMEDOUT)
    return EBUS_TIMEOUT;
  else {