mempool.c: renamed from pool.c

To avoid confusion with pools in irep, we renamed region-based memory
manager from pool to mempool.

- rename pool.c to mempool.c
- separate mempool.h
- rename all mrb_pool to mrb_mempool

So if someone is using pool.c functions (I suppose no one does though),
they need to rename all `mrb_pool` to `mrb_mempool` and include
`mruby/mempool.h` header at the top.

include/mruby.h

@@ -1514,13 +1514,6 @@ MRB_API mrb_value mrb_fiber_alive_p(mrb_state *mrb, mrb_value fib);
 #define E_FIBER_ERROR mrb_exc_get_id(mrb, MRB_ERROR_SYM(FiberError))
 MRB_API void mrb_stack_extend(mrb_state*, mrb_int);
 
-/* memory pool implementation */
-typedef struct mrb_pool mrb_pool;
-MRB_API struct mrb_pool* mrb_pool_open(mrb_state*);
-MRB_API void mrb_pool_close(struct mrb_pool*);
-MRB_API void* mrb_pool_alloc(struct mrb_pool*, size_t);
-MRB_API void* mrb_pool_realloc(struct mrb_pool*, void*, size_t oldlen, size_t newlen);
-MRB_API mrb_bool mrb_pool_can_realloc(struct mrb_pool*, void*, size_t);
 /* temporary memory allocation, only effective while GC arena is kept */
 MRB_API void* mrb_alloca(mrb_state *mrb, size_t);
 

include/mruby/compile.h

@@ -8,6 +8,7 @@
 #define MRUBY_COMPILE_H
 
 #include "common.h"
+#include "mruby/mempool.h"
 
 /**
  * mruby Compiler
@@ -122,7 +123,7 @@ struct mrb_parser_heredoc_info {
 /* parser structure */
 struct mrb_parser_state {
   mrb_state *mrb;
-  struct mrb_pool *pool;
+  struct mrb_mempool *pool;
   mrb_ast_node *cells;
   const char *s, *send;
 #ifndef MRB_NO_STDIO

include/mruby/mempool.h

@@ -0,0 +1,13 @@
+/*
+** mempool.h - memory pool
+**
+** See Copyright Notice in mruby.h
+*/
+
+/* memory pool implementation */
+typedef struct mrb_mempool mrb_mempool;
+MRB_API struct mrb_mempool* mrb_mempool_open(mrb_state*);
+MRB_API void mrb_mempool_close(struct mrb_mempool*);
+MRB_API void* mrb_mempool_alloc(struct mrb_mempool*, size_t);
+MRB_API void* mrb_mempool_realloc(struct mrb_mempool*, void*, size_t oldlen, size_t newlen);
+MRB_API mrb_bool mrb_mempool_can_realloc(struct mrb_mempool*, void*, size_t);

mrbgems/mruby-compiler/core/codegen.c

@@ -48,7 +48,7 @@ struct loopinfo {
 
 typedef struct scope {
   mrb_state *mrb;
-  mrb_pool *mpool;
+  mrb_mempool *mpool;
 
   struct scope *prev;
 
@@ -144,7 +144,7 @@ codegen_error(codegen_scope *s, const char *message)
       }
       mrb_free(s->mrb, s->lines);
     }
-    mrb_pool_close(s->mpool);
+    mrb_mempool_close(s->mpool);
     s = tmp;
   }
   MRB_THROW(s->mrb->jmp);
