基于共享内存多级hash设计

Feature list:

1. 支持Set/Get/Replace/Update, 优化编译下默认16级冲突下单进程下Set/Get可达170w次/s。（理论上只要不达到内容的带宽限制，而且是多核的机器下性能是随线进程数陪增）

2. 支持多程下操作(可预见低的出错概率)

3. 支持CAS弱一致性检测(需要编译时开启)

4. 支持二进制文件导出/导入

5. 支持遍历处理（回调）

6. 可以自定义最大可冲突级数/单个桶最大长度（需要重新编译库）

注意：下面版本是32位机上实现的，64位机需要做些兼容修改

提供运维工具

a) 支持Bindump/Binrestore：共享内存保存到二进制文件和从二进制文件恢复到内存(支持跨机器操作)

b) 查看当前使用率与各级桶的使用率( 未实现 ）

c) 修改为只读、只写模式( 未实现 ）

d) 支持远程恢复与同步( 未实现 ）

实现

1. 预设N个大素数（PRIMER_TABLE,目前取值是1000037~1001323,共100个，最大数为1000,000*100
= 1亿个元素，默认初始化为16级hash）

2. 第一个素数作为一个桶长度，存储hash后的value时,就是以%素数来取模

3. 存储共享内存是一个线性空间，所以要先计算好每列的偏移量

(PRIMER_TABLE_OFFSET[i] = ∑PRIMER_TABLE[i])

4. Value需要定义固定长度，不能是指针指向外一个内存块

5. Hash值计算 ( key + Factor*k )%L, Factor初设为一个素数作为hash因子，用于扩散hash 值，减少冲突发生 1
11%10（后继可以考虑更好的hash算法 ）

6. 支持char* hash( time33 hash算法)

7. 每次set都要先遍历k阶是否key存在，插入中O(k)

8. 为了确保性能，可设置共享内存块不允许换出

9. 大小限制，32位机器受单个进程的进程空间限制，最大为4G。共享内在需要映射到进程空间，考虑到进程本身也需要使用到相应的内存，所以尽量限制在2G以下

设计理念：1）尽可能高的性能 2）能够提供尽可能的多线程安全 3）数据持久化





冲突处理

a) 先从第一个桶hash,如果当前位置已设置

(第一个桶hash + maxline*factor )%1000037

b) 再向下一个桶hash，按下一个桶的大素数来取余

