共享内存创建及哈希索引

最新推荐文章于 2022-04-24 15:11:27 发布
最新推荐文章于 2022-04-24 15:11:27 发布
阅读量233 收藏 1
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/share-ideas/p/10957284.html
版权

构建一个共享内存的资源池，用于后续的使用
创建共享内存资源池的思路：
1、申请的内存由表头数据结构（相关统计信息）和节点数据结构组成
2、内存节点之间利用索引位置串联而成一个类似双向链表的数据结构
3、每次插入节点数据时，都从可用的头节点位置获取可用节点(freeheadpos)，并从可用节点链表中去除节点数据
4、而当删除节点数据时，则将其添加到可用链表的头节点位置处
5、利用自定义索引字段来构建hash值，每个hash值对应一个map，用于保存具有同样hash值的节点。查找节点时，就先利用hash找到指定的map，再遍历map确认具体的节点
6、每个节点的数据结构利用“char node[1]”中的node来找到节点数据的指针位置，从而可读取数据值

 

// 每个节点的数据结构
struct MEMNODE
{
    int prepos; // 前一个节点的位置索引，第一个指向0
    int nextpos; // 后一个节点的位置索引，最后一个指向0
    bool isfree; //是否被使用了
    char node[1]; // 每个节点所存储数据的起始位置，node为起始位置的首地址
};
// 共享内存的表头信息
struct MEMHEAD
{
    int freeheadpos; //空闲节点的头节点索引位置，用于后续从这个地方分配节点，且为连续的分配，表示第几个节点
    int freecnt;     //可用的空闲节点数目
    int allcnt;      // 所有的节点数目
    int hashsize;    // hash桶的大小
};
// NODE为所储存的数据结构，所以每个MEMNODE的大小为：(sizeof(MEMNODE) - 1 + sizeof(NODE))
template<typename INDEX, typename NODE>
class Shm_Mapper
{
       vector<map<INDEX, int> > Index_mapper_List;    // 每个map存储一个hashvalue所对应的所有节点的索引及在内存中的位置。
       MEMHEAD *pMemHead;
       void *pMapbeg;
       bool isopen;
       int ipckey;
};

// 随着节点的申请和释放，将导致整个freeheadpos链表不再是连续的
// 通过freeheadpos变量可以找到第一个节点
int AllocNode(Shm_Mapper<INDEX, NODE>::MEMNODE* &memnode)
{
    memnode = NULL;
    
    if (pMemHead->freecnt <= 0)
    {
        return -1;
    }

    --(pMemHead->freecnt);

    memnode = Pos2Node(pMemHead->freeheadpos);
    pMemHead->freeheadpos = memnode->nextpos;

    //设置新的空闲首节点prepos为0
    if (pMemHead->freeheadpos > 0)
    {
        MEMNODE* newhead = Pos2Node(pMemHead->freeheadpos);
        newhead->prepos = 0;
    }

    //将新获取的节点清空隔离
    memnode->nextpos = 0;
    memnode->prepos = 0;
    memnode->isfree = false;

    return 0;
}

//将节点资源变为可用节点
FreeNode(Shm_Mapper<INDEX, NODE>::MEMNODE* memnode)
{
    int curpos = Node2Pos(memnode);
    if (pMemHead->freeheadpos > 0)
    {
        MEMNODE* oldhead = Pos2Node(pMemHead->freeheadpos);
        oldhead->prepos = curpos;
    }

    memnode->nextpos = pMemHead->freeheadpos;
    memnode->prepos = 0;
    memnode->isfree = true;
    memset(memnode->node, 0, sizeof(NODE));
    pMemHead->freeheadpos = curpos;
    ++(pMemHead->freecnt);

    return 0;
}

