(hryEngine)引擎基础组成——高效内存池(lookaside list)

最新推荐文章于 2019-09-19 00:05:55 发布
最新推荐文章于 2019-09-19 00:05:55 发布
阅读量901 收藏
点赞数
分类专栏： C/C++ 服务器设计 文章标签： list 引擎 object header 网络游戏 apache

转自 http://blogold.chinaunix.net/u3/102180/showart_2065839.html


//  工程名称：网络游戏服务器端引擎《hryEngine》 
//  参考项目：ReactOS、Apache、ACE
【路过的朋友请留下您宝贵的意见，谢谢！】

#ifndef _LOOKASIDELIST_
#define _LOOKASIDELIST_
/******************************************************************************
* LookasideList Functions *
******************************************************************************/
#include "..\Define.h"

#define LAL_MEMORY_BLOCK_SIZE    (8)
typedef struct _LAL_MEMORY_BLOCK
{    
    _LAL_MEMORY_BLOCK*    sNext;                    // 0

    DWORD                dwMemSize;                // 4

    CHAR                pMemory[1];                // 8

    
    _LAL_MEMORY_BLOCK()
    {
        memset(this,0,sizeof(_LAL_MEMORY_BLOCK));
    }
} LAL_MEMORY_BLOCK, *PLAL_MEMORY_BLOCK;

typedef struct _LAL_BLOCK_HEADER
{
    PLAL_MEMORY_BLOCK    pEntry;        // 0

    WORD                wLen;        // 4


    _LAL_BLOCK_HEADER()
    {
        memset(this,0,sizeof(_LAL_BLOCK_HEADER));
    }
} LAL_BLOCK_HEADER, *PLAL_BLOCK_HEADER;

#define LAL_MEMORY_OBJECT_SIZE    (14)
typedef struct _LAL_MEMORY_OBJECT
{
    _LAL_MEMORY_OBJECT*    pPrev;            // 0    for allocated list free

    _LAL_MEMORY_OBJECT*    pNext;            // 4

    PVOID                pParent;        // 8            

    USHORT                usIndex:15;        // 12

    USHORT                usStatus:1;        //            0: free 1: allocated

    CHAR                pMemory[1];        // 14


    _LAL_MEMORY_OBJECT()
    {
        memset(this,0,sizeof(_LAL_MEMORY_OBJECT));
    }    
} LAL_MEMORY_OBJECT, *PLAL_MEMORY_OBJECT;

typedef struct _LAL_OBJECT_HEADER
{
    PLAL_MEMORY_OBJECT    pEntry;        // 0

    DWORD                wLen;        // 4


    _LAL_OBJECT_HEADER()
    {
        memset(this,0,sizeof(_LAL_OBJECT_HEADER));
    }
} LAL_OBJECT_HEADER, *PLAL_OBJECT_HEADER;


class LOOKASIDE_LIST 
{
private:
    LAL_BLOCK_HEADER    m_sMemoryBlockList;
    DWORD                m_dwObjectSize;
    WORD                m_wMaxObjectNum;
    WORD                m_wDefaultObjectNum;
    WORD                m_wIncreaseObjectNum;

    BOOL
    AddBlock(
        IN OUT PLAL_BLOCK_HEADER pBlockHeader,
        IN OUT PLAL_OBJECT_HEADER pObjectHeader,
        IN CONST DWORD dwObjSize,
        IN CONST WORD wObjNum);
public:
    enum
    {
        PER_BLOCK_OBJ_MAX_NUM = 512,
        MEM_STATUS_FREE = 0,
        MEM_STATUS_ALLOCATED = 1,
    };
    LAL_OBJECT_HEADER    m_sFreeObjectList;
    LAL_OBJECT_HEADER    m_sAllocatedObjectList;
    DWORD                m_dwRealObjectSize;
public:
    LOOKASIDE_LIST();
    ~LOOKASIDE_LIST();
    BOOL 
    InitializeLookasideList(
        IN CONST DWORD dwObjectSize,
        IN CONST WORD wMaxObjNum,
        IN CONST WORD wDefaultObjNum,
        IN CONST WORD wIncreaseObjectNum);
    BOOL
    IncreaseBlock(VOID);
};