c) 最大可冲突次数为hash级数( 可冲突次数越多，占满率越高，但是影响性能

优点：

1.非常地快！基于共享内存可以多进程共享

2.基于一维线性空间实现可从外部copy数据备份/恢复

3.空间利用率高，可达90%

4.Set/Get在优化编译后性能高

缺点：

1. 在设定的多次hash级内都冲突的话就插入不成功，但是机率很少。但是要慎重选择hash级数（建议起始级数设定16级，下面有数据说明）

2. 由于对同一个key的取value操作不是原子的，在非常低的概率下，可能在取一个key的同时在对这个key做set，导致只取值不完整(但是需要对一个key的操作在1/170w
s内 )。除非是key很少，而且频繁访问(这种操作是建议加锁)

3. 单进程共享内在需要限制在4G(最好是2G)以内

4. Key不能为0

测试数据

（4字节的key, 12个字节value，直接rand()，成生的随机数可能不够足够精确）

测试环境：

Intel(R) Xeon(R) CPU E5405 @ 2.00GHz（4核）

16G内存DDR3,内存带宽 =(1066/8)×64×8=68224Mbit/8 ~ 8GB/s

测试期间CPU 只使用到一个核 100%

	10	16	20	32
总容量	1kw（~100M）	1.6kw(~200M)	2kw(~250M)	3.2kw(400M)
插入失败时的Rand次数	6,539,556	12,786,141	16,604,767	28,811,470
插入元素	6,529,720	12,748,311	16,540,688	28,618,666
耗时（未开-O3）	15,536,487us	49,602,499us	81,243,290us	210,149,843us
存取率（未开-O3）	~42w/s	~25.7w/s	~20w/s	~13w/s
耗时（打开-O3）	2,910,194us	7,379,382us	15,267,184us	35,694,707us
存取率（打开-O3）	~225w/s	~175w/s	~109w/s	~80w/s
利用率	0.6529	0.796655	0. 826898	0.894123
是否达上限	是	是	是	是

16级( 10次测试时间)





从测试数据可得出结论：

1） 在正式使用时要打开O3的标记编译，可以编译成一个独立库来使用

2） 使用级数越多，使用率越高，性能也随之下降

3） 由于优化编译后性能非常高，所以可以尽量使用多的冲突级，减少因冲突无法插入的情况，同时提高hash空间的使用率真

4） 初始化桶是取从1000037后素数，可以扩大桶的长度，从而减少级数

5） 默认使用16级，根据需要自己再提高使用级数，可预计处理量约为1.2kw

冲突处理

问题：不同的字符串，可能hash出同一个值

Time33的算法，大概是 100w数据，有100~150个冲突

测试：

try set times:1000000

conflict times:105

conflict rate:0.000105

不同hash算法的测试结果：

测试条件：随机 32位数，%lu-%i-%j 的形式生成字符串，100w(排除因级数不够无法插入的情况,因开启测速gprof/-g, 所以性能有很大影响 )

Hash 函数	来源	结果	说明
time33_ hash	gcc/redis	hash total size:10001108 use time: 9940793us try set times:1000000 conflict times:112 conflict rate:0.000112	最简单实现
bobjenkins_hash	memcache	hash total size:10001108 use time: 9407349us try set times:1000000 conflict times:128 conflict rate:0.000128	通过多次rot将key散列，但是从测试效果来说不太明显
blizzard_hash	网上找的一个one-way hash	hash total size:10001108 use time: 9491830us try set times:1000000 conflict times:125 conflict rate:0.000125	通过预生成一个查找表来生成hash,但是多了一层函数调用，在频率调用下反而速度有少少影响
murmur_hash	levelDB	hash total size:10001108 use time: 8885562us try set times:1000000 conflict times:120 conflict rate:0.00012	支持设置初始值可以生成多个不同的hash值，较为简洁

结论：

1. 从多个开源软件用到的hash函数抽出测试来看，对同一个字符串结果集做hash出的key冲突率都差不多（这里的冲突是指两个不同的字符串hash出同一个一样的32值）

2. 综合来说选择 murmur_hash 比较合适

3. 同样需要解决的一个问题：怎么处理两个不同的字符串hash出同一个值的情况？

解决：

1） 以同一个字符串str, 同时hash出三个值

h1 = murmur_hash( str, 0 );

h2 = murmur_hash( str, 1 );

h3 = murmur_hash( str, 2 );

2） h1 用作key的定位，计算hash要保存的位置。h2/h3作是比较值，即：对于一个key,需要满足三个hash值都一致时才认为是需要找的key

3） 对于不同的str1/str2, 如果三个值都一样发生的机率是 (150/1000000 )^3 ~ 0.000000000003375。即约为 1/30b的机率，基本可以忽略了！

多线、进程下一致性处理（未实现）

1. CAS机制：

a) 为每一个Node在Set的时候分配一个cas值（返回的Node和存储Node的cas值一样，每次要更新这个Node时要检查是否cas与取出来时一致

b) 如果打开了这项检查，需要强制传入模块带上一个unsigned int cas;字段

c) 只有在Update一个key的value时才会造成多线程冲突，只是Set/Get是不会的。单线程也不会

d) 增加步进的概念：cas每次自增每个线程都不一样，这样可以每个线程有一个确定变量，如果是由其它线程修改的一定与本线程的cas不一样

i. 每个线程/进程有一个初始化，如果有10个进程就是0
~9

ii. 每次cas值增加都是按进程数来加，step[0]
+= 10，因为每个进程的cas都不会一样

iii. 缺点是需要额外的初始化

场景：线程T1对key1、线程T2对Key1并发Get更新了Value值后想Set回去，可能会出现后一个操作覆盖前一个操作值，而且这个值是涉及到事务性的。正确是应该是T1
Set完后，T2才能取，串行化操作

=》CAS就是解决这个问题，如果发现cas值不一样了，就会Set失败，需要重取再设置（假定某时刻T1 的cas值为9，T2 的cas值为10。如果没有步进时，T1处理后cas值为10，T2再处理就认为没有改变过）

