为C++标准库容器写自己的内存分配程序

最新推荐文章于 2024-08-26 12:47:32 发布
最新推荐文章于 2024-08-26 12:47:32 发布
阅读量1k 收藏
点赞数
分类专栏： C/C++ 文章标签： c++ list class reference iostream string
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fuzj/article/details/1378346
版权

根据sgi 的STL源码的二级分配算法改写的内存池分配程序，只要稍微修改就可以实现共享内存方式管理，使用C++标准库容器中的map，set，multimap，multiset测试通过，vector测试通不过，原因是在内存回收的时候考虑的比较简单，vector每次分配内存个数不固定，回收也不固定，这样的话，程序还需要继续完善。

内存池管理程序源码如下：

#ifndef MY_ALLOCATOR_H_
#define MY_ALLOCATOR_H_
#include "stdafx.h"
#include <limits>
#include <iostream>

namespace happyever
{
  enum { NODENUMS = 2 };
  union _Obj
  {
    union _Obj* M_free_list_link;
    char M_client_data[1];   
  } ;

  typedef union _Obj Obj;

  struct _Cookie
  {
    int iShmKey;        /* 共享内存键值 */
    int iShmID;         /* iShmKey对应的shmid */
    int iSemKey;        /* 锁信号键值 */
    int iSemID;         /* 锁信号标识 */

    int iTotalsize;    /* 容器总容量 */

    void* pStartall;   /* 共享内存自身地址 */
    char* pStartfree;  /* 自由空间的开始地址*/
    char* pEndfree;    /* 自由空间的结束地址*/

    int iUseNum[NODENUMS];
    /*用来存放free_list中节点的size*/
    short sFreelistIndex[NODENUMS];

    /*存放分配内存节点的链表*/
    Obj* uFreelist[NODENUMS];
  };

  typedef struct _Cookie Cookie;

  //Obj;
  //Cookie;
  static Cookie *pHead = NULL;

  template <class T>
  class MyAlloc
  {
  private:
    static const int ALIGN = sizeof(Obj);

    int round_up(int bytes);
    int freelist_index(int bytes);
    int freelist_getindex(int bytes);
    char* chunk_alloc(int size, int *nobjs);
    void* refill(int num,int n);

  public:
    // type definitions
    typedef T        value_type;
    typedef T*       pointer;
    typedef const T* const_pointer;
    typedef T&       reference;
    typedef const T& const_reference;
    typedef std::size_t    size_type;
    typedef std::ptrdiff_t difference_type;

    template <class U>
    struct rebind
    {
      typedef MyAlloc<U> other;
    };

    pointer address (reference value) const
    {
      return &value;
    }
    const_pointer address (const_reference value) const
    {
      return &value;
    }

    MyAlloc() throw()
    {
      std::cout<<"MyAlloc"<<std::endl;
    }

    MyAlloc(const MyAlloc& x) throw()
    {
      std::cout<<"const MyAlloc"<<std::endl;
    }

    template <class U>
    MyAlloc (const MyAlloc<U>& x) throw()
    {
      std::cout<<"const MyAlloc<U>"<<std::endl;
    }

    ~MyAlloc() throw()
    {
      std::cout<<"~MyAlloc"<<std::endl;
    }

    size_type max_size () const throw()
    {
      return std::numeric_limits<std::size_t>::max() / sizeof(T);
    }

    //void PrintFreelistAndCookie();

