[原创]针对linux内存管理对前期内存池作出如下简化处理

   前期在文章中贴出了自我实现的一个内存池，原理是针对initPool以内的 Align对齐（8、16...）的内存采用数组＋练表表双重管理，以求达到高校的目的，每个内存项有2个字节是用来记录内存大小的，然后在Free中可 以将其对应回归到相应的桶内，InitPool以外的部分直接以链表的形式组织，这样就可以达到处理管理绝大多数内存的目的，在windows上测试性能 要远远高于直接malloc、free，但是在linux上发现情况有所改变，linux的malloc已经经过了内存池的优化处理，所以这个方安在 linux上看起来是画蛇添足，但是经过自己测试辨认发现还是有回旋的余地。
   这是我的当初内存项添加的数据
   typedef union _MemItem
       {
          short size；
          union _MemItem *next;
       }MemItem;
这是linux自身malloc内存池附加的标记
struct mem_block {
    int is_available;    //这是一个标记
    int size;            //这是实际空间的大小
    };
显然的哦的更为合理有效，正常情况下只需要附加2个字节，但是linux的malloc需要至少8个字节，随后在测试中发现linux的malloc内存 池对于不同断的内存采取不同的管理方式，大约是80字节以前的分配效率是很高的，大于80以后is_available项就不是0或者1这两个值，而是 80的倍数，不明白意思，也不需要知道，只知道在此之后我的内存池就有接管的必要了，为了更好的配合linux，我将自己附加在内存中的值去掉了，合用系 统自身的，然后仅仅笃定是用InitPool个数的控制，比如我在测试中选用的是2000，那么所有申请内存在16＊16－2000＊16（后面的两个 16是Align步进，也就是256字节到32K之间的）之间的都转由我自定义的内存池控制，基本能够满足用户程序的需求，小于256的部分在加线程锁的 控制后系统本身的还要更优，过大的没有必要加以控制，这样就可以直接交给malloc free处理
   综上，我将以前windows上较为复杂的内存池改成如下简化形式：

     memorys.h


/*
* File:   memorys.h
* Author: net
*内存池
* Created on 2008年4月27日, 上午9:59
*/

#ifndef _MEMORYS_H
#define    _MEMORYS_H

#ifdef    __cplusplus
extern "C" {
#endif

#define InitMemPool 1000 //初始化池所能拥有的数量，不能超过255*255
#define Align 16       //对齐步进单位，4，8，16等等，每项所能容纳的最大内存为Align*index，index为short int，所以单项最大容量为Align*255*255字节，4字节对齐最大为260K，8字节对齐为512K
#define InitMemItem 12 //初始化池所能拥有的数量不能超过255*255
#define ExpendMemItem 12 //每次扩展池多少项。不能超过255*255
#define MaxMemory 1024*1024*300 //内存池最大容量 300M
#define MinBlock 256 //这是本内存池与malloc性能分界线的一个最小数字
#define MaxBlock Align*InitMemPool //超出上限
#define MinIndex 16 //pool Index所代表的大小不是从Align(16K)开始的
#define new(type) ((type *)(New(sizeof(type))))
#define sizes sizeof(MemPool)

#include "types.h"

/**
*该结构用一个自增长的链表结构体保存分链表，每个结构体中包含具体链表的头部、尾部和空闲分界线指针，维护一个链表
*大致结构如下：
*            MemPool
*     V       V      V      ...
*   链表1   链表2   链表3   ...
*通过这样一个结构系统就可以灵活增加减少系统池，并且可以控制池内结构，控制总数据量
*
*/



typedef struct _MemItem
{
    struct _MemItem *next;
}MemItem;

struct mem_block {
    int is_available;    //这是一个标记
    int size;            //这是实际空间的大小
    };

/*池集合*/
typedef struct _MemPool
{
    int name;//名称，同item_size，不管什么类型，申请的同一大小内存快放在同一个内存管理区域，视为同一名称，
    long max_memory;//最多占用的内存
    int init_item;//初始化多少item
    int per_expend_item;//每次扩展时一次申请多少项
    int current_item;//当前有多少项被使用
    int total_item;//共有多少项
    MemItem * first;//IO池头地址
    MemItem * last;//IO池最后一项的地址
    MemItem * current;//IO池分割空闲和使用中的分割地址
}MemPool;




/**
*取会给定结构的池结构体
*/
static Int AlignNum(Int size);
void InitPoolItem(unsigned int name);
void InitPool(void);/*初始化池*/
void FreePool(MemPool * p);/*释放池*/


void InitItem(unsigned int name);//初始化具体项的链表
void *New(unsigned int size);//初始化具体项的链表
void ExpendItem(unsigned int name);//初始化扩展项的链表
void Free(void *myp);//释放具体一项
void PrintPool(void);


#ifdef    __cplusplus
}
#endif

#endif    /* _MEMORYS_H */

memorys.c
/*
* File:   memorys.c
* Author: net
*
* Created on 2008年4月27日, 上午9:58
*/

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
/*
*
*/
#include "memorys.h"
#include "types.h"


pthread_mutex_t Memlock;

int indexs=1;
MemPool poolIndex[InitMemPool];
//Lock memLock;
static long totalByte;

/**
*取会给定结构的池结构体
*/