=》一般情况下都不需要这样的事务性，所以是弱线程安全的(很少概率出现，即使出现这样的冲突也不会造成很在原影响

2. 弱线程安全

a) 在多线程使用下( 为每个线程生成一个成员对象操作)。在很低的概率下，可能会出现两个不同的key，hash出同一个值，并同时操作同一个value的node位置

b) 操作系统对同一个内存位置的操作不保证是串行化的，

c) 概率计算：由于每一个桶的取模素数都不一样，所以大约出现冲突概率是1/N(默认桶长取为100w,所以出现概率为 1/100w，而我们的并发处理不可能达到这个数量级)

3. 强线程安全

a) 情景1：Write Lock

i. 为了达到强线程安全，引入加锁机制

ii. 每个Node增加一个字段char
bLock;( 可设置flag的一个位),每次在写的时候都设置为1，写完后再设置为0

iii. 当另一个线程对这个Node处理里就需要先判断是否被锁

b) 情景2：Update Lock

处理的Scale

1. 在默认16级的情况下大约能处理1.2kw的用户量，如果想提高处理能力可以

a) 扩展每个桶的长度 100w->1000kw

b) 增加级数

c) 注意系统内存量是否足够：容量*Value len。单进程共享内在需要限制在2G以内

d) 分布式处理，考虑到单机单进程受限于内存大小，所以数据一致性尽量考虑由上层处理。如多机按取模处理，每个机器只负责部分号段，或者实现一致性的算法为减少扩容影响

库级支持定时遍历处理

有一种使用场景，需要遍历Hash表里的所有元素并进行相关的操作。基本实现就是传入一个预设参数的函数指针：

初始版本：

Foreach( void (*callback)( const unsigned long _key, valueType& _value) );

但是发现，只能处理全局的一些外部变量，无法处理指定类成员。所以添加一个外部传入的param指针，使得可以传入到回调函数里处理

第二版：

Foreach( void (*callback)( const unsigned long _key, valueType& _value, void* param_out ), void* param_in );

解决了参数问题，还有一个运行时问题：如果每次遍历触发的元素较多，可能一次过处理量会很大！这里需要使用者注意，应该多加一个上次检查时间来触发。

定时扫描器功能

TimerCallBack( fn, timer_id, set_timeout, set_excute_time_interval );

a) 设置一个为定时器设定的回调函数fn与处理id timer_id, 在每个set_timeout触发时遍布所有元素，为每个超过set_excute_time_interval的Node调用一下回调函数fn

b) 每个Node需要有一个dwLastCheckTs字段

后续功能构想

2. 支持共享内存/内存/内在映射文件

3. 动态自动扩展=》rehash( redis实现 )

4. 运维工具

a) 格式化输出指定key-Value/全输出

ChsDB(Cola’s hash shm DB )基于以上版本的扩展版( 未实现 ）

理念：数据先存共享内存再同步，实现一个轻量级高速key-value 数据库

1. 支持只读、只写模式（需要由提供的运维工具修改）

2. 支持定时数据快照snapshot(写本地文件)

3. 支持主-从（多从），主-主模式的数据同步

4. 库级支持定时遍历处理（回调）

错误处理

1．Share memory get failed

1) 检查系统共享内存量设置是否足够大( 减少级数或者

2) 是否有足够内存（级数*100w*sizeof(TemplateNode) ）

3) 是未初始成每个线程一个对象（使用全局对象来操作,确保只操加载到进程空间一次）

共享内存操作

Ipcs –l 列出所有共享内存相关的信息

ipcs-m 列出本机使用的共享内存列表

ipcrm –M id 删除一个共享内存块

使用说明(附源码)

1. 初始化

1）定义存储的数据结构

struct HASH_MSG_INFO

{

unsigned int dwUin;

unsigned int dwLastCheck;

unsigned char ucFlag;

char ucResvered[7];

};

2) 生成对象

CHashShm< HASH_MSG_INFO > ht(123);

if( !ht. IsInitOK() )

return false;

(1)默认16级冲突，可自定义级数: CHashShm< HASH_MSG_INFO,32 > ht( key_t(123));