static 
inline 
PLAL_MEMORY_OBJECT
BodyToHeader ( 
             IN PVOID addr );

PVOID
LalAlloc(
         IN LOOKASIDE_LIST* pLookaside);

VOID
LalFree(
         IN LOOKASIDE_LIST* pLookaside,
         IN PVOID pMemory);


#endif


/*
* PROJECT: hryEngine.LookasideList
* PURPOSE: memory pool by lookaside list
* PROGRAMMERS: Liao Huaifu(279670696@qq.com,deuglhf@hotmail.com)
                 Shanghai
                 09/9-26~09/10-8
*/

#include <windows.h>
#include <malloc.h>
#include "LookasideList.h"

LOOKASIDE_LIST::LOOKASIDE_LIST()
{
    memset(this,0,sizeof(LOOKASIDE_LIST));
}

LOOKASIDE_LIST::~LOOKASIDE_LIST()
{
    if (m_sMemoryBlockList.pEntry && m_sMemoryBlockList.wLen)
    {
        PLAL_MEMORY_BLOCK pBlock = m_sMemoryBlockList.pEntry;
        while(pBlock)
        {
            PLAL_MEMORY_BLOCK tmpBlock = pBlock->sNext;
            delete[] (char*)pBlock;
            pBlock = NULL;
            pBlock = tmpBlock;
        }
    }
}

BOOL 
LOOKASIDE_LIST::InitializeLookasideList(
                        IN CONST DWORD dwObjectSize,
                        IN CONST WORD wMaxObjNum,
                        IN CONST WORD wDefaultObjNum,
                        IN CONST WORD wIncreaseObjectNum)
{
    m_dwObjectSize = dwObjectSize;
    m_wMaxObjectNum = wMaxObjNum;
    m_wDefaultObjectNum = wDefaultObjNum;
    m_wIncreaseObjectNum = wIncreaseObjectNum;

    WORD num = 0;
    (wDefaultObjNum%PER_BLOCK_OBJ_MAX_NUM == 0)? 
        num = wDefaultObjNum/PER_BLOCK_OBJ_MAX_NUM : 
        num = wDefaultObjNum/PER_BLOCK_OBJ_MAX_NUM + 1;
    for(int i=0;i<num;i++)
    {
        AddBlock(&m_sMemoryBlockList,&m_sFreeObjectList,m_dwObjectSize,PER_BLOCK_OBJ_MAX_NUM);
    }
    return TRUE;
}

BOOL
LOOKASIDE_LIST::AddBlock(
         IN OUT PLAL_BLOCK_HEADER pBlockHeader,
         IN OUT PLAL_OBJECT_HEADER pObjectHeader,
         IN CONST DWORD dwObjSize,
         IN CONST WORD wObjNum)
{
    if (!pBlockHeader || !pObjectHeader || !dwObjSize || !dwObjSize)
    {
        return FALSE;
    }

    m_dwRealObjectSize = dwObjSize + LAL_MEMORY_OBJECT_SIZE;
    DWORD dwBlockSize = wObjNum * m_dwRealObjectSize + LAL_MEMORY_BLOCK_SIZE;
    char *pMemory = new char[dwBlockSize];
    if (!pMemory)
    {
        return FALSE;
    }

    PLAL_MEMORY_BLOCK pBlock = (PLAL_MEMORY_BLOCK)pMemory;
    pBlock->sNext = pBlockHeader->pEntry;
    pBlock->dwMemSize = dwBlockSize;
    //pBlock->pMemory = pMemory + LAL_MEMORY_BLOCK_SIZE;


    pBlockHeader->pEntry = pBlock;
    pBlockHeader->wLen++;

    // init object memory chain table

    DWORD dwOffset = 0;     
    for(int i=0;i<wObjNum;i++)
    {
        dwOffset = LAL_MEMORY_BLOCK_SIZE + (i*m_dwRealObjectSize);
        PLAL_MEMORY_OBJECT pObject = (PLAL_MEMORY_OBJECT)(pMemory + dwOffset);
        pObject->pNext = pObjectHeader->pEntry;
        pObject->pPrev = NULL;
        pObjectHeader->pEntry = pObject;
        pObjectHeader->wLen++;
        pObject->pParent = pMemory;
        pObject->usIndex = i+1;
        pObject->usStatus = MEM_STATUS_FREE;
        //pObject->pMemory = pMemory + dwOffset + LAL_MEMORY_OBJECT_SIZE;

    }
    return TRUE;
}

