fix from 3.1 first commit

fujuntang

2021-08-11 68d23225a38a35f1325eb39fa4ed5a005d5de473

 src/shm/hashtable.cpp

old mode 100755
new mode 100644
@@ -1,9 +1,13 @@
#include "usg_common.h"
#include "hashtable.h"
#include "mm.h"
#include "sem_util.h"
#include "svsem.h"
#include "logger_factory.h"
#include <set>
#include <functional>
#include <limits.h>



typedef struct tailq_entry_t
{
@@ -23,23 +27,17 @@

static size_t hashcode(int key);

static struct timespec TIMEOUT = {2, 0};

void hashtable_init(hashtable_t *hashtable )
{
  
  memset(hashtable, 0, sizeof(hashtable_t));
  hashtable->mutex = SemUtil::get(IPC_PRIVATE, 1);
  hashtable->wlock = SemUtil::get(IPC_PRIVATE, 1);
  hashtable->cond = SemUtil::get(IPC_PRIVATE, 1);
  hashtable->readcnt = 0;

  memset(hashtable, 0, sizeof(hashtable_t));
  hashtable->mutex = svsem_get(IPC_PRIVATE, 1);
  hashtable->queueCount = 0;
  hashtable->currentKey = START_KEY;
}

void hashtable_destroy(hashtable_t *hashtable) {
  SemUtil::remove( hashtable->mutex);
  SemUtil::remove( hashtable->wlock);
  SemUtil::remove( hashtable->cond);
  svsem_remove( hashtable->mutex);
}


@@ -102,16 +100,19 @@
  size_t code = hashcode(key);
  tailq_entry_t *item;
  void *oldvalue;
  int rv;

  SemUtil::dec(hashtable->wlock);
  if( (rv = svsem_wait(hashtable->mutex)) != 0) {
    LoggerFactory::getLogger()->error(errno, "hashtable_remove\n");
  }
  tailq_header_t *my_tailq_head = hashtable->array[code] ;
  if ( my_tailq_head == NULL)
  {
    SemUtil::inc(hashtable->wlock);
    if((rv = svsem_post(hashtable->mutex)) != 0) {
      LoggerFactory::getLogger()->error(errno, "hashtable_remove\n");
    }
    return NULL;
  }
  else
  {
  } else {
    for (item = TAILQ_FIRST(my_tailq_head); item != NULL; item = TAILQ_NEXT(item, joint))
    {
      if (key == item->key)
@@ -122,127 +123,111 @@

        /* mm_free the item as we don't need it anymore. */
        mm_free(item);
        SemUtil::inc(hashtable->wlock);
        hashtable->queueCount--;
        svsem_post(hashtable->mutex);
        return oldvalue;
      }
    }
  }
  SemUtil::inc(hashtable->wlock);
  return NULL;

}