    pointer allocate (size_type num, const void* = 0)
    {
      pointer ret = 0;
      Obj** my_free_list;
      Obj* result;
      int index;

      // print message and allocate memory with global new
      std::cerr << "allocate " << num << " element(s)"
        << " of size " << sizeof(T) << std::endl;

      index = freelist_index(sizeof(T));
      if(index >= NODENUMS)
      {
        return NULL;
      }

      my_free_list = pHead->uFreelist + index;

      //Lock(semid,LOCK_NUM);

      result = *my_free_list;
      if (result == 0)
      {
        ret = (pointer)refill((int)num, round_up(sizeof(T)));
      }
      else
      {
        *my_free_list = result->M_free_list_link;
        ret = (pointer)result;
      }
      //UnLock(semid,LOCK_NUM);

      pHead->iUseNum[index] = pHead->iUseNum[index] + (int)num;

      if(0 == ret)
      {
        std::cerr << "alloc memory fail!" << std::endl;
        exit(1);
      }
      std::cerr << " allocated at: " << (void*)ret << std::endl;

      PrintFreelistAndCookie();
      return ret;
    }

    void construct (pointer p, const T& value)
    {
      // initialize memory with placement new
      new((void*)p)T(value);
    }

    void destroy (pointer p)
    {
      // destroy objects by calling their destructor
      p->~T();
    }

    void deallocate (pointer p, size_type num)
    {
      Obj** my_free_list;
      Obj* q ;
      int index;

      index = freelist_getindex(sizeof(T));
      if(index >= NODENUMS)
      {
        std::cerr << "deallocate memory fail!" << std::endl;
        exit(1);
      }

      my_free_list = pHead->uFreelist + index;
      q = (Obj*) p;

      //Lock(semid,LOCK_NUM);
      /*这个地方可能会有问题*/
      //for(int i=0 ;i<(int)num ; i++)
      {
        q->M_free_list_link = *my_free_list;
        *my_free_list = q;
      }
      //UnLock(semid,LOCK_NUM);

      pHead->iUseNum[index] = pHead->iUseNum[index] - (int)num;
     
      std::cerr << "deallocate " << num << " element(s)"
        << " of size " << sizeof(T)
        << " at: " << (void*)p << std::endl;

      PrintFreelistAndCookie();

    }
  };

  template <class T>
  int MyAlloc<T>::round_up(int bytes)
  {
    int i;

    i = bytes;
    if(bytes < ALIGN)
    {
      i = ALIGN;
    }

    std::cout<<"round_up:bytes="<<bytes<<" , return="<<i<<std::endl;
    return i;
  };

  template <class T>
  int MyAlloc<T>::freelist_index(int bytes)
  {
    int i;
    for(i=0 ; i< NODENUMS ; i++)
    {
      if(pHead->sFreelistIndex[i] == bytes)
        break;
    }

    if(i >= NODENUMS)
    {
      for(i=0 ; i< NODENUMS ; i++)
      {
        if(pHead->sFreelistIndex[i] == 0)
        {
          pHead->sFreelistIndex[i] = bytes;
          std::cout<<"freelist_index:bytes="<<bytes<<" , return="<<i<<std::endl;
          return i;
        }
      }
    }
    std::cout<<"freelist_index:bytes="<<bytes<<" , return="<<i<<std::endl;
    return i;
  };

  template <class T>
  int MyAlloc<T>::freelist_getindex(int bytes)
  {
    int i;
    for(i=0 ; i< NODENUMS ; i++)
    {
      if(pHead->sFreelistIndex[i] == bytes)
        break;
    }

    std::cout<<"freelist_getindex:bytes="<<bytes<<" , return="<<i<<std::endl;
    return i;
  };

  template <class T>
  char* MyAlloc<T>::chunk_alloc(int size, int *nobjs)
  {
    char* result;
    int counts = *nobjs;
    int total_bytes = size * counts;
    int bytes_left = int(pHead->pEndfree - pHead->pStartfree);

    std::cout<<"chunk_alloc:total_bytes = "<<total_bytes
      <<",bytes_left = "<<bytes_left<<std::endl;

    if (bytes_left >= total_bytes)
    {
      result = pHead->pStartfree;
      pHead->pStartfree += total_bytes;
      std::cout<<"chunk_alloc:total_bytes = "<<total_bytes
        <<",result = "<<*result<<",start_free = "<<&(pHead->pStartfree)<<std::endl;
    }
    else if (bytes_left >= size)
    {
      counts = bytes_left/size;
      total_bytes = size * counts;
      result = pHead->pStartfree;
      pHead->pStartfree += total_bytes;
      *nobjs = counts;
      std::cout<<"chunk_alloc:total_bytes = "<<total_bytes<<",nobjs = "<<nobjs
        <<",result = "<<*result<<",start_free = "<<&(pHead->pStartfree)<<std::endl;
    }
    else
    {
      /*还需要处理回收其他空闲freelist里面的空间*/
      result = NULL;
    }

    return(result);
  };