(2)设置步进：CHashShm< HASH_MSG_INFO,32,1 > ht(key_t(123));用于多线/进程下弱冲突处理

(3)使用全局变量的方式，确保只操加载到进程空间一次

2. Set/Get/Replace/Update

Set:如果Key不存在，则插入hash表，如果存在就返回失败(支持key类型为unsigned long,char*+len,string)

HASH_MSG_INFO hMsg;

hMsg.dwUin = 12345;

hMsg.dwLastCheck= 12345;

if(ht.Set( 12345, hMsg ) != HASHSHM_OK )

{…}

Else{…}

Get

HASH_MSG_INFO hMsg;

if(ht.Get( 12345, hMsg ) != HASHSHM_OK )

Replace: 如果Key不存在，则插入hash表，如果存在就替换

Update：在编译时打开CAS开关，会做线程数据检查，需要先Get。如果数据已经被修改则update失败

注：由于不支持从value查到key,所以value里最好有一个相同的key字段。如果是char/string类型的key,还需要是定长，不能是STL对象

3. 设置进程退出是detach共享内存

ht. SetBehavior(HASH_ENABLE_DETACH )

4. 遍历

//遍历hash shm中的所有在线列表

g_ht.Foreach( ProcMsgCheck, this );

ProcMsgCheck 是回调函数

void ProcMsgCheck( unsigned long key, ST_ON_STATE& value,void* param )

注意 value 直接引用共享内在的位置！！

头文件：

#ifndef _COLALIANG_HASH_SHM_H_
#define _COLALIANG_HASH_SHM_H_

//-------------------------------------------
//Cola's Hash Shm Library 1.03
//colaliang( SNG Instant Messaging Application Department )
//last update: 2012-12-27

//Makefile
//	g++ -O3 -c hash_shm.cpp
// ar cq libchs.a hash_shm.o

//Enable extra function:
//1. CAS
// -DHASH_SHM_ENABLE_CAS

//2. TIMER_CALL_BACK
//-DHASH_SHM_ENABLE_TCB

//多级hash实现解释
//
//
//					i
//PRIMER_TABLE:	2	3	5	7	11	13	17	( bucket size, using primes )
//PRIMER_TABLE_TATAL:	0	2	5	10	17	28	41	( line address begin position )
//
//1. 冲突解决:通过检查 ( _key + lines*factor ) % PRIMER_TABLE[i]; 的位置是否已经设置, 否则检查下一个位置
//2. hash 多级取模, 通过计算素数来尽量散列
//3. lines 指定了最多的可能冲突次数
//4. maxline 确定共享内级的冲突最大级数
//5.初始化时需要指定 valueType, 元素固定长度, 不能为stl

//------------------------------------------

#include<iostream>
#include<cstdlib>
#include<cmath>
#include<sys/shm.h>

#include<fstream>
#include<vector>
#include<string>
using  std::cout;
using  std::cerr;
using  std::string;
using  std::vector;
using  std::ifstream;
using  std::ofstream;
using  std::ios;

extern const int PRIMER_TABLE_LEN;
extern const int PRIMER_TABLE[ ] ;

enum HASH_RETURN_CODE
{
HASHSHM_OK = 0,
HASHSHM_KEYEXIST,
HASHSHM_ERROR,
HASHSHM_NOTFOUND,
HASHSHM_INSERTERROR,
HASHSHM_OUTOFMEM,
HASHSHM_UPDATE_ERROR,
};

enum HASH_STATUS
{
HASH_STATUS_NORMAL			= 0x1,
HASH_STATUS_WRITE_ONLY	= 0x2,
HASH_STATUS_READ_ONLY		= 0x4
};

enum HASH_ENABLE_FLAG
{
HASH_ENABLE_NONE = 0x0,
HASH_ENABLE_DETACH = 0x1,		//detach from shm, when all process detach,the shm will release

};

//max conflict time, max items = MAX_LINES * BaseBucketLen ( default 100w )
const int MAX_LINES = 32;

//hash factor, use for better hash distrubition
const int FACTOR = 5381;

//use for thread magic id
const int THREAD_STEP = 1;

