发布我的开源cache库ccache

yangsf5

原帖由 yangsf5 于 2008-4-3 11:16 发表
还没明白的地方：
这个cache里，可以有多张哈希表。。
建多张表的用意是：可以多张表并行的处理同时要求处理的太多的结点吗？

如果是这样，那个算法是否处理了同个结点的位置唯一性？

都那么强，就没人回答我的问题吗？

converse

插入节点的时候,首先会在所在HASH表中查找节点是否已经存在,如果存在报错退出,否则进行插入操作,在函数insert_data中.

有问题,Read The Fu**ing Source, pls.

jamesr

给楼主提几个建议：
1、建议所有文件都用LF结尾
2、建议所有文件都用统一的编码：UTF－8
3、建议建一个doc文件夹内放Doxygen生成的文档

以下就是楼主没有这样做后，我自己用doxygen生成的文档图（编码实在头疼哪！）：

converse

关于这个问题,我决定以后的版本注释一律采用英文注释.

SupervisedBoy

楼主用mmap文件存储数据，应该用的是文件锁吧。文件锁支持按偏移和大小加锁的，不用每次锁住全部。

converse

之所以要采用全局锁,是因为一直没有解决这样的问题:

进程A要对hash表a进行插入操作,此时锁住hash表a,但是发现当前已经没有空闲节点,要采用淘汰算法进行淘汰,假设需要淘汰hash表b上的一个节点,此时hash表b已经被另一个进程B锁住,而进程B要进行淘汰的节点又在hash表a上,如此情况,造成死锁.

因此,现在的折中策略是对全局进行加锁,减少锁粒度属于今后的优化,暂缓.

iunknown

原帖由 converse 于 2008-4-2 11:51 发表
同时还有unlock_cache api,因为某些使用C++的用户如果使用了C++的异常处理,在调用ccache中的API时抛出异常将导致ccache没有解锁
, 以后就不能再使用了, 提供这个API是为了在抛出异常的时候用户自己释放锁

对于这个问题，在 c++ 中倒是可以通过 RAII 来处理。
RAII英文意思：Resource acquisition is initialization，资源获取即初始化。该原则或技术用于对资源的管理。其核心思想，就是在对象的生命周期中，资源总是有效。而对象结束时，资源会自动释放。

典型的实现

1. 
   
2. class MutexGuard {
   
3. public:
   
4.     MutexGuard( Lock_t * lock ) {
   
5.         mLock = lock;
   
6.         lock->lock();
   
7.     }
   
8. 
   
9.     ~MutexGuard() {
   
10.         mLock->unlock();
    
11.     }
    
12. 
    
13. private:
    
14.     Lock_t * mLock;
    
15. };
    
16. 
    
17. void Cache :: put( ... )
    
18. {
    
19.     MutexGuard guard( mLock );
    
20. 
    
21.     ..........
    
22. }
    

复制代码

[ 本帖最后由 iunknown 于 2008-4-5 20:23 编辑 ]

lysde

支持,有时间学学...

yangsf5

1. 
   
2. int find_data(const void* key, void* data, ccache_t* cache, cmpfun cmp)
   
3. {
   
4.     int hashindex = hash(key, cache), ret;
   
5.     void *nodedata;
   
6.     node_t *node;
   
7. 
   
8.     if (0 > lock(&(cache->mutex)))
   
9.     {
   
10.         return -1;
    
11.     }
    
12. 
    
13.     ret = FIND_NODE(hashindex, key, cache, cmp);
    
14. 
    
15.     if (0 <= ret)
    
16.     {
    
17.         if (NULL != data)
    
18.         {
    
19.             node = NODE(cache, ret);
    
20.             nodedata = NODE_DATA(node);
    
21.             memcpy(data, nodedata, node->datasize);
    
22.         }
    
23.         linktolrulisthead(ret, cache);
    
24.     }
    
25. 
    
26.     if (0 > unlock(&(cache->mutex)) || 0 > ret)
    
27.     {
    
28.         return -1;
    
29.     }
    
30.     return ret;
    
31. }
    

复制代码

搂住这个函数有问题。。。
在调用这个函数时，对返回值进行判断。
>=0...说明节点存在。。
但是对于－1，就不能确定了：
可以是还没判断就因为锁出错返回－1；也可以是没有这个节点返回－1(因为链表里的最后一个节点的next是－1)。
（算了，不愿回答就算了。。。）

1. 
   
2. int list_findnode(int hashindex, const void* key, ccache_t* cache, cmpfun cmp)
   
3. {
   
4.     hashitem_t *hashitem = HASH_ITEM(cache, hashindex);
   
5.     int index = hashitem->first;
   
6.     node_t *node;
   
7.     void* nodekey;
   
8. 
   
9.     while (0 <= index)
   
10.     {
    
11.         node = NODE(cache, index);
    
12.         nodekey = NODE_KEY(node);
    
13.         if (!cmp(key, nodekey))
    
14.         {
    
15.             break;
    
16.         }
    
17. 
    
18.         index = node->next;
    
19.     }
    
20. 
    
21.     return index;
    
22. }
    

复制代码

[ 本帖最后由 yangsf5 于 2009-1-5 13:06 编辑 ]

converse

新版本发布,这次最大的feature就是支持可变长key/value了,请见首页更新说明.