  template <class T>
  void* MyAlloc<T>::refill(int num,int n)
  {
    int counts = num;
    int *nobjs = &counts;
    char* chunk;
    Obj** my_free_list;
    Obj* result;
    Obj* current_obj;
    Obj* next_obj;
    int i;

    chunk = chunk_alloc(n, nobjs);
    if(chunk == NULL)
    {
      return(chunk);
    }

    counts = *nobjs;
    if (1 == counts)
    {
      return(chunk);
    }

    my_free_list = pHead->uFreelist + freelist_index(n);

    result = (Obj*)chunk;
    *my_free_list = next_obj = (Obj*)(chunk + n*num);
    for (i = 1; ; i++)
    {
      current_obj = next_obj;
      next_obj = (Obj*)((char*)next_obj + n);
      if (counts - 1 == i)
      {
        current_obj->M_free_list_link = 0;
        break;
      }
      else
      {
        current_obj->M_free_list_link = next_obj;
      }
    }
    return(result);
  };

/*这个函数可以改写成自己的共享内存分配函数*/ 

static void InitShm()
  {
    int i,size=1000;
    pHead = (Cookie*)malloc(sizeof(Cookie)+size);

    pHead->iTotalsize = sizeof(Cookie)+size;

    pHead->pStartall  = pHead;
    pHead->pStartfree = (char*)pHead + sizeof(Cookie);
    pHead->pEndfree   = (char*)pHead + pHead->iTotalsize;

    for(i=0 ; i <NODENUMS ; i++)
    {
      pHead->sFreelistIndex[i]=0;
      pHead->uFreelist[i]=0;
      pHead->iUseNum[i]=0;
    }
  }

  static void PrintFreelistAndCookie()
  {
    int i,j;
    Obj* my_free_list;

    std::cout<<"Cookie info :"<<std::endl;
    std::cout<<"sizeof(struct Cookie) = "<<sizeof(Cookie)<<std::endl;
    std::cout<<"Totalsize     = "<<pHead->iTotalsize<<std::endl;
    std::cout<<"UsedSize      = "<<int(pHead->pStartfree-(char*)pHead)<<std::endl;
    std::cout<<"FreepoolSize  = "<<int(pHead->pEndfree - pHead->pStartfree)<<std::endl;
    std::cout<<"Startall      = "<<&(pHead->pStartall)<<std::endl;
    std::cout<<"Startfree     = "<<&(pHead->pStartfree)<<std::endl;
    std::cout<<"Endfree       = "<<&(pHead->pEndfree)<<std::endl;

    std::cout<<"nFreelist info :"<<std::endl;
    for(i=0 ; i<NODENUMS ; i++)
    {
      j=0;
      std::cout<<"iUseNum["<<i<<"] = "<<pHead->iUseNum[i]<<std::endl;
      std::cout<<"FreelistIndex["<<i<<"] = "<<pHead->sFreelistIndex[i]<<std::endl;
      my_free_list = pHead->uFreelist[i];
      if(my_free_list->M_client_data != 0)
      {

        while(my_free_list->M_client_data != 0)
        {
          j++;
          my_free_list = my_free_list->M_free_list_link;
        }
        std::cout<<"free_list["<<i<<"]; node counts="<<j<<std::endl;
      }

    }
  }

