hyung-hwan/hcl
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

added some more statistics in xma

Browse Source
This commit is contained in:
hyung-hwan 2025-06-15 17:23:23 +09:00
parent 02748cd24d
commit af13a3363c
3 changed files with 200 additions and 142 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
lib/hcl-xma.h
View File

@ -72,9 +72,7 @@
*/ */
#include <hcl-cmn.h> #include <hcl-cmn.h>
#ifdef HCL_BUILD_DEBUG #define HCL_XMA_ENABLE_STAT
# define HCL_XMA_ENABLE_STAT
#endif
/** @struct hcl_xma_t /** @struct hcl_xma_t
* The hcl_xma_t type defines a simple memory allocator over a memory zone. * The hcl_xma_t type defines a simple memory allocator over a memory zone.
@ -105,14 +103,22 @@ struct hcl_xma_t
/** pre-computed value for fast xfree index calculation */ /** pre-computed value for fast xfree index calculation */
hcl_oow_t bdec; hcl_oow_t bdec;
#ifdef HCL_XMA_ENABLE_STAT #if defined(HCL_XMA_ENABLE_STAT)
struct struct
{ {
hcl_oow_t total; hcl_oow_t total;
hcl_oow_t alloc; hcl_oow_t alloc; /* allocated size */
hcl_oow_t avail; hcl_oow_t avail; /* available size */
hcl_oow_t nused; hcl_oow_t nused; /* nubmer of used blocks */
hcl_oow_t nfree; hcl_oow_t nfree; /* number of free blocks */
hcl_oow_t alloc_hwmark; /* high watermark - highest total memory ever allocated */
hcl_oow_t nallocops; /* number of alloc operations */
hcl_oow_t nallocgoodops; /* number of successful alloc operations */
hcl_oow_t nallocbadops; /* number of failed alloc operations */
hcl_oow_t nreallocops; /* number of realloc operations */
hcl_oow_t nreallocgoodops; /* number of good realloc operations */
hcl_oow_t nreallocbadops; /* number of failed realloc operations - could fall back to normal alloc*/
hcl_oow_t nfreeops; /* number of free operations */
} stat; } stat;
#endif #endif
}; };

175
lib/hcl.c
View File