//通过索引来查询到指定的节点，只需要先利用index得到hashvalue,再将hashvalue作为索引由Index_mapper_List得到相应的map，最后利用index查找map得到节点的索引值，即可得到节点。
template<typename INDEX, typename NODE>
int Shm_Mapper<INDEX, NODE>::Open(int ipckey, int nodecnt, int hashsize)
{
    ipckey = ipckey;
    int memsize = sizeof(MEMHEAD) + MEMNODESIZE * nodecnt;
    int iShmID = 0;
    bool isfirst = false;

    if (ipckey == 0)
    {
        // 分配普通的内存
        pMapbeg = new char[memsize];

        if (NULL == pMapbeg)
        {
            return -1;
        }
        memset(pMapbeg, 0, memsize);
        pMemHead = (MEMHEAD*)pMapbeg; //得到表头的指针
    }else{
        //试图创建
        if ((iShmID = shmget(ipckey, memsize, IPC_CREAT | IPC_EXCL | 0666)) < 0)
        {
            //若已经存在,则试图连接
            if ((iShmID = shmget(ipckey, memsize, 0666)) < 0)
            {
                return -1;
            }
        }
        else
        {
            isfirst = true;
        }

        pMapbeg = shmat(iShmID, (const void*)NULL, 0);
        pMemHead = (MEMHEAD*)pMapbeg;
    }

    return InitMem(isfirst, nodecnt, hashsize);
}

//初始化共享内存的信息
template<typename INDEX, typename NODE>
int Shm_Mapper<INDEX, NODE>::InitMem(bool isfirst, int nodecnt, int hashsize)
{
    //首次创建，将贡献内存节点块全部放入空闲链表
    if (isfirst)
    {
        pMemHead->freeheadpos = 1;
        pMemHead->freecnt = nodecnt;
        pMemHead->allcnt = nodecnt;
        pMemHead->hashsize = hashsize;

        for (int i = 0; i < pMemHead->hashsize; ++i)
        {
            Index_mapper_List.push_back(map<INDEX, int>());
        }
                        
        for (int i = 1; i <= pMemHead->allcnt; ++i)
        {
            MEMNODE* memnode = Pos2Node(i);
            memnode->isfree = true;
            memnode->prepos = i - 1;
            //尾节点 nextpos置为0
            if (i == nodecnt)
            {
                memnode->nextpos = 0;
            }
            else
            {
                memnode->nextpos = i + 1;
            }
            memset(memnode->node, 0, sizeof(NODE));
        }
    }
    else//非首次创建则读取共享内存索引
    {
        for (int i = 0; i < pMemHead->hashsize; ++i)
        {
            Index_mapper_List.push_back(map<INDEX, int>());
        }
        for (int i = 1; i <= pMemHead->allcnt; ++i)
        {
            MEMNODE *memnode = Pos2Node(i);
            //处理头节点
            if (0 == memnode->prepos)
            {
                //空闲节点头节点
                if (memnode->isfree == true)
                {
                    if (pMemHead->freeheadpos != i)
                    {
                        return -1;   
                    }
                }
                else
                {
                    if (InitMapList(memnode, i) < 0)
                    {
                        return -1;
                    }
                }
            }
        }
    }

    isOpen = true;
    return 0;
}


//将memnode的索引及其节点的位置保存
template<typename INDEX, typename NODE>
int Shm_Mapper<INDEX, NODE>::InitMapList(const MEMNODE* memnode, const int& curpos)
{
    if (memnode->prepos != 0 || memnode->isfree == true)
    {
        return -1;
    }

    INDEX index;
    int hashvalue;
    Node2Index(*((NODE*)(memnode->node)), index);
    Index2Hash(index, hashvalue);

    if (hashvalue >= pMemHead->hashsize)
    {
        return -1;
    }

    map<INDEX, int>& index_mapper = Index_mapper_List[hashvalue];

    typename map<INDEX, int>::iterator iter = index_mapper.find(index);

    if (iter != index_mapper.end())
    {
        return -1;
    }
    index_mapper.insert(typename map<INDEX, int>::value_type(index, curpos));

    return 0;
}