BOOL
LOOKASIDE_LIST::IncreaseBlock(VOID)
{
    if (m_wMaxObjectNum && m_sAllocatedObjectList.wLen>=m_wMaxObjectNum)
    {
        return FALSE;
    }
    return AddBlock(&m_sMemoryBlockList,&m_sFreeObjectList,m_dwObjectSize,m_wIncreaseObjectNum);
}

PVOID
LalAlloc(
         IN LOOKASIDE_LIST* pLookaside)
{
    if (!pLookaside)    return    NULL;
    if (!pLookaside->m_sFreeObjectList.pEntry)
    {
        if (!pLookaside->IncreaseBlock())
            return NULL;
    }

    PLAL_MEMORY_OBJECT pVel = pLookaside->m_sFreeObjectList.pEntry;
    pLookaside->m_sFreeObjectList.wLen--;
    pLookaside->m_sFreeObjectList.pEntry = pVel->pNext;
    pVel->usStatus = LOOKASIDE_LIST::MEM_STATUS_ALLOCATED;
    pVel->pNext = pVel->pPrev = NULL;
#ifdef DEBUG_VER
    if (pLookaside->m_sAllocatedObjectList.pEntry)
    {
        pVel->pNext = pLookaside->m_sAllocatedObjectList.pEntry;
        pLookaside->m_sAllocatedObjectList.pEntry->pPrev = pVel;    
        pLookaside->m_sAllocatedObjectList.pEntry = pVel;
    }
    pLookaside->m_sAllocatedObjectList.pEntry = pVel;
    pLookaside->m_sAllocatedObjectList.wLen++;
#endif
    return pVel->pMemory;
}

VOID
LalFree(
         IN LOOKASIDE_LIST* pLookaside,
         IN PVOID pMemory)
{
    if (!pLookaside || !pMemory) return;
    
    PLAL_MEMORY_OBJECT pVel = BodyToHeader(pMemory);
    PCHAR pUnit = (PCHAR)pVel;
    PCHAR pL = ((PCHAR)pVel->pParent) + (pVel->usIndex-1)*(pLookaside->m_dwRealObjectSize);
    PCHAR pH = ((PCHAR)pVel->pParent) + (pVel->usIndex+1)*(pLookaside->m_dwRealObjectSize);
    if (pUnit > pL && pUnit < pH)
    {
        if (pVel->usStatus)
        {
#ifdef DEBUG_VER
            PLAL_MEMORY_OBJECT pPrev = pVel->pPrev;
            PLAL_MEMORY_OBJECT pNext = pVel->pNext;
            if (pPrev)    
                pPrev->pNext = pNext;
            if (pNext)    
                pNext->pPrev = pPrev;
            else // pPrev = pNext = null

                pLookaside->m_sAllocatedObjectList.pEntry = NULL;    
            pLookaside->m_sAllocatedObjectList.wLen--;
#endif
            pVel->usStatus = LOOKASIDE_LIST::MEM_STATUS_FREE;    
            pVel->pPrev = NULL;
            pVel->pNext = pLookaside->m_sFreeObjectList.pEntry;     
            pLookaside->m_sFreeObjectList.pEntry = pVel;
            pLookaside->m_sFreeObjectList.wLen++;
        }
        else
        {
            // memory had been destroy

        }
    }
}