  template <class T1, class T2>
  bool operator== (const MyAlloc<T1>&,const MyAlloc<T2>&) throw()
  {
    return true;
  }
  template <class T1, class T2>
  bool operator!= (const MyAlloc<T1>&,const MyAlloc<T2>&) throw()
  {
    return false;
  }
}

#endif /*MY_ALLOCATOR_H_*/

测试程序的源码如下：

 

// MyStl.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <map>
#include <vector>
#include <string>
#include <utility>
#include <iostream>
#include "MyAlloc.h"

using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{
  happyever ::InitShm();
  multimap<string,int,less<string>,happyever ::MyAlloc<string> > m;

  m.insert(make_pair(string("Harry"), 32));
  m.insert(make_pair(string("Mary"), 59));
  m.insert(make_pair(string("Roger"), 18));
  m.insert(make_pair(string("Nancy"), 37));
  m.insert(make_pair(string("Mary"), 23));
 
  typedef multimap<string,int,less<string>,happyever ::MyAlloc<string> >::iterator Iter;

  for (Iter p = m.begin(); p != m.end(); p++)
  {
    cout << p->first << "," << p->second << endl;
  }

  Iter p = m.find("Harry");
  m.erase(p);

  /*p = m.find("Harry");
  cout << "Harry is: " << p->second << "." << endl;*/


  for (Iter p = m.begin(); p != m.end(); p++)
  {
    cout << p->first << "," << p->second << endl;
  }
 

  return 0;
}

以上程序在vs2005，vc6上测试通过。使用MinGW编译的时候只需要去掉vc的预编译头文件

#include "stdafx.h"

即可。

以上程序只要稍微修改，就可以实现共享内存的管理，可以方便的使用标准库提供的容器。加上信号量的锁机制。

以上为了学习而改写的SGI的stl二级分配算法实现的。以上代码存在一定的局限性。我另外完整实现了共享内存管理的STL标准的alloctor程序，使用posix信号量加锁。目前应用在aix的xlC编译环境下。因为源码涉及公司的商业秘密，所以不能公开。但基本上以上源码已经体现了自己管理内存的完整思路，供这方面需求的朋友一起学习研究用。