template<typename INDEX, typename NODE>
int Shm_Mapper<INDEX, NODE>::InsertNode(const NODE& node, Shm_Mapper<INDEX, NODE>::MEMNODE* &memnode)
{
    memnode = NULL;
    
    INDEX index;
    int hashvalue;
    Node2Index(node, index);
    Index2Hash(index, hashvalue);
    
    if (hashvalue >= pMemHead->hashsize)
    {
        return -1;
    }
    
    map<INDEX, int>& index_mapper = Index_mapper_List[hashvalue];

    typename map<INDEX, int>::iterator iter = index_mapper.find(index);

    //检查索引不存在，则创建
    if (iter == index_mapper.end())
    {
        if (AllocNode(memnode) < 0)
        {
            return -1;
        }

        memcpy(memnode->node, &node, sizeof(NODE));

        int curpos = Node2Pos(memnode);
        index_mapper.insert(typename map<INDEX, int>::value_type(index, curpos));
    }
    //检查索引存在则覆盖
    else
    {
        int i = iter->second;
        if (i > 0)
        {
            memnode = Pos2Node(i);
            memcpy(memnode->node, &node, sizeof(NODE));
        }
        //如果索引下面没有挂载数据，则重新申请
        else
        {
            if (AllocNode(memnode) < 0)
            {
                return -1;
            }
            
            memcpy(memnode->node, &node, sizeof(NODE));
            
            int curpos = Node2Pos(memnode);
            iter->second = curpos;
        }
    }
    return 0;
}

template<typename INDEX, typename NODE>
int Shm_Mapper<INDEX, NODE>::QuerybyIndex(const INDEX &index, Shm_Mapper<INDEX, NODE>::MEMNODE* &memnode)
{
    memnode = NULL;
    int hashvalue;
    Index2Hash(index, hashvalue);
    
    if (hashvalue >= pMemHead->hashsize)
    {
        return -1;
    }

    map<INDEX, int>& index_mapper = Index_mapper_List[hashvalue];

    typename map<INDEX, int>::iterator iter = index_mapper.find(index);

    if (iter == index_mapper.end())
    {
        return 0;
    }

    int i = iter->second;
    if (i == 0)
    {
        return -1;
    }
    else
    {
        memnode = Pos2Node(i);
    }

    return 0;
}

template<typename INDEX, typename NODE>
int Shm_Mapper<INDEX, NODE>::DeleteNode(Shm_Mapper<INDEX, NODE>::MEMNODE* memnode)
{
    if (memnode->isfree == true)
    {
        return 0;
    }

    int curpos = Node2Pos(memnode);

    //为索引首字段
    if (memnode->prepos == 0)
    {
        INDEX index;
        int hashvalue;
        Node2Index(*((NODE *)memnode->node), index);
        Index2Hash(index, hashvalue);

        if (hashvalue >= pMemHead->hashsize)
        {
            return -1;
        }

        map<INDEX, int>& index_mapper = Index_mapper_List[hashvalue];

        typename map<INDEX, int>::iterator iter = index_mapper.find(index);

        if (iter == index_mapper.end())
        {
            return -1;
        }

        if (curpos != iter->second)
        {
            return  -1;
        }

        //设置新的空闲首节点prepos为0
        if (memnode->nextpos > 0)
        {
            MEMNODE* newhead = Pos2Node(memnode->nextpos);
            newhead->prepos = 0;
            iter->second = memnode->nextpos;
        }
        else//只有一个节点直接删掉索引
        {
            index_mapper.erase(iter);
        }
    }
    else
    {
        return  -1;
    }

    //将新获取的节点清空隔离
    memnode->nextpos = 0;
    memnode->prepos = 0;
    FreeNode(memnode);
    return 0;
}

struct stInfo
{
    char[30] str;
    string data;
}

typedef char[30] stIndex;