//string hash time33
unsigned long hash_time33(char const *str, int len =-1 );

template< typename valueType, int lines = MAX_LINES, int thread_step = THREAD_STEP >
class CHashShm
{
public:

CHashShm():bInitOk(false){};
virtual ~CHashShm();

//init with the share memory key,it will get share memory
//if fail,exit
bool Init( key_t shm_key );

public:
//set node into shm
//	1) if the _key exists,return HASHSHM_KEYEXIST
//	2) if set success,return HASHSHM_OK
//	3) if fail return HASHSHM_ERROR
int Set( const unsigned long _key ,const valueType &_value);
int Set( const char* skey, const int len ,const valueType &_value );
int Set( const string& strkey ,const valueType &_value );

//get node from shm
int Get( const unsigned long _key,  valueType& _value );
int Get( const char* skey, const int len, valueType& _value );
int Get(  const string& strkey , valueType &_value );

int Replace( const unsigned long _key ,const valueType& _value );
int Replace( const char* skey, const int len,const valueType& _value );
int Replace(  const string& strkey ,const valueType &_value );

//if _key not in the table,return HASHSHM_NOTFOUND, else remove the node,set the node key 0 and return HASHSHM_OK
int Remove( const unsigned long _key );
int Remove( const char* skey, const int len );
int Remove( const string& strkey );

//callback function/param for execute, param_in will be pass to callback function as param_out
void Foreach( void (*callback)( const unsigned long _key, valueType& _value, void* param_out ), void* param_in );

//remove all the data
void Clear();

//operation enable behavior
int SetBehavior( unsigned int iflag );
int UnsetBehavior( unsigned int iflag );

bool IsInitOK(){ return bInitOk; }
public:
bool BinDump( char* filename = "./chsbin" );
bool BinRestore( char* filename = "./chsbin" );

public:
//the rate of the space used
double GetFullRate() const;

//the bucket size( begin 0 )
void GetBucketSize( unsigned int index ) const ;

//get one bucket's item count
int GetBucketUseSize( unsigned int index ) const ;

unsigned long GetCurSize() { return m_hashHead->currentSize; }

unsigned long GetSize() { return maxSize; };

private:
//the start position of the share memory
//  1) the begin mem space used to storage the runtime data, reserved 16 byte
//  2) currentSize = (unsigned long *)((long)mem)
void *mem;

//current size of the table ,the pointer of the shm begin
struct hash_head{
unsigned long currentSize;
unsigned long status;
unsigned long reservered2;
unsigned long reservered3;
};
hash_head * m_hashHead;

//the size of the share memory
unsigned long memSize;

//PRIMER_TABLE_TATAL[i] is the summary of the PRIMER_TABLE when x<=i
unsigned long PRIMER_TABLE_TATAL[lines];

//the size of the table
unsigned long maxSize;

//write by the find function,record the last find place
void *lastFound;

//Init flag
bool bInitOk;

//enable operation flag
unsigned int flag;

//the node of the hash table
//	1) when key==0,the node is empty
//	2) name-value pair
struct hash_node{
unsigned long key;
valueType value;
};

private:
//if _key in the table,return HASHSHM_OK,and set lastFound the position,otherwise return HASHSHM_NOTFOUND
int find( const unsigned long _key );

//get share memory,used by the constructor
bool getShm( key_t shm_key );

//get the positon with the (row,col), map to line pos
void *getPos( const unsigned int _row,  const unsigned long _col )
{
//calculate the positon from the start
unsigned long pos =  PRIMER_TABLE_TATAL[_row] + _col;

if ( pos >= maxSize + sizeof(hash_head))
return NULL;

return (void *)((long)mem+ sizeof(hash_head) + pos*sizeof(hash_node));
}

};