void hashtable_removeall(hashtable_t *hashtable)
{
  tailq_entry_t *item;
  SemUtil::dec(hashtable->wlock);
  for (int i = 0; i < MAPSIZE; i++)
  {
    tailq_header_t *my_tailq_head = hashtable->array[i] ;

    if (my_tailq_head == NULL )
      continue;

    while ((item = TAILQ_FIRST(my_tailq_head)) )
    {
      TAILQ_REMOVE(my_tailq_head, item, joint);
      mm_free(item);
    if((rv = svsem_post(hashtable->mutex)) != 0) {
      LoggerFactory::getLogger()->error(errno, "hashtable_remove\n");
    }
    mm_free(my_tailq_head);
    hashtable->array[i] = NULL;

    return NULL;
  }
  SemUtil::inc(hashtable->wlock);
}

/**
 * for debug
 */
void hashtable_printall(hashtable_t *hashtable)
{
  tailq_entry_t *item;
  for (int i = 0; i < MAPSIZE; i++)
  {
    tailq_header_t *my_tailq_head = hashtable->array[i] ;

    if (my_tailq_head == NULL )
      continue;

    printf("code=%d\n", i);
    TAILQ_FOREACH(item, my_tailq_head, joint)
    {
      printf("%d:%s\n", item->key, (char *)item->value);
    }
    printf("\n");
  }
}

static size_t hashcode(int key)
{
  
  return key % MAPSIZE;
  /*printf("hashfun = %ld\n", code);*/
}

void *hashtable_get(hashtable_t *hashtable, int key) {
  
   SemUtil::dec(hashtable->mutex);
   hashtable->readcnt++;
   if (hashtable->readcnt == 1) {
    //获取读写锁
    SemUtil::dec(hashtable->wlock);
// err_msg(0, "hashtable_get dec %d %d\n", --hashtable->tmp);
   }
   SemUtil::inc(hashtable->mutex);
   // ================
  int rv;

   void * res = _hashtable_get(hashtable, key);
  if((rv = svsem_wait(hashtable->mutex)) != 0) {
    LoggerFactory::getLogger()->error(errno, "hashtable_get\n");
  }
  void * res = _hashtable_get(hashtable, key);

   // ==================

   SemUtil::dec(hashtable->mutex);
   hashtable->readcnt--;
   if(hashtable->readcnt == 0) {
    //释放读写锁
    SemUtil::inc(hashtable->wlock);
// err_msg(0, "hashtable_get inc %d\n", ++hashtable->tmp);
  //通知写
    SemUtil::set(hashtable->cond, 1);
   }
   SemUtil::inc(hashtable->mutex);
   return res;
  if((rv = svsem_post(hashtable->mutex)) != 0) {
    LoggerFactory::getLogger()->error(errno, "hashtable_get\n");
  }
  return res;
}

void hashtable_put(hashtable_t *hashtable, int key, void *value) {
   
  SemUtil::dec(hashtable->mutex);
  // 设置读优先级高
  while (hashtable->readcnt > 0)
  {
    SemUtil::set(hashtable->cond, 0);
    SemUtil::inc(hashtable->mutex);
    //等待写通知
    SemUtil::dec(hashtable->cond);
  int rv;

    SemUtil::dec(hashtable->mutex);
  if((rv = svsem_wait(hashtable->mutex)) != 0) {
    LoggerFactory::getLogger()->error(errno, "hashtable_put\n");
  }
  SemUtil::inc(hashtable->mutex);
  _hashtable_put(hashtable, key, value); 
  hashtable->queueCount++;

  //获取读写锁
  SemUtil::dec(hashtable->wlock);
 // err_msg(0, "hashtable_put dec %d\n", --hashtable->tmp);
  if((rv = svsem_post(hashtable->mutex)) != 0) {
    LoggerFactory::getLogger()->error(errno, "hashtable_put\n");
  }

}

bool hashtable_check_put(hashtable_t *hashtable, int key, void *value, bool overwrite) {

  int rv;
  void * val;
  if(( rv = svsem_wait(hashtable->mutex)) != 0) {
    LoggerFactory::getLogger()->error(errno, "hashtable_put\n");
  }
  if(overwrite) {
    _hashtable_put(hashtable, key, value);
    goto suc;
  }
  val = _hashtable_get(hashtable, key);
  // val = 1是allockey的情况
  if(val != NULL && val != (void *)1) 
    goto fail;

  _hashtable_put(hashtable, key, value);

  //释放读写锁
  SemUtil::inc(hashtable->wlock);
// err_msg(0, "hashtable_put inc %d\n", ++hashtable->tmp);
suc:
  if(( rv = svsem_post(hashtable->mutex)) != 0) {
    LoggerFactory::getLogger()->error(errno, "hashtable_put\n");
  }
  return true;

fail:
  if(( rv = svsem_post(hashtable->mutex)) != 0) {
    LoggerFactory::getLogger()->error(errno, "hashtable_put\n");
  }
  return false;
}

int hashtable_get_queue_count(hashtable_t *hashtable) {
  return hashtable->queueCount;
}

int hashtable_alloc_key(hashtable_t *hashtable) {
  int rv;
  int key = hashtable->currentKey;
 
  if( key == INT_MAX || key < START_KEY) {
    key = START_KEY;
  }

  rv = svsem_wait(hashtable->mutex);
  if(rv != 0) {
    LoggerFactory::getLogger()->error(errno, "hashtable_alloc_key\n");
  }

  while(_hashtable_get(hashtable, key) != NULL) {
    key++;
  }
  // 占用key
  _hashtable_put(hashtable, key, (void *)1);

  hashtable->currentKey = key;
  rv = svsem_post(hashtable->mutex);
  if(rv != 0) {
    LoggerFactory::getLogger()->error(errno, "hashtable_alloc_key\n");
  }

  return key;
}

static inline void _hashtable_foreach(hashtable_t *hashtable, std::function<void(int, void *)>  cb) {
  tailq_entry_t *item;
@@ -261,29 +246,7 @@


void hashtable_foreach(hashtable_t *hashtable,  std::function<void(int, void *)>  cb) {
   SemUtil::dec(hashtable->mutex);
   hashtable->readcnt++;
   if (hashtable->readcnt == 1) {
    //获取读写锁
    SemUtil::dec(hashtable->wlock);
   }
   SemUtil::inc(hashtable->mutex);

   // ==================

    _hashtable_foreach(hashtable, cb);

   // ==================

   SemUtil::dec(hashtable->mutex);
   hashtable->readcnt--;
   if(hashtable->readcnt == 0) {
    //释放读写锁
    SemUtil::inc(hashtable->wlock);
  //通知写
    SemUtil::set(hashtable->cond, 1);
   }
   SemUtil::inc(hashtable->mutex);
 return _hashtable_foreach(hashtable, cb);

}

@@ -305,18 +268,60 @@
  return keyset;
}


int hashtable_alloc_key(hashtable_t *hashtable) {
  int key = START_KEY;
  SemUtil::dec(hashtable->wlock);

  while(_hashtable_get(hashtable, key) != NULL) {
    key++;
void hashtable_removeall(hashtable_t *hashtable)
{
  tailq_entry_t *item;
  int rv;
  if( (rv = svsem_wait(hashtable->mutex)) != 0) {
    LoggerFactory::getLogger()->error(errno, "hashtable_removeall\n");
  }
  // 占用key
  _hashtable_put(hashtable, key, (void *)1);
  for (int i = 0; i < MAPSIZE; i++)
  {
    tailq_header_t *my_tailq_head = hashtable->array[i] ;

  SemUtil::inc(hashtable->wlock);
// err_msg(0, "hashtable_alloc_key inc %d\n", ++hashtable->tmp);
  return key;
    if (my_tailq_head == NULL )
      continue;

    while ((item = TAILQ_FIRST(my_tailq_head)) )
    {
      TAILQ_REMOVE(my_tailq_head, item, joint);
      mm_free(item);
    }
    mm_free(my_tailq_head);
    hashtable->array[i] = NULL;
  }

  hashtable->queueCount = 0;
  if((rv = svsem_post(hashtable->mutex)) != 0) {
    LoggerFactory::getLogger()->error(errno, "hashtable_removeall\n");
  }
}


static size_t hashcode(int key)
{

  return key % MAPSIZE;
}

/**
 * for debug
 */
static void hashtable_printall(hashtable_t *hashtable)
{
  tailq_entry_t *item;
  for (int i = 0; i < MAPSIZE; i++)
  {
    tailq_header_t *my_tailq_head = hashtable->array[i] ;

    if (my_tailq_head == NULL )
      continue;

    printf("code=%d\n", i);
    TAILQ_FOREACH(item, my_tailq_head, joint)
    {
      printf("%d:%s\n", item->key, (char *)item->value);
    }
    printf("\n");
  }
}