void Node2Index(const stInfo &node, stIndex &index)
{
    index = node.str;
}

void Index2Hash(const stIndex &index, int &hashvalue)
{
    hashvalue = 0;
    int len = index.strlen();
    for (int i = 0; i < len; ++i)
    {
        hashvalue = ((unsigned char)index[i] + hashvalue) % pMemHead->hashsize;
    }
}

template<typename INDEX, typename NODE>
typename Shm_Mapper<INDEX, NODE>::MEMNODE *Shm_Mapper<INDEX, NODE>::Pos2Node(const int& pos)
{
    if (pos <= 0)
    {
        return (MEMNODE*)NULL;
    }
    else
    {
        return (MEMNODE*)((char *)_pMapbeg + sizeof(MEMHEAD) + MEMNODESIZE * (pos - 1));
    }
}

template<typename INDEX, typename NODE>
int Shm_Mapper<INDEX, NODE>::Node2Pos(const Shm_Mapper<INDEX, NODE>::MEMNODE* memnode)
{
    if (memnode == NULL)
    {
        return 0;
    }
    else
    {
        return (int)(((char*)memnode - (char*)_pMapbeg - sizeof(MEMHEAD))/MEMNODESIZE + 1);
    }

}
View Code

 

转载于:https://www.cnblogs.com/share-ideas/p/10957284.html