template< typename vT, int lines, int thread_step >
bool CHashShm<vT,lines,thread_step>::Init( key_t shm_key )
{
if( lines > PRIMER_TABLE_LEN )
return false;

//constructor with get share memory
maxSize=0;

int i;
for(i=0;i<lines;i++)
{
//caculate the PRIMER_TABLE_TATAL
maxSize+=PRIMER_TABLE[i];
if(i!=0)
PRIMER_TABLE_TATAL[i] = PRIMER_TABLE_TATAL[i-1]+PRIMER_TABLE[i-1];
else
PRIMER_TABLE_TATAL[i]=0;
}

//extra 16byte for use
memSize=sizeof(hash_node)*maxSize + sizeof(hash_head);
if(!getShm( shm_key ))
bInitOk = false;
else
{

m_hashHead = (hash_head*)((long)mem );
m_hashHead->currentSize = 0;

//initialize as normal
m_hashHead->status = HASH_STATUS_NORMAL;

//init operation enable to default none
flag = HASH_ENABLE_NONE;

bInitOk = true;
}

return bInitOk;
}

template< typename vT, int lines, int thread_step >
CHashShm<vT,lines,thread_step>::~CHashShm()
{
//detach from share mem if HASH_ENABLE_DETACH setd. Because
if( flag& HASH_ENABLE_DETACH )
shmdt( mem );
}

template< typename vT, int lines, int thread_step >
void CHashShm<vT,lines,thread_step>::Clear()
{
memset(mem,0,memSize);
m_hashHead->currentSize=0;
}

template< typename vT, int lines, int thread_step >
bool CHashShm<vT,lines,thread_step>::getShm( key_t shm_key )
{
int shm_id=shmget(shm_key,memSize,0666);

//check if the shm exists
if( shm_id==-1 )
{
//create the shm
shm_id=shmget(shm_key,memSize,0666|IPC_CREAT);
if(shm_id==-1){
cerr<<"Share memory get failed\n";
return false;
}

//create the shm
mem=shmat(shm_id,NULL,0);

memset(mem,0,memSize);

if(int(mem)==-1){
cerr<<"shmat system call failed\n";
return false;
}
}
else
{
//exist, point to the shm
mem=shmat(shm_id,NULL,0);

if(int(mem)==-1){
cerr<<"shmat system call failed\n";
return false;
}
}

return true;
}

template< typename vT, int lines, int thread_step >
int CHashShm<vT,lines,thread_step>::find( const unsigned long _key)
{
unsigned long hash;
hash_node *pH=NULL;
for(int i=0;i<lines;i++)
{
//calculate the col position
hash = ( _key + lines * FACTOR ) % PRIMER_TABLE[i];
pH = ( hash_node *)getPos( i, hash );

//position exceed the shm size, just break
if( NULL == pH )
break;

if( pH->key == _key )
{
lastFound=pH;
return HASHSHM_OK;
}
}

return HASHSHM_NOTFOUND;
}

template< typename vT, int lines, int thread_step >
int CHashShm<vT,lines,thread_step>::Set( const unsigned long _key,const vT&_value)
{
//if the key exists
if( find(_key )== HASHSHM_OK )
return HASHSHM_KEYEXIST;

unsigned long hash;
hash_node *pH=NULL;

for(int i=0;i<lines;i++)
{
//minimize conflict using primes
// 1) firs hash pos( calculate the col position )
hash=( _key + lines * FACTOR ) % PRIMER_TABLE[i];

// 2) second hash pos( row, col )
pH=(hash_node *)getPos( i,hash );

// insert position exceed the shm size
if( NULL == pH )
return HASHSHM_OUTOFMEM;

//find the insert position,insert the value
if( pH->key== 0 )
{

pH->key = _key;
pH->value = _value;

m_hashHead->currentSize++;

return HASHSHM_OK;
}
}

//all the appropriate position filled
return HASHSHM_ERROR;
}

template< typename vT, int lines, int thread_step >
int CHashShm<vT,lines,thread_step>::Set( const char* skey, const int len, const vT &_value )
{
unsigned long ulHashKey = hash_time33( skey, len );
return Set( ulHashKey, _value );

}

template< typename vT, int lines, int thread_step >
int CHashShm<vT,lines,thread_step>::Set( const string& strkey, const vT &_value )
{
unsigned long ulHashKey = hash_time33( strkey.data(), strkey.size() );
return Set( ulHashKey, _value );

}

