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

fixed a bug in string cache managment.

Browse Source 
added mbs cache management
This commit is contained in:
hyung-hwan 2020-03-20 06:05:28 +00:00
parent 7fe9ea0936
commit adcbf748a2
3 changed files with 105 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
hawk/lib/hawk-prv.h
View File

@ -48,10 +48,17 @@ typedef struct hawk_tree_t hawk_tree_t;
#include "err-prv.h" #include "err-prv.h"
#include "misc-prv.h" #include "misc-prv.h"
#define ENABLE_FEATURE_SCACHE //#define HAWK_ENABLE_GC
#define FEATURE_SCACHE_NUM_BLOCKS 16 #define HAWK_ENABLE_STR_CACHE
#define FEATURE_SCACHE_BLOCK_UNIT 16 #define HAWK_ENABLE_MBS_CACHE
#define FEATURE_SCACHE_BLOCK_SIZE 128
#define HAWK_STR_CACHE_NUM_BLOCKS 16
#define HAWK_STR_CACHE_BLOCK_UNIT 16
#define HAWK_STR_CACHE_BLOCK_SIZE 128
#define HAWK_MBS_CACHE_NUM_BLOCKS 16
#define HAWK_MBS_CACHE_BLOCK_UNIT 16
#define HAWK_MBS_CACHE_BLOCK_SIZE 128
/* [NOTE] the function value support implemented is very limited. /* [NOTE] the function value support implemented is very limited.
* it supports very primitive way to call a function via a variable. * it supports very primitive way to call a function via a variable.
@ -366,9 +373,14 @@ struct hawk_rtx_t
hawk_val_ref_t* rcache[128]; hawk_val_ref_t* rcache[128];
hawk_oow_t rcache_count; hawk_oow_t rcache_count;
#if defined(ENABLE_FEATURE_SCACHE) #if defined(HAWK_ENABLE_STR_CACHE)
hawk_val_str_t* scache[FEATURE_SCACHE_NUM_BLOCKS][FEATURE_SCACHE_BLOCK_SIZE]; hawk_val_str_t* str_cache[HAWK_STR_CACHE_NUM_BLOCKS][HAWK_STR_CACHE_BLOCK_SIZE];
hawk_oow_t scache_count[FEATURE_SCACHE_NUM_BLOCKS]; hawk_oow_t str_cache_count[HAWK_STR_CACHE_NUM_BLOCKS];
#endif
#if defined(HAWK_ENABLE_MBS_CACHE)
hawk_val_mbs_t* mbs_cache[HAWK_MBS_CACHE_NUM_BLOCKS][HAWK_MBS_CACHE_BLOCK_SIZE];
hawk_oow_t mbs_cache_count[HAWK_MBS_CACHE_NUM_BLOCKS];
#endif #endif
struct struct

28
hawk/lib/run.c
View File

@ -1252,14 +1252,28 @@ static void fini_rtx (hawk_rtx_t* rtx, int fini_globals)
hawk_rtx_freeval (rtx, (hawk_val_t*)tmp, 0); hawk_rtx_freeval (rtx, (hawk_val_t*)tmp, 0);
} }
#if defined(ENABLE_FEATURE_SCACHE) #if defined(HAWK_ENABLE_STR_CACHE)
{ {
int i; int i;
for (i = 0; i < HAWK_COUNTOF(rtx->scache_count); i++) for (i = 0; i < HAWK_COUNTOF(rtx->str_cache_count); i++)
{ {
while (rtx->scache_count[i] > 0) while (rtx->str_cache_count[i] > 0)
{ {
hawk_val_str_t* t = rtx->scache[i][--rtx->scache_count[i]]; hawk_val_str_t* t = rtx->str_cache[i][--rtx->str_cache_count[i]];
hawk_rtx_freeval (rtx, (hawk_val_t*)t, 0);
}
}
}
#endif
#if defined(HAWK_ENABLE_MBS_CACHE)
{
int i;
for (i = 0; i < HAWK_COUNTOF(rtx->mbs_cache_count); i++)
{
while (rtx->mbs_cache_count[i] > 0)
{
hawk_val_str_t* t = rtx->mbs_cache[i][--rtx->mbs_cache_count[i]];
hawk_rtx_freeval (rtx, (hawk_val_t*)t, 0); hawk_rtx_freeval (rtx, (hawk_val_t*)t, 0);
} }
} }
@ -3652,6 +3666,7 @@ static hawk_val_t* do_assignment_nonidx (hawk_rtx_t* rtx, hawk_nde_var_t* var, h
hawk_rtx_seterrfmt (rtx, &var->loc, HAWK_EMAPTOSCALAR, HAWK_T("not allowed to change a map '%.*js' to a scalar"), var->id.name.len, var->id.name.ptr); hawk_rtx_seterrfmt (rtx, &var->loc, HAWK_EMAPTOSCALAR, HAWK_T("not allowed to change a map '%.*js' to a scalar"), var->id.name.len, var->id.name.ptr);
return HAWK_NULL; return HAWK_NULL;
} }
#if !defined(HAWK_ENABLE_GC)
else if (vtype == HAWK_VAL_MAP) else if (vtype == HAWK_VAL_MAP)
{ {
/* old value is not a map but a new value is a map. /* old value is not a map but a new value is a map.
@ -3659,6 +3674,7 @@ static hawk_val_t* do_assignment_nonidx (hawk_rtx_t* rtx, hawk_nde_var_t* var, h
hawk_rtx_seterrfmt (rtx, &var->loc, HAWK_EMAPTOVAR, HAWK_T("not allowed to assign a map to a variable '%.*js'"), var->id.name.len, var->id.name.ptr); hawk_rtx_seterrfmt (rtx, &var->loc, HAWK_EMAPTOVAR, HAWK_T("not allowed to assign a map to a variable '%.*js'"), var->id.name.len, var->id.name.ptr);
return HAWK_NULL; return HAWK_NULL;
} }
#endif
} }
if (hawk_htb_upsert(rtx->named, var->id.name.ptr, var->id.name.len, val, 0) == HAWK_NULL) if (hawk_htb_upsert(rtx->named, var->id.name.ptr, var->id.name.len, val, 0) == HAWK_NULL)
@ -3696,6 +3712,7 @@ static hawk_val_t* do_assignment_nonidx (hawk_rtx_t* rtx, hawk_nde_var_t* var, h
hawk_rtx_seterrfmt (rtx, &var->loc, HAWK_EMAPTOSCALAR, HAWK_T("not allowed to change a map '%.*js' to a scalar"), var->id.name.len, var->id.name.ptr); hawk_rtx_seterrfmt (rtx, &var->loc, HAWK_EMAPTOSCALAR, HAWK_T("not allowed to change a map '%.*js' to a scalar"), var->id.name.len, var->id.name.ptr);
return HAWK_NULL; return HAWK_NULL;
} }
#if !defined(HAWK_ENABLE_GC)
else if (vtype == HAWK_VAL_MAP) else if (vtype == HAWK_VAL_MAP)
{ {
/* old value is not a map but a new value is a map. /* old value is not a map but a new value is a map.
@ -3703,6 +3720,7 @@ static hawk_val_t* do_assignment_nonidx (hawk_rtx_t* rtx, hawk_nde_var_t* var, h
hawk_rtx_seterrfmt (rtx, &var->loc, HAWK_EMAPTOVAR, HAWK_T("not allowed to assign a map to a variable '%.*js'"), var->id.name.len, var->id.name.ptr); hawk_rtx_seterrfmt (rtx, &var->loc, HAWK_EMAPTOVAR, HAWK_T("not allowed to assign a map to a variable '%.*js'"), var->id.name.len, var->id.name.ptr);
return HAWK_NULL; return HAWK_NULL;
} }
#endif
} }
hawk_rtx_refdownval (rtx, old); hawk_rtx_refdownval (rtx, old);
@ -3726,6 +3744,7 @@ static hawk_val_t* do_assignment_nonidx (hawk_rtx_t* rtx, hawk_nde_var_t* var, h
hawk_rtx_seterrfmt (rtx, &var->loc, HAWK_EMAPTOSCALAR, HAWK_T("not allowed to change a map '%.*js' to a scalar"), var->id.name.len, var->id.name.ptr); hawk_rtx_seterrfmt (rtx, &var->loc, HAWK_EMAPTOSCALAR, HAWK_T("not allowed to change a map '%.*js' to a scalar"), var->id.name.len, var->id.name.ptr);
return HAWK_NULL; return HAWK_NULL;
} }
#if !defined(HAWK_ENABLE_GC)
else if (vtype == HAWK_VAL_MAP) else if (vtype == HAWK_VAL_MAP)
{ {
/* old value is not a map but a new value is a map. /* old value is not a map but a new value is a map.
@ -3733,6 +3752,7 @@ static hawk_val_t* do_assignment_nonidx (hawk_rtx_t* rtx, hawk_nde_var_t* var, h
hawk_rtx_seterrfmt (rtx, &var->loc, HAWK_EMAPTOVAR, HAWK_T("not allowed to assign a map to a variable '%.*js'"), var->id.name.len, var->id.name.ptr); hawk_rtx_seterrfmt (rtx, &var->loc, HAWK_EMAPTOVAR, HAWK_T("not allowed to assign a map to a variable '%.*js'"), var->id.name.len, var->id.name.ptr);
return HAWK_NULL; return HAWK_NULL;
} }
#endif
} }
hawk_rtx_refdownval (rtx, old); hawk_rtx_refdownval (rtx, old);

86
hawk/lib/val.c
View File

@ -39,7 +39,6 @@ hawk_val_t* hawk_val_zlm = (hawk_val_t*)&awk_zlm;
/* --------------------------------------------------------------------- */ /* --------------------------------------------------------------------- */
/*#define HAWK_ENABLE_GC*/
#define GCI_MOVED HAWK_TYPE_MAX(hawk_uintptr_t) #define GCI_MOVED HAWK_TYPE_MAX(hawk_uintptr_t)
static hawk_val_t* gc_calloc (hawk_rtx_t* rtx, hawk_oow_t size) static hawk_val_t* gc_calloc (hawk_rtx_t* rtx, hawk_oow_t size)
@ -170,7 +169,7 @@ static void gc_move_reachables_from_root (hawk_gci_t* reachable_list)
while (pair) while (pair)
{ {
iv = (hawk_val_t*)HAWK_MAP_VPTR(pair); iv = (hawk_val_t*)HAWK_MAP_VPTR(pair);
if (HAWK_VPTR_IS_POINTER(iv) && iv->v_gc) if (HAWK_VTR_IS_POINTER(iv) && iv->v_gc)
{ {
igci = hawk_val_to_gci(iv); igci = hawk_val_to_gci(iv);
if (igci->gc_refs != GCI_MOVED) if (igci->gc_refs != GCI_MOVED)
@ -323,20 +322,20 @@ static HAWK_INLINE hawk_val_t* make_str_val (hawk_rtx_t* rtx, const hawk_ooch_t*
{ {
hawk_val_str_t* val = HAWK_NULL; hawk_val_str_t* val = HAWK_NULL;
hawk_oow_t aligned_len; hawk_oow_t aligned_len;
#if defined(ENABLE_FEATURE_SCACHE) #if defined(HAWK_ENABLE_STR_CACHE)
hawk_oow_t i; hawk_oow_t i;
#endif #endif
if (HAWK_UNLIKELY(len1 <= 0 && len2 <= 0)) return hawk_val_zls; if (HAWK_UNLIKELY(len1 <= 0 && len2 <= 0)) return hawk_val_zls;
aligned_len = HAWK_ALIGN_POW2((len1 + len2 + 1), FEATURE_SCACHE_BLOCK_UNIT); aligned_len = HAWK_ALIGN_POW2((len1 + len2 + 1), HAWK_STR_CACHE_BLOCK_UNIT);
#if defined(ENABLE_FEATURE_SCACHE) #if defined(HAWK_ENABLE_STR_CACHE)
i = aligned_len / FEATURE_SCACHE_BLOCK_UNIT; i = aligned_len / HAWK_STR_CACHE_BLOCK_UNIT;
if (i < HAWK_COUNTOF(rtx->scache_count)) if (i < HAWK_COUNTOF(rtx->str_cache_count))
{ {
if (rtx->scache_count[i] > 0) if (rtx->str_cache_count[i] > 0)
{ {
val = rtx->scache[i][--rtx->scache_count[i]]; val = rtx->str_cache[i][--rtx->str_cache_count[i]];
goto init; goto init;
} }
} }
@ -345,7 +344,7 @@ static HAWK_INLINE hawk_val_t* make_str_val (hawk_rtx_t* rtx, const hawk_ooch_t*
val = (hawk_val_str_t*)hawk_rtx_callocmem(rtx, HAWK_SIZEOF(hawk_val_str_t) + (aligned_len * HAWK_SIZEOF(hawk_ooch_t))); val = (hawk_val_str_t*)hawk_rtx_callocmem(rtx, HAWK_SIZEOF(hawk_val_str_t) + (aligned_len * HAWK_SIZEOF(hawk_ooch_t)));
if (HAWK_UNLIKELY(!val)) return HAWK_NULL; if (HAWK_UNLIKELY(!val)) return HAWK_NULL;
#if defined(ENABLE_FEATURE_SCACHE) #if defined(HAWK_ENABLE_STR_CACHE)
init: init:
#endif #endif
val->v_type = HAWK_VAL_STR; val->v_type = HAWK_VAL_STR;
@ -555,18 +554,36 @@ hawk_val_t* hawk_rtx_makenstrvalwithbcs (hawk_rtx_t* rtx, const hawk_bcs_t* str)
/* --------------------------------------------------------------------- */ /* --------------------------------------------------------------------- */
hawk_val_t* hawk_rtx_makembsvalwithbchars (hawk_rtx_t* rtx, const hawk_bch_t* ptr, hawk_oow_t len) hawk_val_t* hawk_rtx_makembsvalwithbchars (hawk_rtx_t* rtx, const hawk_bch_t* ptr, hawk_oow_t len)
{ {
hawk_val_mbs_t* val = HAWK_NULL; hawk_val_mbs_t* val;
hawk_oow_t xsz; hawk_oow_t aligned_len;
#if defined(HAWK_ENABLE_MBS_CACHE)
hawk_oow_t i;
#endif
if (HAWK_UNLIKELY(len <= 0)) return hawk_val_zlm; if (HAWK_UNLIKELY(len <= 0)) return hawk_val_zlm;
aligned_len = HAWK_ALIGN_POW2((len + 1), HAWK_MBS_CACHE_BLOCK_UNIT);
xsz = len * HAWK_SIZEOF(*ptr); #if defined(HAWK_ENABLE_MBS_CACHE)
i = aligned_len / HAWK_MBS_CACHE_BLOCK_UNIT;
if (i < HAWK_COUNTOF(rtx->mbs_cache_count))
{
if (rtx->mbs_cache_count[i] > 0)
{
val = rtx->mbs_cache[i][--rtx->mbs_cache_count[i]];
goto init;
}
}
#endif
val = (hawk_val_mbs_t*)hawk_rtx_callocmem(rtx, HAWK_SIZEOF(hawk_val_mbs_t) + xsz + HAWK_SIZEOF(*ptr)); val = (hawk_val_mbs_t*)hawk_rtx_callocmem(rtx, HAWK_SIZEOF(hawk_val_mbs_t) + (aligned_len * HAWK_SIZEOF(hawk_bch_t)));
if (HAWK_UNLIKELY(!val)) return HAWK_NULL; if (HAWK_UNLIKELY(!val)) return HAWK_NULL;
#if defined(HAWK_ENABLE_MBS_CACHE)
init:
#endif
val->v_type = HAWK_VAL_MBS; val->v_type = HAWK_VAL_MBS;
val->v_refs = 0; val->v_refs = 0;
val->v_static = 0; val->v_static = 0;
@ -574,8 +591,8 @@ hawk_val_t* hawk_rtx_makembsvalwithbchars (hawk_rtx_t* rtx, const hawk_bch_t* pt
val->v_gc = 0; val->v_gc = 0;
val->val.len = len; val->val.len = len;
val->val.ptr = (hawk_bch_t*)(val + 1); val->val.ptr = (hawk_bch_t*)(val + 1);
if (ptr) HAWK_MEMCPY (val->val.ptr, ptr, xsz); if (ptr) HAWK_MEMCPY (val->val.ptr, ptr, len);
val->val.ptr[len] = HAWK_BT('\0'); val->val.ptr[len] = '\0';
return (hawk_val_t*)val; return (hawk_val_t*)val;
} }
@ -986,29 +1003,50 @@ void hawk_rtx_freeval (hawk_rtx_t* rtx, hawk_val_t* val, int cache)
case HAWK_VAL_STR: case HAWK_VAL_STR:
{ {
#if defined(ENABLE_FEATURE_SCACHE) #if defined(HAWK_ENABLE_STR_CACHE)
if (cache) if (cache)
{ {
hawk_val_str_t* v = (hawk_val_str_t*)val; hawk_val_str_t* v = (hawk_val_str_t*)val;
hawk_oow_t aligned_len;
int i; int i;
i = v->val.len / FEATURE_SCACHE_BLOCK_UNIT; aligned_len = HAWK_ALIGN_POW2((v->val.len + 1), HAWK_STR_CACHE_BLOCK_UNIT);
if (i < HAWK_COUNTOF(rtx->scache_count) && i = aligned_len / HAWK_STR_CACHE_BLOCK_UNIT;
rtx->scache_count[i] < HAWK_COUNTOF(rtx->scache[i])) if (i < HAWK_COUNTOF(rtx->str_cache_count) &&
rtx->str_cache_count[i] < HAWK_COUNTOF(rtx->str_cache[i]))
{ {
rtx->scache[i][rtx->scache_count[i]++] = v; rtx->str_cache[i][rtx->str_cache_count[i]++] = v;
v->nstr = 0; v->nstr = 0;
} }
else hawk_rtx_freemem (rtx, val); else hawk_rtx_freemem (rtx, val);
break;
} }
else
#endif #endif
hawk_rtx_freemem (rtx, val);
hawk_rtx_freemem (rtx, val);
break; break;
} }
case HAWK_VAL_MBS: case HAWK_VAL_MBS:
#if defined(HAWK_ENABLE_MBS_CACHE)
if (cache)
{
hawk_val_mbs_t* v = (hawk_val_mbs_t*)val;
hawk_oow_t aligned_len;
int i;
aligned_len = HAWK_ALIGN_POW2((v->val.len + 1), HAWK_MBS_CACHE_BLOCK_UNIT);
i = aligned_len / HAWK_MBS_CACHE_BLOCK_UNIT;
if (i < HAWK_COUNTOF(rtx->mbs_cache_count) &&
rtx->mbs_cache_count[i] < HAWK_COUNTOF(rtx->mbs_cache[i]))
{
rtx->mbs_cache[i][rtx->mbs_cache_count[i]++] = v;
}
else hawk_rtx_freemem (rtx, val);
break;
}
#endif
hawk_rtx_freemem (rtx, val); hawk_rtx_freemem (rtx, val);
break; break;