static 
inline 
PLAL_MEMORY_OBJECT
BodyToHeader ( 
             IN PVOID addr )
{
    return (PLAL_MEMORY_OBJECT)(((char*)addr) - LAL_MEMORY_OBJECT_SIZE);
}


napu_sh
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux C 内存池实现
05-16
C语言实现的内存池！j利用默认的内存管理函数new/delete或malloc/free在堆上分配和释放内存会有一些额外的开销。
p129 - p154虚拟内存管理
最新发布
05-15
虚拟内存管理是操作系统中至关重要的一个组成部分，它使得多个进程可以在同一时间运行，而不会相互干扰，有效地利用有限的物理内存资源。虚拟内存系统通过引入虚拟地址和物理地址的概念，实现了进程间的地址隔离和...
Lookaside List 详解
yangdazhi的专栏
10-30 2204
使用 Lookaside List 分配内存 概述lookaside list 节点结构节点内存块 size初始化节点分配内存释放内存动态调整 lookaside list 节点深度 1. 概述 windows 提供了一种基于 lookaside list 的快速内存分配方案，区别于一般的使用 ExAllocatePoolWithTag() 系列函数的内存分配方式。每次从 loo
内存池的简单实现
不会飞的纸飞机的博客
07-17 471
文章目录1. 内存单元2. 内存块3. 内存池 当我们频繁的申请内存(new、malloc) 和 释放内存(delete、free) 时，会产生内存碎片，而且申请和释放内存也会增加时间的消耗。内存池就是为了解决该问题，提高效率产生的。 这里使用分段分段连续的内存，来存储多次申请和释放的内存。 内存单元： 定义的内存最小单元 内存块： 一块连续的内存，可以存放多个内存单元 内存池： 用链表...
（转）内存池实现
weixin_34354173的博客
09-24 82
话说一直想找一个别人写好的使用，可惜没什么人会拿这小东西发布，只好自写一个。1.多级链表分配池我不知道这种设计的具体学名是什么，这部分的内容也许你去看《STL源码分析》的有关章节更合适一些，这里我只能用我粗陋的语言描述一下。内存池，完全可以从字面上理解为从池子里申请内存，释放的时候还给池子。最简单的内存池应该是fix_pool吧，即每次分配出来的内存块大小是固定的。这种池子的管理结构是一个链表，链...
用C来实现内存池
weixin_33670786的博客
12-11 96
介绍：        设计内存池的目标是为了保证服务器长时间高效的运行，通过对申请空间小而申请频繁的对象进行有效管理，减少内存碎片的产生，合理分配管理用户内存，从而减少系统中出现有效空间足够，而无法分配大块连续内存的情况。 目标：     此次设计内存池的基本目标，需要满足线程安全性（多线程），适量的内存泄露越界检查，运行效率不太低于malloc/free方式，实现对4-128字节范围内的内...
Linux虚拟内存管理基础v2.ppt
09-28
Linux虚拟内存管理是操作系统的核心组成部分，它为每个进程创建了一个独立的、连续的虚拟地址空间，使得进程可以高效地访问和使用内存，即使物理内存不足，也能通过虚拟内存技术利用磁盘空间作为扩展。以下是对Linux...
Linux内核内存管理技术分享
08-27
hardware和计算机体系结构是Linux内存管理的基础。计算机体系结构中，存储层次结构包括寄存器、Cache、主存储器和辅助存储器。MMU（Memory Management Unit）是Linux内存管理的核心组件，负责将虚拟地址转换为物理...
详解Linux内核内存管理架构
09-15
Linux内核内存管理架构是操作系统的核心组成部分，负责高效地分配、回收、管理和优化系统的内存资源。内存管理子系统包括了页面映射、分配、回收、交换、碎片管理、缓存和统计等多个复杂功能，旨在满足各种性能需求...
自己动手设计一个内存管理子系统.pdf
07-31
内存管理子系统是操作系统核心的重要组成部分，特别是在Linux内核中，它扮演着至关重要的角色。内存管理的主要目标是高效地分配和回收内存资源，确保系统的稳定性和性能。本项目旨在探讨如何设计一个基本的内存管理...
多线程内存池实现
Always On The Way
01-08 1336
多线程的内存池是基于模板的类： template class MTMemoryPool { public: void* alloc(size_t size); void free(void* someElement); private: POOLTYPE stPool; LOCK theLock; }; template void* MTMemoryPool::alloc(size
内存池完整实现代码及一些思考
konyel的专栏
06-06 530
为了提高效率和有效的监控内存的实时状态，我们采取了内存池的思想来解决效率与对内存实现监控的问题。网上查找到了一些方案，根据自己的理解实现了应用。   我们什么时候要调用到内存池，   1，当我们频繁的申请释放同样数据大小的内存空间，我们可以用比动态new更有效方式来管理内存时，我们应该用内存池来提高效率。   2，当我们需要知道内存实时的申请状态，以便于对于服务器内存状态做实时预
Server - 对象池(3)
莫忘输赢的博客
08-10 143
#ifndef _CELLObjectPool_hpp_ #define _CELLObjectPool_hpp_ //头文件防止引入多次 #include<stdlib.h> #include<assert.h> #include<mutex> #ifdef _DEBUG #ifndef xPrintf #include<stdio.h>...
内存池版本3--单线程-可变大小对象的内存池
weixin_33881041的博客
01-08 123
#include "stdafx.h"#include &lt;windows.h&gt;#include &lt;MMSystem.h&gt;#include &lt;iostream&gt;using namespace std;#pragma comment(lib, "winmm.lib")class Foo{public: Foo(int a = 0, int b = 0):m...
内存池
Liu_Xiao_Ming的博客
09-19 407
1、什么是内存池 内存池是对内存分配的管理。正常创建变量的方式是new和malloc，但频繁的new与delete，malloc与free同操作系统交互，会降低程序的运行效率，增加内存中的内存碎片数（剩余的内存很足，但不是连续的内存，不足以被分配）。而内存池提前申请一片一定数量的、大小相等的内存备用。当需要时，在内存池中取用，不用时还给内存池。使得内存分配效率得到提升。 2、适用场景 频繁的...
[转]apr内存池
pufan66的专栏
06-27 723
apr内存池 收藏 来源:http://blog.csdn.net/tingya对于APR中的所有的对象中，内存池对象应该是其余对象内存分配的基础，不仅是APR中的对象，而且对于整个Apache中的大部分对象的内存都是从内存池中进行分配的，因此我们将把内存池作为整个APR的基础。2.1 内存池概述在C语言中，内存管理的问题臭
一个内存池代码
firebird321的专栏
04-27 1431
最近做服务器，需要把数千个客户端上发的数据保存起来；保存数据所使用的缓冲区，是从一个内存池里面取得的；客户端上发的数据，长度从几十字节至三四 k 不等（按照协议，数据长度最大为4k）；如果内存池中的每片缓冲区的长度大小都使用4k，会造成空间浪费，因为客户端就算只上发几个字节的数据，也会占用一片4k的缓冲区；想了一下，就做了下面这个内存池来避免空间浪费；里面使用了8块大内存，每块内存依次按照 32字
深入解析Linux虚拟内存管理
在Linux系统中，虚拟内存管理（Virtual Memory Manager，简称VMM）是一个至关重要的组件，它负责处理物理内存和逻辑地址空间之间的映射，确保多个进程可以同时高效地运行而不会相互干扰。这本书详细介绍了以下核心...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值