template< typename vT, int lines, int thread_step >
int CHashShm<vT,lines,thread_step>::Get( const unsigned long _key, vT& _value )
{
if( find( _key ) != HASHSHM_OK )
return HASHSHM_NOTFOUND;

//memset( &_value, &((hash_node*)lastFound)->value, sizeof(_value) );
//Do I need memset?( c++' bitwise copy )
_value = ((hash_node*)lastFound)->value;

return HASHSHM_OK;
}

template< typename vT, int lines, int thread_step >
int CHashShm<vT,lines,thread_step>::Get( const char* skey, const int len, vT&_value )
{
unsigned long ulHashKey = hash_time33( skey, len );
return Get( ulHashKey, _value );

}

template< typename vT, int lines, int thread_step >
int CHashShm<vT,lines,thread_step>::Get( const string& strkey, vT&_value )
{
unsigned long ulHashKey = hash_time33( strkey.data(), strkey.size() );
return Get( ulHashKey, _value );

}

template< typename vT, int lines, int thread_step >
int CHashShm<vT,lines,thread_step>::Replace( const unsigned long _key,const vT &_value)
{
//if the key exists, replace the value
if( find(_key )== HASHSHM_OK )
{
((hash_node*)lastFound)->value = _value;
return HASHSHM_OK;
}

//if not found, the find a hash place
unsigned long hash;
hash_node *pH=NULL;

for(int i=0;i<lines;i++)
{
//minimize conflict using primes
// 1) firs hash pos( calculate the col position )
hash=( _key + lines * FACTOR ) % PRIMER_TABLE[i];

// 2) second hash pos( row, col )
pH=(hash_node *)getPos( i,hash );

// insert position exceed the shm size
if( NULL == pH )
return HASHSHM_OUTOFMEM;

//find the insert position,insert the value
if( pH->key== 0 )
{
pH->key = _key;
pH->value = _value;
m_hashHead->currentSize++;
return HASHSHM_OK;
}
}

//all the appropriate position filled
return HASHSHM_ERROR;
}

template< typename vT, int lines, int thread_step >
int CHashShm<vT,lines,thread_step>::Replace( const char* skey, const int len, const vT&_value )
{
unsigned long ulHashKey = hash_time33( skey, len );
return Replace( ulHashKey, _value );

}

template< typename vT, int lines, int thread_step >
int CHashShm<vT,lines,thread_step>::Replace( const string& strkey, const vT&_value )
{
unsigned long ulHashKey = hash_time33( strkey.data(), strkey.size() );
return Replace( ulHashKey, _value );

}

template< typename vT, int lines, int thread_step >
int CHashShm<vT,lines,thread_step>::Remove( const unsigned long _key)
{
//not found
if( find(_key) != HASHSHM_OK )
return HASHSHM_NOTFOUND;

hash_node *pH=(hash_node *)lastFound;

//only set the key 0
pH->key=0;
m_hashHead->currentSize--;

return HASHSHM_OK;
}

template< typename vT, int lines, int thread_step >
int CHashShm<vT,lines,thread_step>::Remove( const char* skey, const int len )
{
unsigned long ulHashKey = hash_time33( skey, len );
return Remove( ulHashKey );

}

template< typename vT, int lines, int thread_step >
int CHashShm<vT,lines,thread_step>::Remove( const string& strkey )
{
unsigned long ulHashKey = hash_time33( strkey.data(), strkey.size() );
return Remove( ulHashKey );

}

template< typename vT, int lines, int thread_step >
void CHashShm<vT,lines,thread_step>::Foreach(void (*callback)( const unsigned long _key,vT &_value,void * param_out ), void* param_in )
{
typedef  unsigned long u_long;
u_long beg=(u_long)mem + sizeof(hash_head);
u_long end=(u_long)mem+ sizeof(hash_head) + sizeof(hash_node)*(PRIMER_TABLE[lines-1]+PRIMER_TABLE_TATAL[lines-1]);

hash_node *p=NULL;
for(u_long pos=beg;pos<end;pos+=sizeof(hash_node))
{
//directly referece the actual memory place, so value can be modify outside directly
p=(hash_node *)pos;
if(p->key!=0)
callback( p->key,p->value, param_in );
}
}

