From 1329b72fcd4fd36996799c4d44a304856fd29c76 Mon Sep 17 00:00:00 2001 From: CPunch Date: Tue, 17 Nov 2020 03:10:55 -0600 Subject: [PATCH] fixed GC bug --- src/cmem.c | 11 +++++++++-- src/cmem.h | 5 +++-- src/cobj.c | 2 +- src/ctable.c | 44 +++++++++++++++++++++++++++++++++++++++++--- src/ctable.h | 3 ++- 5 files changed, 56 insertions(+), 9 deletions(-) diff --git a/src/cmem.c b/src/cmem.c index c240906..e7eb763 100644 --- a/src/cmem.c +++ b/src/cmem.c @@ -66,7 +66,7 @@ void tableRemoveWhite(CState *state, CTable *tbl) { for (int i = 0; i < tbl->capacity; i++) { CTableEntry *entry = &tbl->table[i]; if (IS_OBJ(entry->key) && !(entry->key.val.obj)->isMarked) { // if the key is a object and it's white (unmarked), remove it from the table - cosmoT_remove(tbl, entry->key); + cosmoT_remove(state, tbl, entry->key); } } } @@ -224,6 +224,7 @@ COSMO_API void cosmoM_collectGarbage(CState *state) { printf("-- GC start\n"); size_t start = state->allocatedBytes; #endif + cosmoM_freezeGC(state); // we don't want a recursive garbage collection event! markRoots(state); @@ -232,10 +233,16 @@ COSMO_API void cosmoM_collectGarbage(CState *state) { sweep(state); // set our next GC event - state->nextGC = state->allocatedBytes * HEAP_GROW_FACTOR; + cosmoM_updateThreshhold(state); + cosmoM_unfreezeGC(state); #ifdef GC_DEBUG printf("-- GC end, reclaimed %ld bytes (started at %ld, ended at %ld), next garbage collection scheduled at %ld bytes\n", start - state->allocatedBytes, start, state->allocatedBytes, state->nextGC); + getchar(); // pauses execution #endif +} + +COSMO_API void cosmoM_updateThreshhold(CState *state) { + state->nextGC = state->allocatedBytes * HEAP_GROW_FACTOR; } \ No newline at end of file diff --git a/src/cmem.h b/src/cmem.h index 353c628..bf1e537 100644 --- a/src/cmem.h +++ b/src/cmem.h @@ -45,8 +45,9 @@ state->freezeGC-- #endif -COSMO_API void *cosmoM_reallocate(CState* state, void *buf, size_t oldSize, size_t newSize); -COSMO_API void cosmoM_collectGarbage(CState* state); +COSMO_API void *cosmoM_reallocate(CState *state, void *buf, size_t oldSize, size_t newSize); +COSMO_API void cosmoM_collectGarbage(CState *state); +COSMO_API void cosmoM_updateThreshhold(CState *state); /* wrapper for cosmoM_reallocate so we can track our memory usage (it's also safer :P) diff --git a/src/cobj.c b/src/cobj.c index 7439063..5ae385f 100644 --- a/src/cobj.c +++ b/src/cobj.c @@ -39,7 +39,7 @@ void cosmoO_free(CState *state, CObj* obj) { switch(obj->type) { case COBJ_STRING: { CObjString *objStr = (CObjString*)obj; - cosmoM_freearray(state, char, objStr->str, objStr->length); + cosmoM_freearray(state, char, objStr->str, objStr->length + 1); cosmoM_free(state, CObjString, objStr); break; } diff --git a/src/ctable.c b/src/ctable.c index e4c3eb3..46a96e0 100644 --- a/src/ctable.c +++ b/src/ctable.c @@ -6,10 +6,27 @@ #include #define MAX_TABLE_FILL 0.75 +// at 30% capacity with capacity > ARRAY_START, shrink the array +#define MIN_TABLE_CAPACITY ARRAY_START + +// bit-twiddling hacks, gets the next power of 2 +unsigned int nextPow2(unsigned int x) { + if (x <= ARRAY_START - 1) return ARRAY_START; // sanity check + x--; + + int power = 2; + while (x >>= 1) power <<= 1; + + if (power < ARRAY_START) + return ARRAY_START; + + return power; +} void cosmoT_initTable(CState *state, CTable *tbl, int startCap) { tbl->capacity = startCap != 0 ? startCap : ARRAY_START; // sanity check :P tbl->count = 0; + tbl->tombstones = 0; tbl->table = NULL; // to let out GC know we're initalizing tbl->table = cosmoM_xmalloc(state, sizeof(CTableEntry) * tbl->capacity); @@ -90,8 +107,26 @@ static CTableEntry *findEntry(CTableEntry *entries, int mask, CValue key) { } } -static void growTbl(CState *state, CTable *tbl, size_t newCapacity) { +static void resizeTbl(CState *state, CTable *tbl, size_t newCapacity) { CTableEntry *entries = cosmoM_xmalloc(state, sizeof(CTableEntry) * newCapacity); + + /* Before someone asks, no we shouldn't move the tombstone check to before the entries allocation. + The garbage collector is threshhold based, based on the currently allocated bytes. There's an + edgecase where if GC_STRESS is not enabled the GC will really only be called on growth of the + string interning table (this.) However the new size of the table is accounted for in the next threshhold + cycle, causing allocations to become less and less frequent until your computer develops dementia. + */ + + // if count > 8 and active entries < tombstones + if (tbl->count > MIN_TABLE_CAPACITY && tbl->count - tbl->tombstones < tbl->tombstones) { + cosmoM_freearray(state, CTableEntry, entries, newCapacity); + int tombs = tbl->tombstones; + tbl->tombstones = 0; + resizeTbl(state, tbl, nextPow2((tbl->count - tombs) * GROW_FACTOR)); + cosmoM_updateThreshhold(state); // force a threshhold update since this *could* be such a huge memory difference + return; + } + int newCount = 0; // set all nodes as NIL : NIL @@ -119,14 +154,16 @@ static void growTbl(CState *state, CTable *tbl, size_t newCapacity) { tbl->table = entries; tbl->capacity = newCapacity; tbl->count = newCount; + tbl->tombstones = 0; } // returns a pointer to the allocated value COSMO_API CValue* cosmoT_insert(CState *state, CTable *tbl, CValue key) { // make sure we have enough space allocated if (tbl->count + 1 > (int)(tbl->capacity * MAX_TABLE_FILL)) { + // grow table int newCap = tbl->capacity * GROW_FACTOR; - growTbl(state, tbl, newCap); + resizeTbl(state, tbl, newCap); } // insert into the table @@ -151,7 +188,7 @@ bool cosmoT_get(CTable *tbl, CValue key, CValue *val) { return !(IS_NIL(entry->key)); } -bool cosmoT_remove(CTable *tbl, CValue key) { +bool cosmoT_remove(CState* state, CTable *tbl, CValue key) { if (tbl->count == 0) return 0; // sanity check CTableEntry *entry = findEntry(tbl->table, tbl->capacity - 1, key); @@ -161,6 +198,7 @@ bool cosmoT_remove(CTable *tbl, CValue key) { // crafts tombstone entry->key = cosmoV_newNil(); // this has to be nil entry->val = cosmoV_newBoolean(false); // doesn't reall matter what this is, as long as it isn't nil + tbl->tombstones++; return true; } diff --git a/src/ctable.h b/src/ctable.h index e9e1b84..796164d 100644 --- a/src/ctable.h +++ b/src/ctable.h @@ -12,6 +12,7 @@ typedef struct CTableEntry { typedef struct CTable { int count; int capacity; + int tombstones; CTableEntry *table; } CTable; @@ -22,7 +23,7 @@ COSMO_API CValue *cosmoT_insert(CState *state, CTable *tbl, CValue key); CObjString *cosmoT_lookupString(CTable *tbl, const char *str, size_t length, uint32_t hash); bool cosmoT_get(CTable *tbl, CValue key, CValue *val); -bool cosmoT_remove(CTable *tbl, CValue key); +bool cosmoT_remove(CState *state, CTable *tbl, CValue key); void cosmoT_printTable(CTable *tbl, const char *name);