@@ -153,7 +153,7 @@ codegen_error(codegen_scope *s, const char *message)
 static void*
 codegen_palloc(codegen_scope *s, size_t len)
 {
-  void *p = mrb_pool_alloc(s->mpool, len);
+  void *p = mrb_mempool_alloc(s->mpool, len);
 
   if (!p) codegen_error(s, "pool memory allocation");
   return p;
@@ -3837,8 +3837,8 @@ static codegen_scope*
 scope_new(mrb_state *mrb, codegen_scope *prev, node *nlv)
 {
   static const codegen_scope codegen_scope_zero = { 0 };
-  mrb_pool *pool = mrb_pool_open(mrb);
-  codegen_scope *s = (codegen_scope*)mrb_pool_alloc(pool, sizeof(codegen_scope));
+  mrb_mempool *pool = mrb_mempool_open(mrb);
+  codegen_scope *s = (codegen_scope*)mrb_mempool_alloc(pool, sizeof(codegen_scope));
 
   if (!s) {
     if (prev)
@@ -3944,7 +3944,7 @@ scope_finish(codegen_scope *s)
   irep->nregs = s->nregs;
 
   mrb_gc_arena_restore(mrb, s->ai);
-  mrb_pool_close(s->mpool);
+  mrb_mempool_close(s->mpool);
 }
 
 static struct loopinfo*
@@ -4073,7 +4073,7 @@ generate_code(mrb_state *mrb, parser_state *p, int val)
     codegen(scope, p->tree, val);
     proc = mrb_proc_new(mrb, scope->irep);
     mrb_irep_decref(mrb, scope->irep);
-    mrb_pool_close(scope->mpool);
+    mrb_mempool_close(scope->mpool);
     proc->c = NULL;
     if (mrb->c->cibase && mrb->c->cibase->proc == proc->upper) {
       proc->upper = NULL;
@@ -4083,7 +4083,7 @@ generate_code(mrb_state *mrb, parser_state *p, int val)
   }
   MRB_CATCH(mrb->jmp) {
     mrb_irep_decref(mrb, scope->irep);
-    mrb_pool_close(scope->mpool);
+    mrb_mempool_close(scope->mpool);
     mrb->jmp = prev_jmp;
     return NULL;
   }

mrbgems/mruby-compiler/core/parse.y

@@ -110,7 +110,7 @@ cons_free_gen(parser_state *p, node *cons)
 static void*
 parser_palloc(parser_state *p, size_t size)
 {
-  void *m = mrb_pool_alloc(p->pool, size);
+  void *m = mrb_mempool_alloc(p->pool, size);
 
   if (!m) {
     MRB_THROW(p->mrb->jmp);
@@ -1058,7 +1058,7 @@ static node*
 composite_string_node(parser_state *p, node *a, node *b)
 {
   size_t newlen = (size_t)a->cdr + (size_t)b->cdr;
-  char *str = (char*)mrb_pool_realloc(p->pool, a->car, (size_t)a->cdr + 1, newlen + 1);
+  char *str = (char*)mrb_mempool_realloc(p->pool, a->car, (size_t)a->cdr + 1, newlen + 1);
   memcpy(str + (size_t)a->cdr, b->car, (size_t)b->cdr);
   str[newlen] = '\0';
   a->car = (node*)str;
@@ -6668,13 +6668,13 @@ mrb_parser_parse(parser_state *p, mrb_ccontext *c)
 MRB_API parser_state*
 mrb_parser_new(mrb_state *mrb)
 {
-  mrb_pool *pool;
+  mrb_mempool *pool;
   parser_state *p;
   static const parser_state parser_state_zero = { 0 };
 
-  pool = mrb_pool_open(mrb);
+  pool = mrb_mempool_open(mrb);
   if (!pool) return NULL;
-  p = (parser_state*)mrb_pool_alloc(pool, sizeof(parser_state));
+  p = (parser_state*)mrb_mempool_alloc(pool, sizeof(parser_state));
   if (!p) return NULL;
 
   *p = parser_state_zero;
@@ -6712,7 +6712,7 @@ mrb_parser_free(parser_state *p) {
   if (p->tokbuf != p->buf) {
     mrb_free(p->mrb, p->tokbuf);
   }
-  mrb_pool_close(p->pool);
+  mrb_mempool_close(p->pool);
 }
 
 MRB_API mrb_ccontext*

src/mempool.c

@@ -1,11 +1,12 @@
 /*
-** 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 */
@@ -30,8 +31,8 @@
 #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;
@@ -42,9 +43,9 @@ struct mrb_pool_page {
 #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
@@ -60,10 +61,10 @@ struct mrb_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;
@@ -73,28 +74,28 @@ mrb_pool_open(mrb_state *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;
@@ -104,9 +105,9 @@ page_alloc(mrb_pool *pool, size_t 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);
@@ -129,13 +130,13 @@ mrb_pool_alloc(mrb_pool *pool, size_t 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;
@@ -152,7 +153,7 @@ mrb_pool_realloc(mrb_pool *pool, void *p, size_t oldlen, size_t newlen)
       return p;
     }
   }
-  void *np = mrb_pool_alloc(pool, newlen);
+  void *np = mrb_mempool_alloc(pool, newlen);
   if (np == NULL) {
     return NULL;
   }
@@ -165,17 +166,17 @@ int
 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