/** \par
Potion's GC is a generational copying GC. This is why the
volatile keyword is used so liberally throughout the source
code. PN types may suddenly move during any collection phase.
They move from the birth area to the old area.
Potion actually begins by allocating an old area. This is for
two reasons. First, the script may be too short to require an
old area, so we want to avoid allocating two areas to start with.
And second, since Potion loads its core classes into GC first,
we save ourselves a severe promotion step by beginning with an
automatic promotion to second generation. (Oh and this allows
the core Potion struct pointer to be non-volatile.)
In short, this first page is never released, since the GC struct
itself is on that page.
While this may pay a slight penalty in memory size for long-running
scripts, perhaps I could add some occassional compaction to solve
that as well.
\sa potion_init() which calls GC_PROTECT()
*/
Potion *potion_gc_boot(void *sp) {
Potion *P;
int bootsz = POTION_MIN_BIRTH_SIZE;
void *page1 = pngc_page_new(&bootsz, 0);
if (page1 == NULL)
potion_fatal("Not enough memory");
struct PNMemory *M = (struct PNMemory *)page1;
PN_MEMZERO(M, struct PNMemory);
#ifdef DEBUG
M->time = 0.0;
#endif
SET_GEN(birth, page1, bootsz);
SET_STOREPTR(4);
// stack must be 16-byte aligned on amd64 SSE or __APPLE__, and 32-byte with AVX instrs.
// at least amd64 atof() does SSE register return.
#if (PN_SIZE_T == 8) || defined(__APPLE__)
M->cstack = (((_PN)sp & ((1<<5)-1)) == 0 )
? sp : (void *)(_PN)((_PN)sp | ((1<<5)-1) )+1;
#else
M->cstack = sp;
#endif
P = (Potion *)((char *)M + PN_ALIGN(sizeof(struct PNMemory), 8));
PN_MEMZERO(P, Potion);
P->mem = M;
M->birth_cur = (void *)((char *)P + PN_ALIGN(sizeof(Potion), 8));
GC_PROTECT(P);
return P;
}
void potion_test_allocated(CuTest *T) {
struct PNMemory *M = P->mem;
void *prev = NULL;
void *scanptr = (void *)((char *)M->birth_lo + PN_ALIGN(sizeof(struct PNMemory), 8));
while ((PN)scanptr < (PN)M->birth_cur) {
if (((struct PNFwd *)scanptr)->fwd != POTION_FWD && ((struct PNFwd *)scanptr)->fwd != POTION_COPIED) {
if (((struct PNObject *)scanptr)->vt > PN_TUSER) {
vPN(Object) o = (struct PNObject *)scanptr;
fprintf(stderr, "error: scanning heap from %p to %p\n",
M->birth_lo, M->birth_cur);
fprintf(stderr, "%p in %s region\n", scanptr,
IS_GC_PROTECTED(scanptr) ? "protected"
: IN_BIRTH_REGION(scanptr) ? "birth"
: IN_OLDER_REGION(scanptr) ? "older"
: "gc");
fprintf(stderr, "%p { uniq:0x%08x vt:0x%08x ivars[0]:0x%08lx type:0x%x}\n",
scanptr, o->uniq, o->vt, o->ivars[0],
potion_type((PN)scanptr));
fprintf(stderr, "prev %p: size=%d, type:0x%x (%s)\n",
prev, potion_type_size(P, prev),
potion_type((PN)prev), AS_STR(PN_VTABLE(PN_TYPE((PN)prev))));
#ifdef DEBUG
//potion_dump_stack(P);
#endif
}
CuAssert(T, "wrong type for allocated object", ((struct PNObject *)scanptr)->vt <= PN_TUSER);
}
prev = scanptr;
scanptr = (void *)((char *)scanptr + potion_type_size(P, scanptr));
CuAssert(T, "allocated object goes beyond GC pointer", (PN)scanptr <= (PN)M->birth_cur);
}
}
void potion_garbagecollect(Potion *P, int sz, int full) {
struct PNMemory *M = P->mem;
if (M->collecting) return;
M->pass++;
M->collecting = 1;
if (M->old_lo == NULL) {
int gensz = POTION_MIN_BIRTH_SIZE * 4;
if (gensz < sz * 4)
gensz = min(POTION_MAX_BIRTH_SIZE, PN_ALIGN(sz * 4, POTION_PAGESIZE));
void *page = pngc_page_new(&gensz, 0);
SET_GEN(old, page, gensz);
full = 0;
} else if ((char *) M->old_cur + sz + potion_birth_suggest(sz, M->old_lo, M->old_cur) +
((char *) M->birth_hi - (char *) M->birth_lo) > (char *) M->old_hi)
full = 1;
#if POTION_GC_PERIOD>0
else if (M->pass % POTION_GC_PERIOD == POTION_GC_PERIOD)
full = 1;
#endif
if (full)
potion_gc_major(P, sz);
else
potion_gc_minor(P, sz);
M->dirty = 0;
M->collecting = 0;
}
//
// Potion's GC is a generational copying GC. This is why the
// volatile keyword is used so liberally throughout the source
// code. PN types may suddenly move during any collection phase.
// They move from the birth area to the old area.
//
// Potion actually begins by allocating an old area. This is for
// two reasons. First, the script may be too short to require an
// old area, so we want to avoid allocating two areas to start with.
// And second, since Potion loads its core classes into GC first,
// we save ourselves a severe promotion step by beginning with an
// automatic promotion to second generation. (Oh and this allows
// the core Potion struct pointer to be non-volatile.)
//
// In short, this first page is never released, since the GC struct
// itself is on that page.
//
// While this may pay a slight penalty in memory size for long-running
// scripts, perhaps I could add some occassional compaction to solve
// that as well.
//
Potion *potion_gc_boot(void *sp) {
Potion *P;
int bootsz = POTION_MIN_BIRTH_SIZE;
void *page1 = pngc_page_new(&bootsz, 0);
struct PNMemory *M = (struct PNMemory *)page1;
PN_MEMZERO(M, struct PNMemory);
SET_GEN(birth, page1, bootsz);
SET_STOREPTR(4);
M->cstack = sp;
P = (Potion *)((char *)M + PN_ALIGN(sizeof(struct PNMemory), 8));
PN_MEMZERO(P, Potion);
P->mem = M;
M->birth_cur = (void *)((char *)P + PN_ALIGN(sizeof(Potion), 8));
GC_PROTECT(P);
return P;
}
// TODO: release memory allocated by the user
void potion_gc_release(Potion *P) {
struct PNMemory *M = P->mem;
void *birthlo = (void *)M->birth_lo;
void *birthhi = (void *)M->birth_hi;
void *oldlo = (void *)M->old_lo;
void *oldhi = (void *)M->old_hi;
if (M->birth_lo != M) {
void *protend = (void *)PN_ALIGN((_PN)M->protect, POTION_PAGESIZE);
pngc_page_delete((void *)M, (char *)protend - (char *)M);
}
pngc_page_delete(birthlo, birthhi - birthlo);
if (oldlo != NULL)
pngc_page_delete(oldlo, oldhi - oldlo);
birthlo = 0;
birthhi = 0;
oldlo = 0;
oldhi = 0;
}
void pngc_page_delete(void *mem, int sz) {
potion_munmap(mem, PN_ALIGN(sz, POTION_PAGESIZE));
}
void *pngc_page_new(int *sz, const char exec) {
*sz = PN_ALIGN(*sz, POTION_PAGESIZE);
return potion_mmap(*sz, exec);
}
PN_SIZE potion_type_size(Potion *P, const struct PNObject *ptr) {
int sz = 0;
switch (((struct PNFwd *)ptr)->fwd) {
case POTION_COPIED:
case POTION_FWD:
sz = ((struct PNFwd *)ptr)->siz;
goto done;
}
if (ptr->vt > PN_TUSER) {
sz = sizeof(struct PNObject) +
(((struct PNVtable *)PN_VTABLE(ptr->vt))->ivlen * sizeof(PN));
goto done;
}
switch (ptr->vt) {
case PN_TNUMBER:
sz = sizeof(struct PNDecimal);
break;
case PN_TSTRING:
sz = sizeof(struct PNString) + PN_STR_LEN(ptr) + 1;
break;
case PN_TCLOSURE:
sz = sizeof(struct PNClosure) + (PN_CLOSURE(ptr)->extra * sizeof(PN));
break;
case PN_TTUPLE:
sz = sizeof(struct PNTuple) + (sizeof(PN) * ((struct PNTuple *)ptr)->len);
break;
case PN_TSTATE:
sz = sizeof(Potion);
break;
case PN_TFILE:
sz = sizeof(struct PNFile);
break;
case PN_TVTABLE:
sz = sizeof(struct PNVtable);
break;
case PN_TSOURCE:
// TODO: look up ast size (see core/ast.c)
sz = sizeof(struct PNSource) + (3 * sizeof(PN));
break;
case PN_TBYTES:
sz = sizeof(struct PNBytes) + ((struct PNBytes *)ptr)->siz;
break;
case PN_TPROTO:
sz = sizeof(struct PNProto);
break;
case PN_TTABLE:
sz = sizeof(struct PNTable) + kh_mem(PN, ptr);
break;
case PN_TSTRINGS:
sz = sizeof(struct PNTable) + kh_mem(str, ptr);
break;
case PN_TFLEX:
sz = sizeof(PNFlex) + ((PNFlex *)ptr)->siz;
break;
case PN_TCONT:
sz = sizeof(struct PNCont) + (((struct PNCont *)ptr)->len * sizeof(PN));
break;
case PN_TUSER:
sz = sizeof(struct PNData) + ((struct PNData *)ptr)->siz;
break;
}
done:
if (sz < sizeof(struct PNFwd))
sz = sizeof(struct PNFwd);
return PN_ALIGN(sz, 8); // force 64-bit alignment
}
static int potion_gc_major(Potion *P, int siz) {
struct PNMemory *M = P->mem;
void *prevoldlo = 0;
void *prevoldhi = 0;
void *prevoldcur = 0;
void *newold = 0;
void *protptr = (void *)M + PN_ALIGN(sizeof(struct PNMemory), 8);
void *scanptr = 0;
void **wb = 0;
int birthest = 0;
int birthsiz = 0;
int newoldsiz = 0;
int oldsiz = 0;
if (siz < 0)
siz = 0;
else if (siz >= POTION_MAX_BIRTH_SIZE)
return POTION_NO_MEM;
prevoldlo = (void *)M->old_lo;
prevoldhi = (void *)M->old_hi;
prevoldcur = (void *)M->old_cur;
info("running gc_major\n"
"(young: %p -> %p = %ld)\n"
"(old: %p -> %p = %ld)\n",
M->birth_lo, M->birth_hi, (long)(M->birth_hi - M->birth_lo),
M->old_lo, M->old_hi, (long)(M->old_hi - M->old_lo));
birthest = potion_birth_suggest(siz, prevoldlo, prevoldcur);
newoldsiz = (((char *)prevoldcur - (char *)prevoldlo) + siz + birthest +
POTION_GC_THRESHOLD + 16 * POTION_PAGESIZE) + ((char *)M->birth_cur - (char *)M->birth_lo);
newold = pngc_page_new(&newoldsiz, 0);
M->old_cur = scanptr = newold + (sizeof(PN) * 2);
info("(new old: %p -> %p = %d)\n", newold, (char *)newold + newoldsiz, newoldsiz);
potion_mark_stack(P, 2);
wb = (void **)M->birth_storeptr;
if (M->birth_lo != M) {
while ((PN)protptr < (PN)M->protect)
protptr = potion_mark_major(P, protptr);
}
while ((PN)scanptr < (PN)M->old_cur)
scanptr = potion_mark_major(P, scanptr);
scanptr = 0;
GC_MAJOR_STRINGS();
pngc_page_delete((void *)prevoldlo, (char *)prevoldhi - (char *)prevoldlo);
prevoldlo = 0;
prevoldhi = 0;
prevoldcur = 0;
birthsiz = NEW_BIRTH_REGION(M, wb, siz + birthest);
oldsiz = ((char *)M->old_cur - (char *)newold) +
(birthsiz + 2 * birthest + 4 * POTION_PAGESIZE);
oldsiz = PN_ALIGN(oldsiz, POTION_PAGESIZE);
if (oldsiz < newoldsiz) {
pngc_page_delete((void *)newold + oldsiz, newoldsiz - oldsiz);
newoldsiz = oldsiz;
}
M->old_lo = newold;
M->old_hi = (char *)newold + newoldsiz;
M->majors++;
newold = 0;
return POTION_OK;
}
PN_SIZE potion_type_size(Potion *P, const struct PNObject *ptr) {
int sz = 0;
switch (((struct PNFwd *)ptr)->fwd) {
case POTION_COPIED:
case POTION_FWD:
sz = ((struct PNFwd *)ptr)->siz;
goto done;
}
if (ptr->vt < PN_TNIL) goto err;
if (ptr->vt > PN_TUSER) {
if (P->vts && ptr->vt < P->vts->len
&& PN_VTABLE(ptr->vt) && PN_TYPECHECK(ptr->vt)) {
sz = sizeof(struct PNObject) +
(((struct PNVtable *)PN_VTABLE(ptr->vt))->ivlen * sizeof(PN));
//sz = potion_send((PN)ptr, PN_size); //cannot use bind with POTION_COPIED objs during GC!
} else {
err:
if (P->flags & (DEBUG_VERBOSE
#ifdef DEBUG
|DEBUG_GC
#endif
))
fprintf(stderr, "** Invalid User Object 0x%lx vt: 0x%lx\n",
(unsigned long)ptr, (unsigned long)ptr->vt);
return 0;
}
goto done;
}
switch (ptr->vt) {
case PN_TNUMBER:
sz = sizeof(struct PNDecimal);
break;
case PN_TSTRING:
sz = sizeof(struct PNString) + PN_STR_LEN(ptr) + 1;
break;
case PN_TCLOSURE:
sz = sizeof(struct PNClosure) + (PN_CLOSURE(ptr)->extra * sizeof(PN));
break;
case PN_TTUPLE:
sz = sizeof(struct PNTuple) + (sizeof(PN) * ((struct PNTuple *)ptr)->alloc);
break;
case PN_TSTATE:
sz = sizeof(Potion);
break;
case PN_TFILE:
sz = sizeof(struct PNFile);
break;
case PN_TVTABLE:
sz = sizeof(struct PNVtable);
break;
case PN_TSOURCE:
sz = sizeof(struct PNSource);
break;
case PN_TBYTES:
sz = sizeof(struct PNBytes) + ((struct PNBytes *)ptr)->siz;
break;
case PN_TPROTO:
sz = sizeof(struct PNProto);
break;
case PN_TTABLE:
sz = sizeof(struct PNTable) + kh_mem(PN, ptr);
break;
case PN_TLICK:
sz = sizeof(struct PNLick);
break;
case PN_TSTRINGS:
sz = sizeof(struct PNTable) + kh_mem(str, ptr);
break;
case PN_TFLEX:
sz = sizeof(PNFlex) + ((PNFlex *)ptr)->siz;
break;
case PN_TCONT:
sz = sizeof(struct PNCont) + (((struct PNCont *)ptr)->len * sizeof(PN));
break;
case PN_TUSER:
sz = sizeof(struct PNData) + ((struct PNData *)ptr)->siz;
break;
}
done:
if (sz < sizeof(struct PNFwd))
sz = sizeof(struct PNFwd);
return PN_ALIGN(sz, 8); // force 64-bit alignment
}