/*新定义一个池项*/
void InitPoolItem(unsigned int name) {
   
    MemPool p = poolIndex[name-MinIndex];
    /*基本链表设置*/
    p.name = name;
    p.first = NULL;
    p.last = NULL;
    p.current = NULL;
    /*设置杂项*/
    p.max_memory = 0;
    p.init_item = 0;
    p.per_expend_item = 0;
    p.current_item = 0;
    p.total_item = 0;
}

/*初始化池*/
void InitPool(void) {

    pthread_mutex_init(&Memlock,NULL);
    int i;
    MemPool p;
    for (i = 0; i < InitMemPool; i++) {
        p = poolIndex[i];
        /*基本链表设置*/
        p.name = i + MinIndex;
        p.first = NULL;
        p.last = NULL;
        p.current = NULL;
        /*设置杂项*/
        p.max_memory = 0;
        p.init_item = 0;
        p.per_expend_item = 0;
        p.current_item = 0;
        p.total_item = 0;
    }

}
void FreePool(MemPool *p)
{
    pthread_mutex_destroy(&Memlock);
    return;
}


/*初始化项*/
void InitItem(unsigned int name)
{
    int blk;
    MemItem *ip;/*项的链表指针*/
    /*构造容器*/
    MemPool *p=&poolIndex[name-MinIndex];

    (p->total_item)+=((p->init_item)==0?InitMemItem:(p->init_item));
    p->first=(MemItem *)malloc(name*Align);/*创建第一个块*/

    ip=p->first;
    for(blk=1;blk<(p->init_item==0?InitMemItem:p->init_item);++blk)
    {
        ip->next=(MemItem *)malloc(name*Align);
        ip=ip->next;
    }
    ip->next=NULL;
    p->last=ip;
   totalByte+=name*Align*(p->init_item==0?InitMemItem:p->init_item);
   
}
/*扩展当前池项的下属内存块*/
void ExpendItem(unsigned int name)
{
    int blk;
    MemItem *ip;/*项的链表指针*/
    /*构造容器*/
   
    MemPool *p=&poolIndex[name-MinIndex];

    p->total_item+=(p->per_expend_item==0?ExpendMemItem:p->per_expend_item);
    p->last->next=(MemItem *)malloc(name*Align);/*创建第一个块*/
    indexs++;
    ip=p->last->next;
    for(blk=1;blk<(p->per_expend_item==0?ExpendMemItem:p->per_expend_item);++blk)
    {
        ip->next=(MemItem *)malloc(name*Align);
        ip=ip->next;
        indexs++;
    }
    ip->next=NULL;
    p->last=ip;
    totalByte+=name*Align*(p->per_expend_item==0?ExpendMemItem:p->per_expend_item);
    //printf("kuozan ");

}
/*申请心内存-〉内存池*/
void *New(unsigned int size)
{
    //MemItem *ip;/*项的链表指针*/
    /*构造容器*/
    if(totalByte>MaxMemory)
        return NULL;/**申请的总内存过大，请调大默认最大内存设置或者检察内寻泄露*/
     //    printf("新大小: %d ",size);
    if(size>=MaxBlock||size<MinBlock)
    {
        return malloc(size);
    }
    size=((size+Align-1) &~ (Align-1))/Align;
      // printf("oo: %d ",size);
    MemPool *p=&poolIndex[size-MinIndex];
   
    if(p->first==NULL)
       InitItem(size);

        pthread_mutex_lock(&Memlock);
    if(p->first->next==NULL)
    {ExpendItem(size);}

    MemItem *ips;
    ips=p->first;
    p->first=p->first->next;
    p->current_item++;
    pthread_mutex_unlock(&Memlock);
    return ips;/*此处返回的是向后偏移过的指针*/



}

/*内存池回收*/
void Free(void *myp)
{

       struct mem_block * realsize=(struct mem_block *)myp;//转化为Short指针
    --realsize;/*向前移动short位移*/
   //    printf("释放:%i,%i",realsize->size,realsize->is_available);
       int size=realsize->size-9;
       ++realsize;
      
      if(size>=MaxBlock||size<MinBlock)
    {
        free(realsize);
        //printf("直接释放了一个大于管理范围的内存指针,最大值255*255*4 /n");
        return;
    }
        
      // printf("gg0:%d",size);
       size=((size+Align-1) &~ (Align-1))/Align;
      //         printf("gg1:%d",size);
    MemItem *ip=(MemItem *)realsize;/*转化回来*/
    MemPool *p=&poolIndex[size-MinIndex];

    if(p==NULL)
    {
        printf("试图释放一个不属于池的指针,直接释放了/n");
        return;
    }
      pthread_mutex_lock(&Memlock);
    if(p->first!=NULL)
    {
       
        ip->next=NULL;
        p->last->next=ip;
        p->last=p->last->next;
        p->current_item--;
       
    }
    else
    {
        printf("产生了一个野指针");
    }
pthread_mutex_unlock(&Memlock);
    return;
}
/*输出调试函数*/
void PrintPool(void)
{
    MemPool *pool;
        int i;
    for (i = 0; i < InitMemPool; i++) {
            pool=&poolIndex[i];
            if(pool->first!=NULL)
            {
        printf("/n名称%i 共有%i 使用%i,初始化:%i 当前地 址%p/n",pool->name,pool->total_item,pool->current_item,pool->init_item,pool->current);
        if(pool->total_item>0)
        {
            MemItem * mi=pool->first;
            while(mi!=NULL)
            {
                printf("--/t%p",mi);
                mi=mi->next;
            }
        }
            }
       
    }
}