标签：huge 语言 struct 分配 内存 mpool next page size

 
#include <iostream>
using namespace std;
#include <stdlib.h>
#include <stdio.h>
#include <stdio.h>
#include <memory.h>
#include <malloc.h>

struct _page {
    struct _page* next;
    char begin[0];
};
struct _huge_page {
    struct _huge_page* next;
    size_t size;
    char begin[0];
};
struct mpool {
    struct _page* pages;
    size_t npage;
    size_t size;
    size_t used; 
    size_t nalloc;
    struct _huge_page* huges;
    size_t nhuge;
};
struct mpool*
mpool_new(size_t page_size) {
    size_t cap = 1024;
    while (cap < page_size)
        cap *= 2;
    struct mpool* m = (struct mpool*)(malloc(sizeof(*m)));
    struct _page* p =  (struct _page*)(malloc(sizeof(*p) + cap));
    p->next = NULL;
    m->pages = p;
    m->npage = 1;
    m->size = cap;
    m->used = 0; 
    m->nalloc = 0;
    m->nhuge = 0;
    return m;
}
void
mpool_delete(struct mpool* m) {
    if (m) {
        struct _page* p; 
        while (m->pages) {
            p = m->pages;
            m->pages = p->next;
            free(p);
        }
        struct _huge_page* hp;
        while (m->huges) {
            hp = m->huges;
            m->huges = hp->next;
            free(hp);
        }
        free(m);
    }
}

void*
mpool_alloc(struct mpool* m, size_t n) {
    n = (n+3) & ~3;
    if (n >= m->size) {
        struct _huge_page* p =(struct _huge_page*)(malloc(sizeof(*p) + n));
        p->size = n;
        p->next = m->huges;
        m->huges = p;
        m->nhuge += 1;
        m->nalloc += n;
        return p->begin;
    }
    if (m->used + n > m->size) {
        struct _page* p = (struct _page*)(malloc(sizeof(*p) + m->size)); 
        p->next = m->pages;
        m->pages = p;
        m->npage += 1;
        m->used = 0;
        m->nalloc += n;
        return p->begin;
    } else {
        void* ptr = m->pages->begin + m->used;
        m->used += n;
        m->nalloc += n;
        return ptr;
    }
}

void*
mpool_realloc(struct mpool* m, void* p, size_t n) {
    return mpool_alloc(m, n);
}

void 
mpool_dump(struct mpool* m) {
    printf("[npage:%zu] ", m->npage);
    printf("[total pagesize:%zu] ", m->npage*m->size);
     
    printf("[nhuge:%zu] ", m->nhuge);
    size_t n = 0;
    struct _huge_page* h = m->huges;
    while (h) {
        n += h->size;
        h = h->next;
    }
    printf("[total huge size:%zu] ", n);

    printf("[nalloc:%zu]\n", m->nalloc);
}

int main()
{
   struct mpool* m;
  cout<<sizeof(*m)<<endl;
 
  return 0;
}

标签：huge,语言,struct,分配,内存,mpool,next,page,size
来源： https://www.cnblogs.com/hshy/p/15903002.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。