@ -29,7 +29,7 @@ hcl_t* hcl_open (hcl_mmgr_t* mmgr, hcl_oow_t xtnsize, const hcl_vmprim_t* vmprim
hcl_t* hcl; hcl_t* hcl;
/* if this assertion fails, correct the type definition in hcl.h */ /* if this assertion fails, correct the type definition in hcl.h */
HCL_ASSERT (hcl, HCL_SIZEOF(hcl_oow_t) == HCL_SIZEOF(hcl_oop_t)); HCL_ASSERT(hcl, HCL_SIZEOF(hcl_oow_t) == HCL_SIZEOF(hcl_oop_t));
hcl = (hcl_t*)HCL_MMGR_ALLOC(mmgr, HCL_SIZEOF(*hcl) + xtnsize); hcl = (hcl_t*)HCL_MMGR_ALLOC(mmgr, HCL_SIZEOF(*hcl) + xtnsize);
if (hcl) if (hcl)
@ -106,7 +106,7 @@ static void* alloc_heap (hcl_t* hcl, hcl_oow_t* size)
static void free_heap (hcl_t* hcl, void* ptr) static void free_heap (hcl_t* hcl, void* ptr)
{ {
hcl_freemem (hcl, ptr); hcl_freemem(hcl, ptr);
} }
int hcl_init (hcl_t* hcl, hcl_mmgr_t* mmgr, const hcl_vmprim_t* vmprim) int hcl_init (hcl_t* hcl, hcl_mmgr_t* mmgr, const hcl_vmprim_t* vmprim)
@ -116,19 +116,19 @@ int hcl_init (hcl_t* hcl, hcl_mmgr_t* mmgr, const hcl_vmprim_t* vmprim)
if (!vmprim->syserrstrb && !vmprim->syserrstru) if (!vmprim->syserrstrb && !vmprim->syserrstru)
{ {
hcl_seterrnum (hcl, HCL_EINVAL); hcl_seterrnum(hcl, HCL_EINVAL);
return -1; return -1;
} }
#if !defined(HCL_BUILD_RELEASE) #if !defined(HCL_BUILD_RELEASE)
if (!vmprim->assertfail) if (!vmprim->assertfail)
{ {
hcl_seterrnum (hcl, HCL_EINVAL); hcl_seterrnum(hcl, HCL_EINVAL);
return -1; return -1;
} }
#endif #endif
HCL_MEMSET (hcl, 0, HCL_SIZEOF(*hcl)); HCL_MEMSET(hcl, 0, HCL_SIZEOF(*hcl));
hcl->_instsize = HCL_SIZEOF(*hcl); hcl->_instsize = HCL_SIZEOF(*hcl);
hcl->_mmgr = mmgr; hcl->_mmgr = mmgr;
hcl->_cmgr = hcl_get_utf8_cmgr(); hcl->_cmgr = hcl_get_utf8_cmgr();
@ -188,13 +188,13 @@ int hcl_init (hcl_t* hcl, hcl_mmgr_t* mmgr, const hcl_vmprim_t* vmprim)
return 0; return 0;
oops: oops:
if (modtab_inited) hcl_rbt_fini (&hcl->modtab); if (modtab_inited) hcl_rbt_fini(&hcl->modtab);
if (hcl->gci.stack.ptr) if (hcl->gci.stack.ptr)
{ {
hcl_freemem (hcl, hcl->gci.stack.ptr); hcl_freemem(hcl, hcl->gci.stack.ptr);
hcl->gci.stack.capa = 0; hcl->gci.stack.capa = 0;
} }
if (hcl->log.ptr) hcl_freemem (hcl, hcl->log.ptr); if (hcl->log.ptr) hcl_freemem(hcl, hcl->log.ptr);
hcl->log.capa = 0; hcl->log.capa = 0;
return -1; return -1;
} }
@ -205,10 +205,10 @@ static hcl_rbt_walk_t unload_module (hcl_rbt_t* rbt, hcl_rbt_pair_t* pair, void*
hcl_mod_data_t* mdp; hcl_mod_data_t* mdp;
mdp = (hcl_mod_data_t*)HCL_RBT_VPTR(pair); mdp = (hcl_mod_data_t*)HCL_RBT_VPTR(pair);
HCL_ASSERT (hcl, mdp != HCL_NULL); HCL_ASSERT(hcl, mdp != HCL_NULL);
mdp->pair = HCL_NULL; /* to prevent hcl_closemod() from calling hcl_rbt_delete() */ mdp->pair = HCL_NULL; /* to prevent hcl_closemod() from calling hcl_rbt_delete() */
hcl_closemod (hcl, mdp); hcl_closemod(hcl, mdp);
return HCL_RBT_WALK_FORWARD; return HCL_RBT_WALK_FORWARD;
} }
@ -218,14 +218,14 @@ void hcl_fini (hcl_t* hcl)
hcl_cb_t* cb; hcl_cb_t* cb;
hcl_oow_t i; hcl_oow_t i;
hcl_rbt_walk (&hcl->modtab, unload_module, hcl); hcl_rbt_walk(&hcl->modtab, unload_module, hcl);
hcl_rbt_fini (&hcl->modtab); hcl_rbt_fini(&hcl->modtab);
if (hcl->log.len > 0) if (hcl->log.len > 0)
{ {
/* flush pending log messages just in case. */ /* flush pending log messages just in case. */
HCL_ASSERT (hcl, hcl->log.ptr != HCL_NULL); HCL_ASSERT(hcl, hcl->log.ptr != HCL_NULL);
HCL_VMPRIM_LOG_WRITE (hcl, hcl->log.last_mask, hcl->log.ptr, hcl->log.len); HCL_VMPRIM_LOG_WRITE(hcl, hcl->log.last_mask, hcl->log.ptr, hcl->log.len);
} }
for (cb = hcl->cblist; cb; cb = cb->next) for (cb = hcl->cblist; cb; cb = cb->next)
@ -239,57 +239,57 @@ void hcl_fini (hcl_t* hcl)
* callbacks. however, the actual logging might not be produced at * callbacks. however, the actual logging might not be produced at
* this point because one of the callbacks could arrange to stop * this point because one of the callbacks could arrange to stop
* logging */ * logging */
HCL_ASSERT (hcl, hcl->log.ptr != HCL_NULL); HCL_ASSERT(hcl, hcl->log.ptr != HCL_NULL);
HCL_VMPRIM_LOG_WRITE (hcl, hcl->log.last_mask, hcl->log.ptr, hcl->log.len); HCL_VMPRIM_LOG_WRITE(hcl, hcl->log.last_mask, hcl->log.ptr, hcl->log.len);
} }
/* deregister all callbacks */ /* deregister all callbacks */
while (hcl->cblist) hcl_deregcb (hcl, hcl->cblist); while (hcl->cblist) hcl_deregcb(hcl, hcl->cblist);
/* detach the user data io handlers just in case */ /* detach the user data io handlers just in case */
hcl_detachudio (hcl); hcl_detachudio (hcl);
if (hcl->sem_list) if (hcl->sem_list)
{ {
hcl_freemem (hcl, hcl->sem_list); hcl_freemem(hcl, hcl->sem_list);
hcl->sem_list_capa = 0; hcl->sem_list_capa = 0;
hcl->sem_list_count = 0; hcl->sem_list_count = 0;
} }
if (hcl->sem_heap) if (hcl->sem_heap)
{ {
hcl_freemem (hcl, hcl->sem_heap); hcl_freemem(hcl, hcl->sem_heap);
hcl->sem_heap_capa = 0; hcl->sem_heap_capa = 0;
hcl->sem_heap_count = 0; hcl->sem_heap_count = 0;
} }
if (hcl->sem_io_tuple) if (hcl->sem_io_tuple)
{ {
hcl_freemem (hcl, hcl->sem_io_tuple); hcl_freemem(hcl, hcl->sem_io_tuple);
hcl->sem_io_tuple_capa = 0; hcl->sem_io_tuple_capa = 0;
hcl->sem_io_tuple_count = 0; hcl->sem_io_tuple_count = 0;
} }
if (hcl->sem_io_map) if (hcl->sem_io_map)
{ {
hcl_freemem (hcl, hcl->sem_io_map); hcl_freemem(hcl, hcl->sem_io_map);
hcl->sem_io_map_capa = 0; hcl->sem_io_map_capa = 0;
} }
if (hcl->proc_map) if (hcl->proc_map)
{ {
hcl_freemem (hcl, hcl->proc_map); hcl_freemem(hcl, hcl->proc_map);
hcl->proc_map_capa = 0; hcl->proc_map_capa = 0;
hcl->proc_map_used = 0; hcl->proc_map_used = 0;
hcl->proc_map_free_first = -1; hcl->proc_map_free_first = -1;
hcl->proc_map_free_last = -1; hcl->proc_map_free_last = -1;
} }
hcl_purgecode (hcl, &hcl->code); hcl_purgecode(hcl, &hcl->code);
if (hcl->p.s.ptr) if (hcl->p.s.ptr)
{ {
hcl_freemem (hcl, hcl->p.s.ptr); hcl_freemem(hcl, hcl->p.s.ptr);
hcl->p.s.ptr= HCL_NULL; hcl->p.s.ptr= HCL_NULL;
hcl->p.s.capa = 0; hcl->p.s.capa = 0;
hcl->p.s.size = 0; hcl->p.s.size = 0;
@ -302,51 +302,51 @@ void hcl_fini (hcl_t* hcl)
{ {
next = hcl->gci.b->next; next = hcl->gci.b->next;
hcl->gci.bsz -= HCL_SIZEOF(hcl_obj_t) + hcl_getobjpayloadbytes(hcl, (hcl_oop_t)(hcl->gci.b + 1)); hcl->gci.bsz -= HCL_SIZEOF(hcl_obj_t) + hcl_getobjpayloadbytes(hcl, (hcl_oop_t)(hcl->gci.b + 1));
hcl_freeheapmem (hcl, hcl->heap, hcl->gci.b); hcl_freeheapmem(hcl, hcl->heap, hcl->gci.b);
hcl->gci.b = next; hcl->gci.b = next;
} }
while (hcl->gci.b); while (hcl->gci.b);
HCL_ASSERT (hcl, hcl->gci.bsz == 0); HCL_ASSERT(hcl, hcl->gci.bsz == 0);
} }
if (hcl->gci.stack.ptr) if (hcl->gci.stack.ptr)
{ {
hcl_freemem (hcl, hcl->gci.stack.ptr); hcl_freemem(hcl, hcl->gci.stack.ptr);
hcl->gci.stack.ptr = 0; hcl->gci.stack.ptr = 0;
hcl->gci.stack.capa = 0; hcl->gci.stack.capa = 0;
hcl->gci.stack.len = 0; hcl->gci.stack.len = 0;
} }
if (hcl->heap) hcl_killheap (hcl, hcl->heap); if (hcl->heap) hcl_killheap(hcl, hcl->heap);
if (hcl->log.ptr) if (hcl->log.ptr)
{ {
hcl_freemem (hcl, hcl->log.ptr); hcl_freemem(hcl, hcl->log.ptr);
hcl->log.capa = 0; hcl->log.capa = 0;
hcl->log.len = 0; hcl->log.len = 0;
} }
if (hcl->option.log_target_u) if (hcl->option.log_target_u)
{ {
hcl_freemem (hcl, hcl->option.log_target_u); hcl_freemem(hcl, hcl->option.log_target_u);
hcl->option.log_target_u = HCL_NULL; hcl->option.log_target_u = HCL_NULL;
} }
if (hcl->option.log_target_b) if (hcl->option.log_target_b)
{ {
hcl_freemem (hcl, hcl->option.log_target_b); hcl_freemem(hcl, hcl->option.log_target_b);
hcl->option.log_target_b = HCL_NULL; hcl->option.log_target_b = HCL_NULL;
} }
for (i = 0; i < HCL_COUNTOF(hcl->option.mod); i++) for (i = 0; i < HCL_COUNTOF(hcl->option.mod); i++)
{ {
if (hcl->option.mod[i].ptr) hcl_freemem (hcl, hcl->option.mod[i].ptr); if (hcl->option.mod[i].ptr) hcl_freemem(hcl, hcl->option.mod[i].ptr);
} }
if (hcl->inttostr.xbuf.ptr) if (hcl->inttostr.xbuf.ptr)
{ {
hcl_freemem (hcl, hcl->inttostr.xbuf.ptr); hcl_freemem(hcl, hcl->inttostr.xbuf.ptr);
hcl->inttostr.xbuf.ptr = HCL_NULL; hcl->inttostr.xbuf.ptr = HCL_NULL;
hcl->inttostr.xbuf.capa = 0; hcl->inttostr.xbuf.capa = 0;
hcl->inttostr.xbuf.len = 0; hcl->inttostr.xbuf.len = 0;
@ -354,14 +354,14 @@ void hcl_fini (hcl_t* hcl)
if (hcl->inttostr.t.ptr) if (hcl->inttostr.t.ptr)
{ {
hcl_freemem (hcl, hcl->inttostr.t.ptr); hcl_freemem(hcl, hcl->inttostr.t.ptr);
hcl->inttostr.t.ptr = HCL_NULL; hcl->inttostr.t.ptr = HCL_NULL;
hcl->inttostr.t.capa = 0; hcl->inttostr.t.capa = 0;
} }
if (hcl->sprintf.xbuf.ptr) if (hcl->sprintf.xbuf.ptr)
{ {
hcl_freemem (hcl, hcl->sprintf.xbuf.ptr); hcl_freemem(hcl, hcl->sprintf.xbuf.ptr);
hcl->sprintf.xbuf.ptr = HCL_NULL; hcl->sprintf.xbuf.ptr = HCL_NULL;
hcl->sprintf.xbuf.capa = 0; hcl->sprintf.xbuf.capa = 0;
hcl->sprintf.xbuf.len = 0; hcl->sprintf.xbuf.len = 0;
@ -384,7 +384,7 @@ void hcl_resetcode (hcl_t* hcl)
{ {
hcl_oop_t key = HCL_CONS_CAR(v); hcl_oop_t key = HCL_CONS_CAR(v);
if (!HCL_IS_SYMBOL(hcl,key) || !HCL_OBJ_GET_FLAGS_KERNEL(key)) if (!HCL_IS_SYMBOL(hcl,key) || !HCL_OBJ_GET_FLAGS_KERNEL(key))
hcl_zapatsysdic (hcl, HCL_CONS_CAR(v)); hcl_zapatsysdic(hcl, HCL_CONS_CAR(v));
} }
} }
@ -393,7 +393,7 @@ void hcl_resetcode (hcl_t* hcl)
hcl->code.lit.len = 0; hcl->code.lit.len = 0;
/* clean up object memory */ /* clean up object memory */
hcl_gc (hcl, 1); hcl_gc(hcl, 1);
} }
void hcl_clearcode (hcl_t* hcl) void hcl_clearcode (hcl_t* hcl)
@ -452,7 +452,7 @@ int hcl_setoption (hcl_t* hcl, hcl_option_t id, const void* value)
v2 = hcl_dupbtoucstr(hcl, (const hcl_bch_t*)value, HCL_NULL); v2 = hcl_dupbtoucstr(hcl, (const hcl_bch_t*)value, HCL_NULL);
if (HCL_UNLIKELY(!v2)) if (HCL_UNLIKELY(!v2))
{ {
hcl_freemem (hcl, v1); hcl_freemem(hcl, v1);
return -1; return -1;
} }
@ -472,7 +472,7 @@ int hcl_setoption (hcl_t* hcl, hcl_option_t id, const void* value)
v2 = hcl_duputobcstr(hcl, (const hcl_uch_t*)value, HCL_NULL); v2 = hcl_duputobcstr(hcl, (const hcl_uch_t*)value, HCL_NULL);
if (HCL_UNLIKELY(!v2)) if (HCL_UNLIKELY(!v2))
{ {
hcl_freemem (hcl, v1); hcl_freemem(hcl, v1);
return -1; return -1;
} }
@ -493,7 +493,7 @@ int hcl_setoption (hcl_t* hcl, hcl_option_t id, const void* value)
v2 = hcl_dupbtouchars(hcl, v->ptr, v->len, HCL_NULL); v2 = hcl_dupbtouchars(hcl, v->ptr, v->len, HCL_NULL);
if (HCL_UNLIKELY(!v2)) if (HCL_UNLIKELY(!v2))
{ {
hcl_freemem (hcl, v1); hcl_freemem(hcl, v1);
return -1; return -1;
} }
@ -514,7 +514,7 @@ int hcl_setoption (hcl_t* hcl, hcl_option_t id, const void* value)
v2 = hcl_duputobchars(hcl, v->ptr, v->len, HCL_NULL); v2 = hcl_duputobchars(hcl, v->ptr, v->len, HCL_NULL);
if (HCL_UNLIKELY(!v2)) if (HCL_UNLIKELY(!v2))
{ {
hcl_freemem (hcl, v1); hcl_freemem(hcl, v1);
return -1; return -1;
} }
@ -566,7 +566,7 @@ int hcl_setoption (hcl_t* hcl, hcl_option_t id, const void* value)
if (dup_str_opt(hcl, (const hcl_ooch_t*)value, &tmp) <= -1) return -1; if (dup_str_opt(hcl, (const hcl_ooch_t*)value, &tmp) <= -1) return -1;
idx = id - HCL_MOD_LIBDIRS; idx = id - HCL_MOD_LIBDIRS;
if (hcl->option.mod[idx].ptr) hcl_freemem (hcl, hcl->option.mod[idx].ptr); if (hcl->option.mod[idx].ptr) hcl_freemem(hcl, hcl->option.mod[idx].ptr);
hcl->option.mod[idx] = tmp; hcl->option.mod[idx] = tmp;
return 0; return 0;
@ -582,13 +582,13 @@ int hcl_setoption (hcl_t* hcl, hcl_option_t id, const void* value)
for (cb = hcl->cblist; cb; cb = cb->next) for (cb = hcl->cblist; cb; cb = cb->next)
{ {
if (cb->on_option) cb->on_option (hcl, id, value); if (cb->on_option) cb->on_option(hcl, id, value);
} }
return 0; return 0;
einval: einval:
hcl_seterrnum (hcl, HCL_EINVAL); hcl_seterrnum(hcl, HCL_EINVAL);
return -1; return -1;
} }
@ -649,7 +649,7 @@ int hcl_getoption (hcl_t* hcl, hcl_option_t id, void* value)
return 0; return 0;
}; };
hcl_seterrnum (hcl, HCL_EINVAL); hcl_seterrnum(hcl, HCL_EINVAL);
return -1; return -1;
} }
@ -690,10 +690,10 @@ void hcl_deregcb (hcl_t* hcl, hcl_cb_t* cb)
if (cb->vm_checkbc) if (cb->vm_checkbc)
{ {
HCL_ASSERT (hcl, hcl->vm_checkbc_cb_count > 0); HCL_ASSERT(hcl, hcl->vm_checkbc_cb_count > 0);
hcl->vm_checkbc_cb_count--; hcl->vm_checkbc_cb_count--;
} }
hcl_freemem (hcl, cb); hcl_freemem(hcl, cb);
} }
void* hcl_allocmem (hcl_t* hcl, hcl_oow_t size) void* hcl_allocmem (hcl_t* hcl, hcl_oow_t size)
@ -701,7 +701,7 @@ void* hcl_allocmem (hcl_t* hcl, hcl_oow_t size)
void* ptr; void* ptr;
ptr = HCL_MMGR_ALLOC(HCL_MMGR(hcl), size); ptr = HCL_MMGR_ALLOC(HCL_MMGR(hcl), size);
if (!ptr) hcl_seterrnum (hcl, HCL_ESYSMEM); if (!ptr) hcl_seterrnum(hcl, HCL_ESYSMEM);
return ptr; return ptr;
} }
@ -710,7 +710,7 @@ void* hcl_callocmem (hcl_t* hcl, hcl_oow_t size)
void* ptr; void* ptr;
ptr = HCL_MMGR_ALLOC(HCL_MMGR(hcl), size); ptr = HCL_MMGR_ALLOC(HCL_MMGR(hcl), size);
if (!ptr) hcl_seterrnum (hcl, HCL_ESYSMEM); if (!ptr) hcl_seterrnum(hcl, HCL_ESYSMEM);
else HCL_MEMSET (ptr, 0, size); else HCL_MEMSET (ptr, 0, size);
return ptr; return ptr;
} }
@ -718,7 +718,7 @@ void* hcl_callocmem (hcl_t* hcl, hcl_oow_t size)
void* hcl_reallocmem (hcl_t* hcl, void* ptr, hcl_oow_t size) void* hcl_reallocmem (hcl_t* hcl, void* ptr, hcl_oow_t size)
{ {
ptr = HCL_MMGR_REALLOC(HCL_MMGR(hcl), ptr, size); ptr = HCL_MMGR_REALLOC(HCL_MMGR(hcl), ptr, size);
if (!ptr) hcl_seterrnum (hcl, HCL_ESYSMEM); if (!ptr) hcl_seterrnum(hcl, HCL_ESYSMEM);
return ptr; return ptr;
} }
@ -777,11 +777,11 @@ hcl_mod_data_t* hcl_openmod (hcl_t* hcl, const hcl_ooch_t* name, hcl_oow_t namel
if (namelen > HCL_COUNTOF(buf) - (MOD_PREFIX_LEN + 1 + 1)) if (namelen > HCL_COUNTOF(buf) - (MOD_PREFIX_LEN + 1 + 1))
{ {
/* module name too long */ /* module name too long */
hcl_seterrnum (hcl, HCL_EINVAL); /* TODO: change the error number to something more specific */ hcl_seterrnum(hcl, HCL_EINVAL); /* TODO: change the error number to something more specific */
return HCL_NULL; return HCL_NULL;
} }
hcl_copy_oochars (&buf[MOD_PREFIX_LEN], name, namelen); hcl_copy_oochars(&buf[MOD_PREFIX_LEN], name, namelen);
buf[MOD_PREFIX_LEN + namelen] = '\0'; buf[MOD_PREFIX_LEN + namelen] = '\0';
#if defined(HCL_ENABLE_STATIC_MODULE) #if defined(HCL_ENABLE_STATIC_MODULE)
@ -801,7 +801,7 @@ hcl_mod_data_t* hcl_openmod (hcl_t* hcl, const hcl_ooch_t* name, hcl_oow_t namel
{ {
/* found the module in the static module table */ /* found the module in the static module table */
HCL_MEMSET (&md, 0, HCL_SIZEOF(md)); HCL_MEMSET(&md, 0, HCL_SIZEOF(md));
md.mod.inctx = hcl->option.mod_inctx; md.mod.inctx = hcl->option.mod_inctx;
hcl_copy_oochars ((hcl_ooch_t*)md.mod.name, name, namelen); hcl_copy_oochars ((hcl_ooch_t*)md.mod.name, name, namelen);
/* Note md.handle is HCL_NULL for a static module */ /* Note md.handle is HCL_NULL for a static module */
@ -811,40 +811,40 @@ hcl_mod_data_t* hcl_openmod (hcl_t* hcl, const hcl_ooch_t* name, hcl_oow_t namel
pair = hcl_rbt_insert(&hcl->modtab, (hcl_ooch_t*)name, namelen, &md, HCL_SIZEOF(md)); pair = hcl_rbt_insert(&hcl->modtab, (hcl_ooch_t*)name, namelen, &md, HCL_SIZEOF(md));
if (HCL_UNLIKELY(!pair)) if (HCL_UNLIKELY(!pair))
{ {
hcl_seterrbfmt (hcl, HCL_ESYSMEM, "insufficient system memory in storing static module handle"); hcl_seterrbfmt(hcl, HCL_ESYSMEM, "insufficient system memory in storing static module handle");
return HCL_NULL; return HCL_NULL;
} }
mdp = (hcl_mod_data_t*)HCL_RBT_VPTR(pair); mdp = (hcl_mod_data_t*)HCL_RBT_VPTR(pair);
if (load(hcl, &mdp->mod) <= -1) if (load(hcl, &mdp->mod) <= -1)
{ {
hcl_rbt_delete (&hcl->modtab, (hcl_ooch_t*)name, namelen); hcl_rbt_delete(&hcl->modtab, (hcl_ooch_t*)name, namelen);
return HCL_NULL; return HCL_NULL;
} }
mdp->pair = pair; mdp->pair = pair;
HCL_DEBUG1 (hcl, "Opened a static module [%js]\n", mdp->mod.name); HCL_DEBUG1(hcl, "Opened a static module [%js]\n", mdp->mod.name);
return mdp; return mdp;
} }
else else
{ {
#if !defined(HCL_ENABLE_DYNAMIC_MODULE) #if !defined(HCL_ENABLE_DYNAMIC_MODULE)
HCL_DEBUG2 (hcl, "Cannot find a static module [%.*js]\n", namelen, name); HCL_DEBUG2(hcl, "Cannot find a static module [%.*js]\n", namelen, name);
hcl_seterrbfmt (hcl, HCL_ENOENT, "unable to find a static module [%.*js]", namelen, name); hcl_seterrbfmt(hcl, HCL_ENOENT, "unable to find a static module [%.*js]", namelen, name);
return HCL_NULL; return HCL_NULL;
#endif #endif
} }
#endif #endif
#if !defined(HCL_ENABLE_DYNAMIC_MODULE) #if !defined(HCL_ENABLE_DYNAMIC_MODULE)
HCL_DEBUG2 (hcl, "Cannot open module [%.*js] - module loading disabled\n", namelen, name); HCL_DEBUG2(hcl, "Cannot open module [%.*js] - module loading disabled\n", namelen, name);
hcl_seterrbfmt (hcl, HCL_ENOIMPL, "unable to open module [%.*js] - module loading disabled", namelen, name); hcl_seterrbfmt(hcl, HCL_ENOIMPL, "unable to open module [%.*js] - module loading disabled", namelen, name);
return HCL_NULL; return HCL_NULL;
#endif #endif
/* attempt to find a dynamic external module */ /* attempt to find a dynamic external module */
HCL_MEMSET (&md, 0, HCL_SIZEOF(md)); HCL_MEMSET(&md, 0, HCL_SIZEOF(md));
md.mod.inctx = hcl->option.mod_inctx; md.mod.inctx = hcl->option.mod_inctx;
hcl_copy_oochars((hcl_ooch_t*)md.mod.name, name, namelen); hcl_copy_oochars((hcl_ooch_t*)md.mod.name, name, namelen);
if (hcl->vmprim.dl_open && hcl->vmprim.dl_getsym && hcl->vmprim.dl_close) if (hcl->vmprim.dl_open && hcl->vmprim.dl_getsym && hcl->vmprim.dl_close)
@ -854,8 +854,8 @@ hcl_mod_data_t* hcl_openmod (hcl_t* hcl, const hcl_ooch_t* name, hcl_oow_t namel
if (md.handle == HCL_NULL) if (md.handle == HCL_NULL)
{ {
HCL_DEBUG2 (hcl, "Cannot open a module [%.*js]\n", namelen, name); HCL_DEBUG2(hcl, "Cannot open a module [%.*js]\n", namelen, name);
hcl_seterrbfmt (hcl, HCL_ENOENT, "unable to open a module [%.*js]", namelen, name); hcl_seterrbfmt(hcl, HCL_ENOENT, "unable to open a module [%.*js]", namelen, name);
return HCL_NULL; return HCL_NULL;
} }
@ -863,9 +863,9 @@ hcl_mod_data_t* hcl_openmod (hcl_t* hcl, const hcl_ooch_t* name, hcl_oow_t namel
load = (hcl_mod_load_t)hcl->vmprim.dl_getsym(hcl, md.handle, buf); load = (hcl_mod_load_t)hcl->vmprim.dl_getsym(hcl, md.handle, buf);
if (!load) if (!load)
{ {
hcl_seterrbfmt (hcl, HCL_ERRNUM(hcl), "unable to get module symbol [%js] in [%.*js]", buf, namelen, name); hcl_seterrbfmt(hcl, HCL_ERRNUM(hcl), "unable to get module symbol [%js] in [%.*js]", buf, namelen, name);
HCL_DEBUG3 (hcl, "Cannot get a module symbol [%js] in [%.*js]\n", buf, namelen, name); HCL_DEBUG3(hcl, "Cannot get a module symbol [%js] in [%.*js]\n", buf, namelen, name);
hcl->vmprim.dl_close (hcl, md.handle); hcl->vmprim.dl_close(hcl, md.handle);
return HCL_NULL; return HCL_NULL;
} }
@ -874,9 +874,9 @@ hcl_mod_data_t* hcl_openmod (hcl_t* hcl, const hcl_ooch_t* name, hcl_oow_t namel
pair = hcl_rbt_insert(&hcl->modtab, (void*)name, namelen, &md, HCL_SIZEOF(md)); pair = hcl_rbt_insert(&hcl->modtab, (void*)name, namelen, &md, HCL_SIZEOF(md));
if (pair == HCL_NULL) if (pair == HCL_NULL)
{ {
HCL_DEBUG2 (hcl, "Cannot register a module [%.*js]\n", namelen, name); HCL_DEBUG2(hcl, "Cannot register a module [%.*js]\n", namelen, name);
hcl_seterrbfmt (hcl, HCL_ESYSMEM, "unable to register a module [%.*js] for memory shortage", namelen, name); hcl_seterrbfmt(hcl, HCL_ESYSMEM, "unable to register a module [%.*js] for memory shortage", namelen, name);
hcl->vmprim.dl_close (hcl, md.handle); hcl->vmprim.dl_close(hcl, md.handle);
return HCL_NULL; return HCL_NULL;
} }
@ -884,42 +884,42 @@ hcl_mod_data_t* hcl_openmod (hcl_t* hcl, const hcl_ooch_t* name, hcl_oow_t namel
if (load(hcl, &mdp->mod) <= -1) if (load(hcl, &mdp->mod) <= -1)
{ {
const hcl_ooch_t* oldmsg = hcl_backuperrmsg (hcl); const hcl_ooch_t* oldmsg = hcl_backuperrmsg (hcl);
hcl_seterrbfmt (hcl, HCL_ERRNUM(hcl), "module initializer [%js] returned failure in [%.*js] - %js", buf, namelen, name, oldmsg); hcl_seterrbfmt(hcl, HCL_ERRNUM(hcl), "module initializer [%js] returned failure in [%.*js] - %js", buf, namelen, name, oldmsg);
HCL_DEBUG3 (hcl, "Module function [%js] returned failure in [%.*js]\n", buf, namelen, name); HCL_DEBUG3(hcl, "Module function [%js] returned failure in [%.*js]\n", buf, namelen, name);
hcl_rbt_delete (&hcl->modtab, name, namelen); hcl_rbt_delete(&hcl->modtab, name, namelen);
hcl->vmprim.dl_close (hcl, mdp->handle); hcl->vmprim.dl_close(hcl, mdp->handle);
return HCL_NULL; return HCL_NULL;
} }
mdp->pair = pair; mdp->pair = pair;
HCL_DEBUG2 (hcl, "Opened a module [%js] - %p\n", mdp->mod.name, mdp->handle); HCL_DEBUG2(hcl, "Opened a module [%js] - %p\n", mdp->mod.name, mdp->handle);
/* the module loader must ensure to set a proper query handler */ /* the module loader must ensure to set a proper query handler */
HCL_ASSERT (hcl, mdp->mod.query != HCL_NULL); HCL_ASSERT(hcl, mdp->mod.query != HCL_NULL);
return mdp; return mdp;
} }
void hcl_closemod (hcl_t* hcl, hcl_mod_data_t* mdp) void hcl_closemod (hcl_t* hcl, hcl_mod_data_t* mdp)
{ {
if (mdp->mod.unload) mdp->mod.unload (hcl, &mdp->mod); if (mdp->mod.unload) mdp->mod.unload(hcl, &mdp->mod);
if (mdp->handle) if (mdp->handle)
{ {
hcl->vmprim.dl_close (hcl, mdp->handle); hcl->vmprim.dl_close(hcl, mdp->handle);
HCL_DEBUG2 (hcl, "Closed a module [%js] - %p\n", mdp->mod.name, mdp->handle); HCL_DEBUG2(hcl, "Closed a module [%js] - %p\n", mdp->mod.name, mdp->handle);
mdp->handle = HCL_NULL; mdp->handle = HCL_NULL;
} }
else else
{ {
HCL_DEBUG1 (hcl, "Closed a static module [%js]\n", mdp->mod.name); HCL_DEBUG1(hcl, "Closed a static module [%js]\n", mdp->mod.name);
} }
if (mdp->pair) if (mdp->pair)
{ {
/*mdp->pair = HCL_NULL;*/ /* this reset isn't needed as the area will get freed by hcl_rbt_delete()) */ /*mdp->pair = HCL_NULL;*/ /* this reset isn't needed as the area will get freed by hcl_rbt_delete()) */
hcl_rbt_delete (&hcl->modtab, mdp->mod.name, hcl_count_oocstr(mdp->mod.name)); hcl_rbt_delete(&hcl->modtab, mdp->mod.name, hcl_count_oocstr(mdp->mod.name));
} }
} }
@ -943,8 +943,8 @@ hcl_pfbase_t* hcl_querymod (hcl_t* hcl, const hcl_ooch_t* pfid, hcl_oow_t pfidle
* guarantee that a period is included in an primitive function identifer. * guarantee that a period is included in an primitive function identifer.
* what if the compiler is broken? imagine a buggy compiler rewritten * what if the compiler is broken? imagine a buggy compiler rewritten
* in hcl itself? */ * in hcl itself? */
HCL_DEBUG2 (hcl, "Internal error - no period in a primitive function identifier [%.*js] - buggy compiler?\n", pfidlen, pfid); HCL_DEBUG2(hcl, "Internal error - no period in a primitive function identifier [%.*js] - buggy compiler?\n", pfidlen, pfid);
hcl_seterrbfmt (hcl, HCL_EINTERN, "no period in a primitive function identifier [%.*js]", pfidlen, pfid); hcl_seterrbfmt(hcl, HCL_EINTERN, "no period in a primitive function identifier [%.*js]", pfidlen, pfid);
return HCL_NULL; return HCL_NULL;
} }
@ -958,7 +958,7 @@ hcl_pfbase_t* hcl_querymod (hcl_t* hcl, const hcl_ooch_t* pfid, hcl_oow_t pfidle
if (pair) if (pair)
{ {
mdp = (hcl_mod_data_t*)HCL_RBT_VPTR(pair); mdp = (hcl_mod_data_t*)HCL_RBT_VPTR(pair);
HCL_ASSERT (hcl, mdp != HCL_NULL); HCL_ASSERT(hcl, mdp != HCL_NULL);
} }
else else
{ {
@ -970,15 +970,14 @@ hcl_pfbase_t* hcl_querymod (hcl_t* hcl, const hcl_ooch_t* pfid, hcl_oow_t pfidle
if ((pfbase = mdp->mod.query(hcl, &mdp->mod, sep + 1, pfidlen - mod_name_len - 1)) == HCL_NULL) if ((pfbase = mdp->mod.query(hcl, &mdp->mod, sep + 1, pfidlen - mod_name_len - 1)) == HCL_NULL)
{ {
/* the primitive function is not found. but keep the module open even if it's opened above */ /* the primitive function is not found. but keep the module open even if it's opened above */
HCL_DEBUG3 (hcl, "Cannot find a primitive function [%.*js] in a module [%js]\n", pfidlen - mod_name_len - 1, sep + 1, mdp->mod.name); HCL_DEBUG3(hcl, "Cannot find a primitive function [%.*js] in a module [%js]\n", pfidlen - mod_name_len - 1, sep + 1, mdp->mod.name);
hcl_seterrbfmt (hcl, HCL_ENOENT, "unable to find a primitive function [%.*js] in a module [%js]", pfidlen - mod_name_len - 1, sep + 1, mdp->mod.name); hcl_seterrbfmt(hcl, HCL_ENOENT, "unable to find a primitive function [%.*js] in a module [%js]", pfidlen - mod_name_len - 1, sep + 1, mdp->mod.name);
return HCL_NULL; return HCL_NULL;
} }
*mod = &mdp->mod; *mod = &mdp->mod;
HCL_DEBUG4 (hcl, "Found a primitive function [%.*js] in a module [%js] - %p\n", HCL_DEBUG4(hcl, "Found a primitive function [%.*js] in a module [%js] - %p\n", pfidlen - mod_name_len - 1, sep + 1, mdp->mod.name, pfbase);
pfidlen - mod_name_len - 1, sep + 1, mdp->mod.name, pfbase);
return pfbase; return pfbase;
} }
@ -1014,7 +1013,7 @@ hcl_pfbase_t* hcl_findpfbase (hcl_t* hcl, hcl_pfinfo_t* pfinfo, hcl_oow_t pfcoun
} }
#endif #endif
hcl_seterrnum (hcl, HCL_ENOENT); hcl_seterrnum(hcl, HCL_ENOENT);
return HCL_NULL; return HCL_NULL;
} }

145
lib/xma.c
View File

@ -250,7 +250,7 @@ int hcl_xma_init (hcl_xma_t* xma, hcl_mmgr_t* mmgr, void* zoneptr, hcl_oow_t zon
first->free_prev = HCL_NULL; first->free_prev = HCL_NULL;
first->free_next = HCL_NULL; first->free_next = HCL_NULL;
HCL_MEMSET (xma, 0, HCL_SIZEOF(*xma)); HCL_MEMSET(xma, 0, HCL_SIZEOF(*xma));
xma->_mmgr = mmgr; xma->_mmgr = mmgr;
xma->bdec = szlog2(FIXED * ALIGN); /* precalculate the decrement value */ xma->bdec = szlog2(FIXED * ALIGN); /* precalculate the decrement value */
@ -272,6 +272,15 @@ int hcl_xma_init (hcl_xma_t* xma, hcl_mmgr_t* mmgr, void* zoneptr, hcl_oow_t zon
xma->stat.avail = zonesize - MBLKHDRSIZE; xma->stat.avail = zonesize - MBLKHDRSIZE;
xma->stat.nfree = 1; xma->stat.nfree = 1;
xma->stat.nused = 0; xma->stat.nused = 0;
xma->stat.alloc_hwmark = 0;
xma->stat.nallocops = 0;
xma->stat.nallocgoodops = 0;
xma->stat.nallocbadops = 0;
xma->stat.nreallocops = 0;
xma->stat.nreallocgoodops = 0;
xma->stat.nreallocbadops = 0;
xma->stat.nfreeops = 0;
#endif #endif
return 0; return 0;
@ -343,7 +352,7 @@ static hcl_xma_fblk_t* alloc_from_freelist (hcl_xma_t* xma, hcl_oow_t xfi, hcl_o
{ {
hcl_oow_t rem; hcl_oow_t rem;
detach_from_freelist (xma, cand); detach_from_freelist(xma, cand);
rem = cand->size - size; rem = cand->size - size;
if (rem >= FBLKMINSIZE) if (rem >= FBLKMINSIZE)
@ -366,7 +375,7 @@ static hcl_xma_fblk_t* alloc_from_freelist (hcl_xma_t* xma, hcl_oow_t xfi, hcl_o
y->prev_size = cand->size; y->prev_size = cand->size;
/* add the remaining part to the free list */ /* add the remaining part to the free list */
attach_to_freelist (xma, (hcl_xma_fblk_t*)y); attach_to_freelist(xma, (hcl_xma_fblk_t*)y);
z = next_mblk(y); z = next_mblk(y);
if ((hcl_uint8_t*)z < xma->end) z->prev_size = y->size; if ((hcl_uint8_t*)z < xma->end) z->prev_size = y->size;
@ -394,6 +403,7 @@ static hcl_xma_fblk_t* alloc_from_freelist (hcl_xma_t* xma, hcl_oow_t xfi, hcl_o
xma->stat.nused++; xma->stat.nused++;
xma->stat.alloc += cand->size; xma->stat.alloc += cand->size;
xma->stat.avail -= cand->size; xma->stat.avail -= cand->size;
if (xma->stat.alloc > xma->stat.alloc_hwmark) xma->stat.alloc_hwmark = xma->stat.alloc;
#endif #endif
return cand; return cand;
} }
@ -408,7 +418,11 @@ void* hcl_xma_alloc (hcl_xma_t* xma, hcl_oow_t size)
hcl_xma_fblk_t* cand; hcl_xma_fblk_t* cand;
hcl_oow_t xfi; hcl_oow_t xfi;
DBG_VERIFY (xma, "alloc start"); DBG_VERIFY(xma, "alloc start");
#if defined(HCL_XMA_ENABLE_STAT)
xma->stat.nallocops++;
#endif
/* round up 'size' to the multiples of ALIGN */ /* round up 'size' to the multiples of ALIGN */
if (size < MINALLOCSIZE) size = MINALLOCSIZE; if (size < MINALLOCSIZE) size = MINALLOCSIZE;
@ -426,7 +440,7 @@ void* hcl_xma_alloc (hcl_xma_t* xma, hcl_oow_t size)
assert (cand->free != 0); assert (cand->free != 0);
assert (cand->size == size); assert (cand->size == size);
detach_from_freelist (xma, cand); detach_from_freelist(xma, cand);
cand->free = 0; cand->free = 0;
#if defined(HCL_XMA_ENABLE_STAT) #if defined(HCL_XMA_ENABLE_STAT)
@ -434,13 +448,20 @@ void* hcl_xma_alloc (hcl_xma_t* xma, hcl_oow_t size)
xma->stat.nused++; xma->stat.nused++;
xma->stat.alloc += cand->size; xma->stat.alloc += cand->size;
xma->stat.avail -= cand->size; xma->stat.avail -= cand->size;
if (xma->stat.alloc > xma->stat.alloc_hwmark) xma->stat.alloc_hwmark = xma->stat.alloc;
#endif #endif
} }
else if (xfi == XFIMAX(xma)) else if (xfi == XFIMAX(xma))
{ {
/* huge block */ /* huge block */
cand = alloc_from_freelist(xma, XFIMAX(xma), size); cand = alloc_from_freelist(xma, XFIMAX(xma), size);
if (!cand) return HCL_NULL; if (!cand)
{
#if defined(HCL_XMA_ENABLE_STAT)
xma->stat.nallocbadops++;
#endif
return HCL_NULL;
}
} }
else else
{ {
@ -469,11 +490,20 @@ void* hcl_xma_alloc (hcl_xma_t* xma, hcl_oow_t size)
cand = alloc_from_freelist(xma, xfi, size); cand = alloc_from_freelist(xma, xfi, size);
if (cand) break; if (cand) break;
} }
if (!cand) return HCL_NULL; if (!cand)
{
#if defined(HCL_XMA_ENABLE_STAT)
xma->stat.nallocbadops++;
#endif
return HCL_NULL;
}
} }
} }
DBG_VERIFY (xma, "alloc end"); #if defined(HCL_XMA_ENABLE_STAT)
xma->stat.nallocgoodops++;
#endif
DBG_VERIFY(xma, "alloc end");
return SYS_TO_USR(cand); return SYS_TO_USR(cand);
} }
@ -481,7 +511,7 @@ static void* _realloc_merge (hcl_xma_t* xma, void* b, hcl_oow_t size)
{ {
hcl_xma_mblk_t* blk = (hcl_xma_mblk_t*)USR_TO_SYS(b); hcl_xma_mblk_t* blk = (hcl_xma_mblk_t*)USR_TO_SYS(b);
DBG_VERIFY (xma, "realloc merge start"); DBG_VERIFY(xma, "realloc merge start");
/* rounds up 'size' to be multiples of ALIGN */ /* rounds up 'size' to be multiples of ALIGN */
if (size < MINALLOCSIZE) size = MINALLOCSIZE; if (size < MINALLOCSIZE) size = MINALLOCSIZE;
size = HCL_ALIGN_POW2(size, ALIGN); size = HCL_ALIGN_POW2(size, ALIGN);
@ -504,7 +534,7 @@ static void* _realloc_merge (hcl_xma_t* xma, void* b, hcl_oow_t size)
assert (blk->size == n->prev_size); assert (blk->size == n->prev_size);
/* let's merge the current block with the next block */ /* let's merge the current block with the next block */
detach_from_freelist (xma, (hcl_xma_fblk_t*)n); detach_from_freelist(xma, (hcl_xma_fblk_t*)n);
rem = (MBLKHDRSIZE + n->size) - req; rem = (MBLKHDRSIZE + n->size) - req;
if (rem >= FBLKMINSIZE) if (rem >= FBLKMINSIZE)
@ -521,7 +551,7 @@ static void* _realloc_merge (hcl_xma_t* xma, void* b, hcl_oow_t size)
y->free = 1; y->free = 1;
y->size = rem - MBLKHDRSIZE; y->size = rem - MBLKHDRSIZE;
y->prev_size = blk->size; y->prev_size = blk->size;
attach_to_freelist (xma, (hcl_xma_fblk_t*)y); attach_to_freelist(xma, (hcl_xma_fblk_t*)y);
z = next_mblk(y); z = next_mblk(y);
if ((hcl_uint8_t*)z < xma->end) z->prev_size = y->size; if ((hcl_uint8_t*)z < xma->end) z->prev_size = y->size;
@ -529,6 +559,7 @@ static void* _realloc_merge (hcl_xma_t* xma, void* b, hcl_oow_t size)
#if defined(HCL_XMA_ENABLE_STAT) #if defined(HCL_XMA_ENABLE_STAT)
xma->stat.alloc += req; xma->stat.alloc += req;
xma->stat.avail -= req; /* req + MBLKHDRSIZE(tmp) - MBLKHDRSIZE(n) */ xma->stat.avail -= req; /* req + MBLKHDRSIZE(tmp) - MBLKHDRSIZE(n) */
if (xma->stat.alloc > xma->stat.alloc_hwmark) xma->stat.alloc_hwmark = xma->stat.alloc;
#endif #endif
} }
else else
@ -546,6 +577,7 @@ static void* _realloc_merge (hcl_xma_t* xma, void* b, hcl_oow_t size)
xma->stat.nfree--; xma->stat.nfree--;
xma->stat.alloc += MBLKHDRSIZE + n->size; xma->stat.alloc += MBLKHDRSIZE + n->size;
xma->stat.avail -= n->size; xma->stat.avail -= n->size;
if (xma->stat.alloc > xma->stat.alloc_hwmark) xma->stat.alloc_hwmark = xma->stat.alloc;
#endif #endif
} }
} }
@ -566,7 +598,7 @@ static void* _realloc_merge (hcl_xma_t* xma, void* b, hcl_oow_t size)
/* make the leftover block merge with the next block */ /* make the leftover block merge with the next block */
detach_from_freelist (xma, (hcl_xma_fblk_t*)n); detach_from_freelist(xma, (hcl_xma_fblk_t*)n);
blk->size = size; blk->size = size;
@ -576,7 +608,7 @@ static void* _realloc_merge (hcl_xma_t* xma, void* b, hcl_oow_t size)
y->prev_size = blk->size; y->prev_size = blk->size;
/* add 'y' to the free list */ /* add 'y' to the free list */
attach_to_freelist (xma, (hcl_xma_fblk_t*)y); attach_to_freelist(xma, (hcl_xma_fblk_t*)y);
z = next_mblk(y); /* get adjacent block to the merged block */ z = next_mblk(y); /* get adjacent block to the merged block */
if ((hcl_uint8_t*)z < xma->end) z->prev_size = y->size; if ((hcl_uint8_t*)z < xma->end) z->prev_size = y->size;
@ -598,7 +630,7 @@ static void* _realloc_merge (hcl_xma_t* xma, void* b, hcl_oow_t size)
y->size = rem - MBLKHDRSIZE; y->size = rem - MBLKHDRSIZE;
y->prev_size = blk->size; y->prev_size = blk->size;
attach_to_freelist (xma, (hcl_xma_fblk_t*)y); attach_to_freelist(xma, (hcl_xma_fblk_t*)y);
/*n = next_mblk(y); /*n = next_mblk(y);
if ((hcl_uint8_t*)n < xma->end)*/ n->prev_size = y->size; if ((hcl_uint8_t*)n < xma->end)*/ n->prev_size = y->size;
@ -611,7 +643,7 @@ static void* _realloc_merge (hcl_xma_t* xma, void* b, hcl_oow_t size)
} }
} }
DBG_VERIFY (xma, "realloc merge end"); DBG_VERIFY(xma, "realloc merge end");
return b; return b;
} }
@ -626,7 +658,7 @@ void* hcl_xma_realloc (hcl_xma_t* xma, void* b, hcl_oow_t size)
{ {
void* n; void* n;
if (b == HCL_NULL) if (!b)
{ {
/* 'realloc' with NULL is the same as 'alloc' */ /* 'realloc' with NULL is the same as 'alloc' */
n = hcl_xma_alloc(xma, size); n = hcl_xma_alloc(xma, size);
@ -634,18 +666,30 @@ void* hcl_xma_realloc (hcl_xma_t* xma, void* b, hcl_oow_t size)
else else
{ {
/* try reallocation by merging the adjacent continuous blocks */ /* try reallocation by merging the adjacent continuous blocks */
n = _realloc_merge (xma, b, size); #if defined(HAWK_XMA_ENABLE_STAT)
xma->stat.nreallocops++;
#endif
n = _realloc_merge(xma, b, size);
if (!n) if (!n)
{ {
#if defined(HCL_XMA_ENABLE_STAT)
xma->stat.nreallocbadops++;
#endif
/* reallocation by merging failed. fall back to the slow /* reallocation by merging failed. fall back to the slow
* allocation-copy-free scheme */ * allocation-copy-free scheme */
n = hcl_xma_alloc(xma, size); n = hcl_xma_alloc(xma, size);
if (n) if (n)
{ {
HCL_MEMCPY (n, b, size); HCL_MEMCPY(n, b, size);
hcl_xma_free (xma, b); hcl_xma_free(xma, b);
} }
} }
else
{
#if defined(HCL_XMA_ENABLE_STAT)
xma->stat.nreallocgoodops++;
#endif
}
} }
return n; return n;
@ -657,7 +701,7 @@ void hcl_xma_free (hcl_xma_t* xma, void* b)
hcl_xma_mblk_t* x, * y; hcl_xma_mblk_t* x, * y;
hcl_oow_t org_blk_size; hcl_oow_t org_blk_size;
DBG_VERIFY (xma, "free start"); DBG_VERIFY(xma, "free start");
org_blk_size = blk->size; org_blk_size = blk->size;
@ -665,6 +709,7 @@ void hcl_xma_free (hcl_xma_t* xma, void* b)
/* update statistical variables */ /* update statistical variables */
xma->stat.nused--; xma->stat.nused--;
xma->stat.alloc -= org_blk_size; xma->stat.alloc -= org_blk_size;
xma->stat.nfreeops++;
#endif #endif
x = prev_mblk(blk); x = prev_mblk(blk);
@ -692,11 +737,11 @@ void hcl_xma_free (hcl_xma_t* xma, void* b)
hcl_oow_t ns = MBLKHDRSIZE + org_blk_size + MBLKHDRSIZE; hcl_oow_t ns = MBLKHDRSIZE + org_blk_size + MBLKHDRSIZE;
hcl_oow_t bs = ns + y->size; hcl_oow_t bs = ns + y->size;
detach_from_freelist (xma, (hcl_xma_fblk_t*)x); detach_from_freelist(xma, (hcl_xma_fblk_t*)x);
detach_from_freelist (xma, (hcl_xma_fblk_t*)y); detach_from_freelist(xma, (hcl_xma_fblk_t*)y);
x->size += bs; x->size += bs;
attach_to_freelist (xma, (hcl_xma_fblk_t*)x); attach_to_freelist(xma, (hcl_xma_fblk_t*)x);
z = next_mblk(x); z = next_mblk(x);
if ((hcl_uint8_t*)z < xma->end) z->prev_size = x->size; if ((hcl_uint8_t*)z < xma->end) z->prev_size = x->size;
@ -732,7 +777,7 @@ void hcl_xma_free (hcl_xma_t* xma, void* b)
hcl_xma_mblk_t* z = next_mblk(y); hcl_xma_mblk_t* z = next_mblk(y);
/* detach y from the free list */ /* detach y from the free list */
detach_from_freelist (xma, (hcl_xma_fblk_t*)y); detach_from_freelist(xma, (hcl_xma_fblk_t*)y);
/* update the block availability */ /* update the block availability */
blk->free = 1; blk->free = 1;
@ -743,7 +788,7 @@ void hcl_xma_free (hcl_xma_t* xma, void* b)
if ((hcl_uint8_t*)z < xma->end) z->prev_size = blk->size; if ((hcl_uint8_t*)z < xma->end) z->prev_size = blk->size;
/* attach blk to the free list */ /* attach blk to the free list */
attach_to_freelist (xma, (hcl_xma_fblk_t*)blk); attach_to_freelist(xma, (hcl_xma_fblk_t*)blk);
#if defined(HCL_XMA_ENABLE_STAT) #if defined(HCL_XMA_ENABLE_STAT)
xma->stat.avail += org_blk_size + MBLKHDRSIZE; xma->stat.avail += org_blk_size + MBLKHDRSIZE;
@ -765,14 +810,14 @@ void hcl_xma_free (hcl_xma_t* xma, void* b)
* | X | Y | * | X | Y |
* +-------------------------+------------+ * +-------------------------+------------+
*/ */
detach_from_freelist (xma, (hcl_xma_fblk_t*)x); detach_from_freelist(xma, (hcl_xma_fblk_t*)x);
x->size += MBLKHDRSIZE + org_blk_size; x->size += MBLKHDRSIZE + org_blk_size;
assert (y == next_mblk(x)); assert (y == next_mblk(x));
if ((hcl_uint8_t*)y < xma->end) y->prev_size = x->size; if ((hcl_uint8_t*)y < xma->end) y->prev_size = x->size;
attach_to_freelist (xma, (hcl_xma_fblk_t*)x); attach_to_freelist(xma, (hcl_xma_fblk_t*)x);
#if defined(HCL_XMA_ENABLE_STAT) #if defined(HCL_XMA_ENABLE_STAT)
xma->stat.avail += MBLKHDRSIZE + org_blk_size; xma->stat.avail += MBLKHDRSIZE + org_blk_size;
@ -781,7 +826,7 @@ void hcl_xma_free (hcl_xma_t* xma, void* b)
else else
{ {
blk->free = 1; blk->free = 1;
attach_to_freelist (xma, (hcl_xma_fblk_t*)blk); attach_to_freelist(xma, (hcl_xma_fblk_t*)blk);
#if defined(HCL_XMA_ENABLE_STAT) #if defined(HCL_XMA_ENABLE_STAT)
xma->stat.nfree++; xma->stat.nfree++;
@ -789,7 +834,7 @@ void hcl_xma_free (hcl_xma_t* xma, void* b)
#endif #endif
} }
DBG_VERIFY (xma, "free end"); DBG_VERIFY(xma, "free end");
} }
void hcl_xma_dump (hcl_xma_t* xma, hcl_xma_dumper_t dumper, void* ctx) void hcl_xma_dump (hcl_xma_t* xma, hcl_xma_dumper_t dumper, void* ctx)
@ -800,20 +845,21 @@ void hcl_xma_dump (hcl_xma_t* xma, hcl_xma_dumper_t dumper, void* ctx)
hcl_oow_t isum; hcl_oow_t isum;
#endif #endif
dumper (ctx, "<XMA DUMP>\n"); dumper(ctx, "[XMA DUMP]\n");
#if defined(HCL_XMA_ENABLE_STAT) #if defined(HCL_XMA_ENABLE_STAT)
dumper (ctx, "== statistics ==\n"); dumper(ctx, "== statistics ==\n");
dumper (ctx, "total = %zu\n", xma->stat.total); dumper(ctx, "Total = %zu\n", xma->stat.total);
dumper (ctx, "alloc = %zu\n", xma->stat.alloc); dumper(ctx, "Alloc = %zu\n", xma->stat.alloc);
dumper (ctx, "avail = %zu\n", xma->stat.avail); dumper(ctx, "Avail = %zu\n", xma->stat.avail);
dumper(ctx, "Alloc High Watermark = %zu\n", xma->stat.alloc_hwmark);
#endif #endif
dumper (ctx, "== blocks ==\n"); dumper(ctx, "== blocks ==\n");
dumper (ctx, " size avail address\n"); dumper(ctx, " size avail address\n");
for (tmp = (hcl_xma_mblk_t*)xma->start, fsum = 0, asum = 0; (hcl_uint8_t*)tmp < xma->end; tmp = next_mblk(tmp)) for (tmp = (hcl_xma_mblk_t*)xma->start, fsum = 0, asum = 0; (hcl_uint8_t*)tmp < xma->end; tmp = next_mblk(tmp))
{ {
dumper (ctx, " %-18zu %-5u %p\n", tmp->size, (unsigned int)tmp->free, tmp); dumper(ctx, " %-18zu %-5u %p\n", tmp->size, (unsigned int)tmp->free, tmp);
if (tmp->free) fsum += tmp->size; if (tmp->free) fsum += tmp->size;
else asum += tmp->size; else asum += tmp->size;
} }
@ -822,21 +868,28 @@ void hcl_xma_dump (hcl_xma_t* xma, hcl_xma_dumper_t dumper, void* ctx)
isum = (xma->stat.nfree + xma->stat.nused) * MBLKHDRSIZE; isum = (xma->stat.nfree + xma->stat.nused) * MBLKHDRSIZE;
#endif #endif
dumper (ctx, "---------------------------------------\n"); dumper(ctx, "---------------------------------------\n");
dumper (ctx, "Allocated blocks: %18zu bytes\n", asum); dumper(ctx, "Allocated blocks : %18zu bytes\n", asum);
dumper (ctx, "Available blocks: %18zu bytes\n", fsum); dumper(ctx, "Available blocks : %18zu bytes\n", fsum);
#if defined(HCL_XMA_ENABLE_STAT) #if defined(HCL_XMA_ENABLE_STAT)
dumper (ctx, "Internal use : %18zu bytes\n", isum); dumper(ctx, "Internal use : %18zu bytes\n", isum);
dumper (ctx, "Total : %18zu bytes\n", (asum + fsum + isum)); dumper(ctx, "Total : %18zu bytes\n", (asum + fsum + isum));
dumper(ctx, "Alloc operations : %18zu\n", xma->stat.nallocops);
dumper(ctx, "Good alloc operations : %18zu\n", xma->stat.nallocgoodops);
dumper(ctx, "Bad alloc operations : %18zu\n", xma->stat.nallocbadops);
dumper(ctx, "Realloc operations : %18zu\n", xma->stat.nreallocops);
dumper(ctx, "Good realloc operations: %18zu\n", xma->stat.nreallocgoodops);
dumper(ctx, "Bad realloc operations : %18zu\n", xma->stat.nreallocbadops);
dumper(ctx, "Free operations : %18zu\n", xma->stat.nfreeops);
#endif #endif
#if defined(HCL_XMA_ENABLE_STAT) #if defined(HCL_XMA_ENABLE_STAT)
assert (asum == xma->stat.alloc); HCL_ASSERT(hcl, asum == xma->stat.alloc);
assert (fsum == xma->stat.avail); HCL_ASSERT(hcl, fsum == xma->stat.avail);
assert (isum == xma->stat.total - (xma->stat.alloc + xma->stat.avail)); HCL_ASSERT(hcl, isum == xma->stat.total - (xma->stat.alloc + xma->stat.avail));
assert (asum + fsum + isum == xma->stat.total); HCL_ASSERT(hcl, asum + fsum + isum == xma->stat.total);
#endif #endif
} }