/*

** pool.c - memory pool

** mempool.c - memory pool

**

** See Copyright Notice in mruby.h

*/

#include <string.h>

#include <mruby.h>

#include <mruby/mempool.h>

/* configuration section */

/* allocated memory address should be multiple of POOL_ALIGNMENT */

#pragma warning(disable : 4200)

#endif

struct mrb_pool_page {

struct mrb_pool_page *next;

struct mrb_mempool_page {

struct mrb_mempool_page *next;

size_t offset;

size_t len;

void *last;

#pragma warning(pop)

#endif

struct mrb_pool {

struct mrb_mempool {

mrb_state *mrb;

struct mrb_pool_page *pages;

struct mrb_mempool_page *pages;

};

#undef TEST_POOL

# define ALIGN_PADDING(x) (0)

#endif

MRB_API mrb_pool*

mrb_pool_open(mrb_state *mrb)

MRB_API mrb_mempool*

mrb_mempool_open(mrb_state *mrb)

{

mrb_pool *pool = (mrb_pool*)mrb_malloc_simple(mrb, sizeof(mrb_pool));

mrb_mempool *pool = (mrb_mempool*)mrb_malloc_simple(mrb, sizeof(mrb_mempool));

if (pool) {

pool->mrb = mrb;

}

MRB_API void

mrb_pool_close(mrb_pool *pool)

mrb_mempool_close(mrb_mempool *pool)

{

struct mrb_pool_page *page;

struct mrb_mempool_page *page;

if (!pool) return;

page = pool->pages;

while (page) {

struct mrb_pool_page *tmp = page;

struct mrb_mempool_page *tmp = page;

page = page->next;

mrb_free(pool->mrb, tmp);

}

mrb_free(pool->mrb, pool);

}

static struct mrb_pool_page*

page_alloc(mrb_pool *pool, size_t len)

static struct mrb_mempool_page*

page_alloc(mrb_mempool *pool, size_t len)

{

struct mrb_pool_page *page;

struct mrb_mempool_page *page;

if (len < POOL_PAGE_SIZE)

len = POOL_PAGE_SIZE;

page = (struct mrb_pool_page*)mrb_malloc_simple(pool->mrb, sizeof(struct mrb_pool_page)+len);

page = (struct mrb_mempool_page*)mrb_malloc_simple(pool->mrb, sizeof(struct mrb_mempool_page)+len);

if (page) {

page->offset = 0;

page->len = len;

}

MRB_API void*

mrb_pool_alloc(mrb_pool *pool, size_t len)

mrb_mempool_alloc(mrb_mempool *pool, size_t len)

{

struct mrb_pool_page *page;

struct mrb_mempool_page *page;

if (!pool) return NULL;

len += ALIGN_PADDING(len);

}

MRB_API void*

mrb_pool_realloc(mrb_pool *pool, void *p, size_t oldlen, size_t newlen)

mrb_mempool_realloc(mrb_mempool *pool, void *p, size_t oldlen, size_t newlen)

{

if (!pool) return NULL;

if (newlen < oldlen) return p;

oldlen += ALIGN_PADDING(oldlen);

newlen += ALIGN_PADDING(newlen);

for (struct mrb_pool_page *page = pool->pages; page; page = page->next) {

for (struct mrb_mempool_page *page = pool->pages; page; page = page->next) {

if (page->last == p) {

/* if p is a last allocation from the page */

size_t beg = (char*)p - page->page;

return p;

}

}

void *np = mrb_pool_alloc(pool, newlen);

void *np = mrb_mempool_alloc(pool, newlen);

if (np == NULL) {

return NULL;

}

main(void)

{

int i, len = 250;

mrb_pool *pool;

mrb_mempool *pool;

void *p;

pool = mrb_pool_open(NULL);

p = mrb_pool_alloc(pool, len);

pool = mrb_mempool_open(NULL);

p = mrb_mempool_alloc(pool, len);

for (i=1; i<20; i++) {

printf("%p (len=%d)\n", p, len);

p = mrb_pool_realloc(pool, p, len, len*2);

p = mrb_mempool_realloc(pool, p, len, len*2);

len *= 2;

}

mrb_pool_close(pool);

mrb_mempool_close(pool);

return 0;

}

#endif