template< typename vT, int lines, int thread_step >
bool CHashShm<vT,lines,thread_step>::BinDump( char* filename)
{

ofstream os( filename, ios::out | ios::binary );
if( !os )
return false;

os.write( (char*)mem, memSize );
os.close();

return true;
}

template< typename vT, int lines, int thread_step >
bool CHashShm<vT,lines,thread_step>::BinRestore( char* filename)
{

ifstream ios( filename, ios::binary );
if( !ios )
return false;

// get length of file:
ios.seekg (0, ios::end);
unsigned long   file_length = ios.tellg();
ios.seekg (0, ios::beg);

if( file_length != memSize )
return false;

ios.read( (char*)mem, memSize );

ios.close();
return true;
}

//the rate of the space used
template< typename vT, int lines, int thread_step >
double CHashShm<vT,lines,thread_step>::GetFullRate() const
{
return double( m_hashHead->currentSize )/maxSize;
};

//the bucket size( begin 0 )
template< typename vT, int lines, int thread_step >
void CHashShm<vT,lines,thread_step>::GetBucketSize( unsigned int index ) const
{
return index>=lines?0:PRIMER_TABLE[index];
} ;

//get one bucket's item count
template< typename vT, int lines, int thread_step >
int CHashShm<vT,lines,thread_step>::GetBucketUseSize( unsigned int index )  const
{
if(  index>=lines )
return 0;

int sum = 0;
hash_node * pNode = (hash_node *)((long)mem+ sizeof(hash_head) + index*sizeof(hash_node));

for( int i=0; i<PRIMER_TABLE[index]; i++ )
{
if( pNode->key != 0 )
++sum;
}

return sum;
}

//set operation enable flag
template< typename vT, int lines, int thread_step >
int CHashShm<vT,lines,thread_step>::SetBehavior( unsigned int iflag )
{
flag |= iflag;
return flag;
}

template< typename vT, int lines, int thread_step >
int CHashShm<vT,lines,thread_step>::UnsetBehavior( unsigned int iflag )
{
flag &= ~iflag;
return flag;
}

#endif

Cpp文件：

//-------------------------------------------
//Cola's Hash Shm Library 1.03
//colaliang( SNG Instant Messaging Application Department )
//last update: 2012-12-27

#include "hash_shm.h"

const int PRIMER_TABLE_LEN = 64;
const int PRIMER_TABLE[ PRIMER_TABLE_LEN ] = {
1511,1523,1531,1543,1549,1553,1559,1567,1571,1579,1583,1597,1601,1607,1609,1613,1619,1621,1627,1637,1657,1663,1667,1669,1693,
1697,1699,1709,1721,1723,1733,1741,1747,1753,1759,1777,1783,1787,1789,1801,1811,1823,1831,1847,1861,1867,1871,1873,1877,1879,
1889,1901,1907,1913,1931,1933,1949,1951,1973,1979,1987,1993,1997,1999
};

unsigned long hash_time33(char const *str, int len  )
{
//get from php
unsigned long hash = 5381;

//variant with the hash unrolled eight times
// if len not specify, use default time33
char const *p = str;
if( len < 0 )
{
for(; *p; p++)
{
hash = hash * 33 + *p;
}

return hash;
}

#define TIME33_HASH_MIXED_CH() hash = ((hash<<5)+hash) + *p++
//use eighe alignment
for (; len >= 8; len -= 8)
{
TIME33_HASH_MIXED_CH();	// 1
TIME33_HASH_MIXED_CH(); // 2
TIME33_HASH_MIXED_CH();	// 3
TIME33_HASH_MIXED_CH(); // 4
TIME33_HASH_MIXED_CH(); // 5
TIME33_HASH_MIXED_CH(); // 6
TIME33_HASH_MIXED_CH(); // 7
TIME33_HASH_MIXED_CH(); // 8
}
switch (len)
{
case 7: TIME33_HASH_MIXED_CH();
case 6: TIME33_HASH_MIXED_CH();
case 5: TIME33_HASH_MIXED_CH();
case 4: TIME33_HASH_MIXED_CH();
case 3: TIME33_HASH_MIXED_CH();
case 2: TIME33_HASH_MIXED_CH();
case 1: TIME33_HASH_MIXED_CH(); break;
case 0: break;
}

return hash;
}