weixin_34380948
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
基于共享内存的hashmap
06-19
老外的开源代码，好用，收藏了。
浅谈innodb的索引页结构,插入缓冲,自适应哈希索引
09-09
AHI通过监控索引搜索模式，对经常被访问的索引页创建哈希索引，从而将B树索引转换为更快的哈希查找。然而，AHI并不适用于所有场景，特别是在高并发的join操作中，哈希索引的锁竞争可能影响性能。此外，使用LIKE操作...
利用内存文件（共享内存）实现简单的数据库索引
changzehai的博客
09-05 1761
利用内存文件（共享内存）实现简单的数据库索引   1.    概要 当需要对一些数据进行大量重复的读写操作并且对效率有很高的要求的时候，使用传统数据库(oracle, mysql)往往不能满足效率高的要求，这个时候我们可以使用内存文件（共享内存）来保存我们的数据。这样的话，对文件的读写操作就变为对内存的读写操作，效率那是大大的提升。不过，内存文件虽然已经极大的提高效率了，但是，往往我们并不清
基于共享内存多级hash设计
内方外圆
09-06 4420
Feature list: 1.     支持Set/Get/Replace/Update, 优化编译下默认16级冲突下单进程下Set/Get可达170w次/s。（理论上只要不达到内容的带宽限制，而且是多核的机器下性能是随线进程数陪增） 2.     支持多程下操作(可预见低的出错概率) 3.     支持CAS弱一致性检测(需要编译时开启) 4.     支持二进制文件导
Windows 建立共享内存 索引查找更新
weixin_34026276的博客
02-16 444
2019独角兽企业重金招聘Python工程师标准>>> ...
MySQL全局共享内存介绍
09-10
MySQL全局共享内存是数据库系统中用于提升性能的关键组成部分，它允许不同的线程和进程共享数据，减少磁盘I/O操作，提高响应速度。全局共享内存主要用于MySQL实例（mysqld进程）以及底层存储引擎，存储各种全局运算...
MySQL内存表的特性与使用介绍
09-10
5. **索引类型**：内存表支持哈希索引（默认）和B树索引，可以通过`USING`子句指定，如： ```sql CREATE TABLE lookup ( id INT, INDEX USING HASH (id) ) ENGINE = MEMORY; CREATE TABLE lookup ( id INT, ...
VB桌面搜索 创建索引等功能.rar
07-10
VB桌面搜索创建索引功能是基于Visual Basic（VB）编程语言实现的一种本地文件搜索工具，它能够大大提高用户在计算机上查找文件的效率。这个程序利用了第三方DLL库，DLL（动态链接库）是一种共享库，其中包含了一系列...
Tomcat_redis_Session共享
03-30
默认情况下，Session信息存储在服务器的内存中，但这样存在一个问题：如果服务器集群或者采用负载均衡，不同服务器之间无法共享同一个Session，可能导致用户在切换服务器时需要重新登录。 为了解决这个问题，我们...
基于共享内存的hashMap及STL
09-12
从一个公司的项目中提取的一个基于共享内存的hashMap，vector,list等的相关实现，应用与游戏服务器的数据保存与访问
使用共享内存的多级哈希表
06-16
转自：http://www.cppblog.com/lmlf001/archive/2007/09/08/31858.html
共享内存数据库\Linux下基于共享内存访问的数据库设计与实现
04-08
一篇关于共享内存数据库\Linux下基于共享内存访问的数据库设计与实现的论文 写的不错 拿出来与大家分享
共享内存读写【2019.7.18更新】
u011550549的博客
07-13 1025
进程间共享数据： 一块共享内存，加载了很多区域的数据，为了快速查找内存数据，可以在头部设置索引空间。 这样可以实现快速的跳转。 关于进程的读写，则是设立了读锁与写锁。 写锁是唯一的，哪个进程如果要写数据，必须要去抢写锁。 ...
LINUX共享内存使用常见陷阱与分析
duola_rain的专栏
05-30 1625
所谓共享内存就是使得多个进程可以访问同一块内存空间，是最快的可用IPC形式。是针对其他通信机制运行效率较低而设计的。往往与其它通信机制，如信号量结合使用，来达到进程间的同步及互斥。其他进程能把同一段共享内存段“连接到”他们自己的地址空间里去。所有进程都能访问共享内存中的地址。如果一个进程向这段共享内存写了数据，所做的改动会即时被有访问同一段共享内存的其他进程看到。共享内存的使用大大降低了在大规模数
916-关于共享内存
LINZEYU666的博客
12-17 840
我们知道各进程之间是独立存在，互不影响的。有没有一种方式让这些进程之间产生联系呢？当然有！那就是共享内存。共享内存是进程间通信中最简单的方式之一。 站在进程的角度来说，共享内存就是可以同时被多个进程访问的内存。由于所有进程共享同一块内存，因此这种通信方式效率非常高。 为什么进程间的内存不是共享的吧？ 举一个例子，假设有 2 个进程同时想让某一物理地址保存一个值，A 进程想让这个物理地址保存 1，B 进程想让这个物理地址保存 2。那么这个物理地址到底应该保存哪个值？所以，为了将每个进程隔离开，设计者就想到一个
【Linux】应用篇十二--共享内存
修成真的博客
03-25 2987
应用篇十一--共享内存一、内存映射二、内存映射使用三、内存映射注意事项四、释放映射五、System V共享内存IPC 的keyftok函数创建步骤 一、内存映射 使一个磁盘文件与内存中的一个缓冲区相映射，进程可以像访问普通内存一样对文件进行访问，不必再调用read,write。 优点： 实现了用户空间和内核空间的高效交互方式 二、内存映射使用 void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t o.
SystemV 共享内存（一）—— 共享内存的创建与释放(shmget / shmctl)
热门推荐
challenglistic的博客
04-24 1万+
介绍共享内存的定义，及其共享内存的创建函数和释放函数
在共享内存中实现hash表
durbin86的专栏
04-27 2130
最近需要在php的共享内存之间使用kv存东西，找了一个开源的hashtable，挺实用的： lhttp://www.qdecoder.org/qlibc/reference/qlibc/qhasharr_8c.html
java容器.pdf
最新发布
09-27
Java容器是Java编程语言中用于存储和操作一组对象的数据结构。...同时，需要注意内存管理问题，避免内存泄露和大量无用对象的创建。理解和掌握Java容器的使用和底层原理，对于有效的编程和性能调优都有很大的帮助。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值