C++ 中自定义数组容器MyVector的实现
03-27
C++ 中自定义数组容器MyVector实现+类模板实现过程中产生的问题的详细注释
C++标准库容器写自己的内存分配程序源代码
10-05
该段程序代码教会你如何自己分配内存，其中的主要是说明如何分配C++标准库容器的内存和处理。
自己管理C++内存(内存池)
幻想之渔
04-20 838
内存管理的目的：提高速度，降低空间浪费率 减少malloc的使用。（可以先分配一大块，再一点一点的使用） 较少cookie的使用。 版本一 #include &lt;iostream&gt; using namespace std; class Screen { public: Screen(int x):i(x) {} int get() {...
学懂C++（四十四）：C++ 自定义内存管理的深入解析：内存池与自定义分配器
最新发布
martian665的专栏
08-26 1717
C++ 自定义内存管理的深入解析：内存池与自定义分配器
C++中的内存管理方式
2301_76197086的博客
03-12 506
详解C++中的内存管理方式
C++手写容器
破茧而出
05-19 319
#ifndef PersonSet_hpp#define PersonSet_hpp#include &lt;iostream&gt;#include "Person.hpp"using namespace std;class PersonSet{public:    Person **p;    int _size;    int capacity;    int index;public:  ...
用C++实现自己的内存池
热门推荐
Bruce Che 的专栏
12-14 1万+
打开浏览器，搜索了下内存管理的概念，百度百科中是这样定义的：内存管理，是指软件运行时对计算机内存资源的分配和使用的技术。其最主要的目的是如何高效，快速的分配，并且在适当的时候释放和回收内存资源。说到内存，与之紧密相联系的一个概念就是指针。回想起上学那会儿，自己对指针是即喜欢，又害怕。因为学好了指针，就可以学好C，继而学好C++，但面对那些晦涩的概念，和程序运行中一些莫名其妙的指针越界、内存泄露……
c++标准库参考.pdf
06-15
C++标准库通过allocator类的多种变体，例如allocator_base、allocator_chunklist等，为不同场景下的内存分配提供了便利和优化。 C++标准库还包括一系列的容器类，它们在、、、、、、、等头文件中定义。这些容器类型...
C++ 标准库 中文 高清 (2020最新带书签)
10-11
C++标准库是C++编程语言的核心组成部分，它提供了一系列预先定义的数据结构、函数和算法，使得程序员可以高效地编写程序。C++标准库不仅包括了C标准库，还额外扩展了许多面向对象和泛型编程的功能。这个高清中文版的...
C++标准库介绍
08-29
C++标准库是C++语言的核心组成部分之一，它提供了广泛的函数和类，用于实现输入/输出、字符串操作、容器、算法、诊断、语言支持等功能。C++标准库的头文件共有50个，其中18个提供了C库的功能。 C++标准库的内容可以...
C++biaozhunku.rar_C++标准库_c++ 标准库_library
09-22
C++标准库是C++编程语言的核心组成部分，它提供了一系列预先定义好的函数、类和对象，使得程序员可以高效地编写程序而无需从零开始构建所有基础功能。C++标准库通常被称为C++ Standard Template Library (STL)，但...
自定义C++内存管理
洋葱汪的博客
04-09 475
目录 1、关于动态内存分配 2、new / delete的重载 3、重载new[] / delete[] 4、动态内存申请的结果 1、动态内存申请的结果 2、跨编译器统一new的行为 5、小结 1、关于动态内存分配 new关键字与malloc函数的区别 - new关键字是C++的—部分，malloc是由C库提供的函数 - new以具体类型为...
C++ 自定义内存 管理
king1076的专栏
11-05 626
工作中常常需要，将一些数据放到内存中处理，有时候数据量好大多达3G的空间。 而且自己存储都是一些指针之类的东西，每次都要new，容器中存储的量好大，四五百万个。 而且最头疼的就是 析构的时候要等好久才能释放掉这个东西。查了好久 发现最流行的就是 空间换时间。 说了也惭愧，在学校中没怎么学到高深的东西，好多都是自己在工作中学习的。 同事说我可以看看Nginx的内存管理，我百度了下，有点那么意
C++ STL 容器自定义内存分配器
MyDriverC
06-05 2944
一，基础篇 很多时候我们不要用默认的allocator的实现，我们需要自己的内存配置，所以我们可以做自己的分配器，这里说说必须要有的一些注意事项，因为有些是我犯错过的。 需要有自己的一些类型定义比如pointer需要做自己的allocate和deallocate一定要有rebind实现，如果不理解，请看一下标准库里面的list，set等的实现，很容易的。   附上代码：
C++内存管理
zw_ggr_2017的博客
08-03 152
C++内存管理
Boost程序库完全开发指南——深入C++“准”标准库高清版
02-03
- **性能优化**：合理选择合适的容器和算法，避免不必要的内存分配和复制。 - **异常安全**：编写异常安全的代码，特别是在使用智能指针和其他资源管理组件时。 - **文档编写**：为使用Boost库的代码编写清晰的文档...
用C++如何实现内存的自动管理和用一个容器存放继承层次的任何类的对象
qq_25048473的博客
04-10 654
用C++如何实现内存的自动管理和用一个容器存放继承层次的任何类的对象
C++程序设计内存管理器（内存池）
翼遥君的博客
03-26 3632
一、New/malloc内存分配很慢 C语言中的标准库函数malloc、free、calloc和realloc，以及C++中的new、new[]、delete和delete[] 操作符，是这两种语言中内存管理的关键之处。（注意一下C语言里面的是函数，在C++里面是操作符，这个据说在面试里面被问到过。） 在执行时，malloc和new将向操作系统内核请求内存，而free和delete则请
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值