added --gctype

fixed a bug in xma
touched up gc code a bit

moo/bin/main.c

@@ -89,6 +89,7 @@ int main (int argc, char* argv[])
 	{
 		{ ":log",              'l' },
 		{ ":heapsize",         '\0' },
+		{ ":gctype",           '\0' },
 		{ ":procstksize",      '\0' },
 		{ "large-pages",       '\0' },
 		{ ":base-charset",     '\0' },
@@ -114,11 +115,13 @@ int main (int argc, char* argv[])
 		fprintf (stderr, "Usage: %s [options] filename ...\n", argv[0]);
 		fprintf (stderr, " --log filename[,logopts]\n");
 		fprintf (stderr, " --heapsize=bytes\n");
+		fprintf (stderr, " --gctype=ms|ss\n");
 		fprintf (stderr, " --procstksize=number of oops\n");
 		fprintf (stderr, " --large-pages\n");
 		fprintf (stderr, " --base-charset=name\n");
 		fprintf (stderr, " --input-charset=name\n");
 		fprintf (stderr, " --log-charset=name\n");
+		
 	#if defined(MOO_BUILD_DEBUG)
 		fprintf (stderr, " --debug dbgopts\n");
 	#endif
@@ -145,10 +148,17 @@ int main (int argc, char* argv[])
 				if (moo_comp_bcstr(opt.lngopt, "heapsize") == 0)
 				{
 					heapsize = strtoul(opt.arg, MOO_NULL, 0);
-					if (heapsize <= MIN_HEAPSIZE) heapsize = MIN_HEAPSIZE;
 					break;
 				}
-				if (moo_comp_bcstr(opt.lngopt, "procstksize") == 0)
+				else if (moo_comp_bcstr(opt.lngopt, "gctype") == 0)
+				{
+					if (moo_comp_bcstr(opt.arg, "ms") == 0)
+						cfg.gc_type = MOO_GC_TYPE_MARK_SWEEP;
+					else
+						cfg.gc_type = MOO_GC_TYPE_SEMISPACE;
+					break;
+				}
+				else if (moo_comp_bcstr(opt.lngopt, "procstksize") == 0)
 				{
 					cfg.proc_stk_size = strtoul(opt.arg, MOO_NULL, 0);
 					break;
@@ -238,6 +248,7 @@ int main (int argc, char* argv[])
 		moo_setoption (moo, MOO_OPTION_SYSDIC_SIZE, &tab_size);
 	}
 
+	if (cfg.gc_type == MOO_GC_TYPE_SEMISPACE && heapsize <= MIN_HEAPSIZE) heapsize = MIN_HEAPSIZE;
 	if (moo_ignite(moo, heapsize) <= -1)
 	{
 		moo_logbfmt (moo, MOO_LOG_STDERR, "ERROR: cannot ignite moo - [%d] %js\n", moo_geterrnum(moo), moo_geterrstr(moo));

moo/lib/exec.c

@@ -6369,6 +6369,16 @@ void moo_abort (moo_t* moo)
 	moo->abort_req = 1;
 }
 
+#if defined(MOO_PROFILE_VM) && defined(MOO_ENABLE_GC_MARK_SWEEP)
+static void xma_dumper (void* ctx, const char* fmt, ...)
+{
+	va_list ap;
+	va_start (ap, fmt);
+	moo_logbfmtv ((moo_t*)ctx, MOO_LOG_IC | MOO_LOG_INFO, fmt, ap);
+	va_end (ap);
+}
+#endif
+
 int moo_invoke (moo_t* moo, const moo_oocs_t* objname, const moo_oocs_t* mthname)
 {
 	int n;
@@ -6428,7 +6438,11 @@ int moo_invoke (moo_t* moo, const moo_oocs_t* objname, const moo_oocs_t* mthname
 	MOO_LOG2 (moo, MOO_LOG_IC | MOO_LOG_INFO, "Method cache - hits: %zu, misses: %zu\n", moo->stat.method_cache_hits, moo->stat.method_cache_misses);
 	MOO_LOG1 (moo, MOO_LOG_IC | MOO_LOG_INFO, "Total instructions: %zu\n", moo->stat.inst_counter);
 #if defined(MOO_ENABLE_GC_MARK_SWEEP)
-	MOO_LOG2 (moo, MOO_LOG_IC | MOO_LOG_INFO, "GC - gci.bsz: %zu, gci.stack.max: %zu\n", moo->gci.bsz, moo->gci.stack.max);
+	if (moo->gc_type == MOO_GC_TYPE_MARK_SWEEP)
+	{
+		MOO_LOG2 (moo, MOO_LOG_IC | MOO_LOG_INFO, "GC - gci.bsz: %zu, gci.stack.max: %zu\n", moo->gci.bsz, moo->gci.stack.max);
+		if (moo->heap->xma) moo_xma_dump (moo->heap->xma, xma_dumper, moo);
+	}
 #endif
 #endif
 

moo/lib/gc.c

@@ -798,9 +798,6 @@ static moo_rbt_walk_t call_module_gc (moo_rbt_t* rbt, moo_rbt_pair_t* pair, void
 /* ----------------------------------------------------------------------- */
 
 #if defined(MOO_ENABLE_GC_MARK_SWEEP)
-
-
-
 #if 0
 static MOO_INLINE void gc_mark (moo_t* moo, moo_oop_t oop)
 {
@@ -1021,7 +1018,7 @@ static MOO_INLINE void gc_sweep (moo_t* moo)
 			else moo->gci.b = next;
 
 			moo->gci.bsz -= MOO_SIZEOF(moo_obj_t) + moo_getobjpayloadbytes(moo, obj);
-			moo_freemem (moo, curr);
+			moo_freeheapmem (moo, moo->heap, curr);
 		}
 
 		curr = next;
@@ -1031,18 +1028,12 @@ static MOO_INLINE void gc_sweep (moo_t* moo)
 
 /* ----------------------------------------------------------------------- */
 
-moo_oop_t moo_moveoop (moo_t* moo, moo_oop_t oop)
+static moo_oop_t move_oop_in_heap_space (moo_t* moo, moo_oop_t oop)
 {
 #if defined(MOO_SUPPORT_GC_DURING_IGNITION)
 	if (!oop) return oop;
 #endif
 
-#if defined(MOO_ENABLE_GC_MARK_SWEEP)
-/* TODO: temporary... */
-	gc_mark (moo, oop);
-	return oop;
-#endif
-
 	if (!MOO_OOP_IS_POINTER(oop)) return oop;
 
 	if (MOO_OBJ_GET_FLAGS_PERM(oop)) return oop;
@@ -1179,16 +1170,8 @@ static moo_uint8_t* scan_heap_space (moo_t* moo, moo_uint8_t* ptr, moo_uint8_t**
 }
 
 
-void moo_gc (moo_t* moo)
+static void scan_roots (moo_t* moo)
 {
-#if defined(MOO_ENABLE_GC_MARK_SWEEP)
-	MOO_LOG1 (moo, MOO_LOG_GC | MOO_LOG_INFO, "Starting GC (mark-sweep) - gci.bsz = %zu\n", moo->gci.bsz);
-moo->gci.stack.len = 0;
-/*moo->gci.stack.max = 0;*/
-	gc_mark_root (moo);
-	gc_sweep (moo);
-	MOO_LOG2 (moo, MOO_LOG_GC | MOO_LOG_INFO, "Finished GC (mark-sweep) - gci.bsz = %zu, gci.stack.max %zu\n", moo->gci.bsz, moo->gci.stack.max);
-#else
 	/* 
 	 * move a referenced object to the new heap.
 	 * inspect the fields of the moved object in the new heap.
@@ -1352,7 +1335,41 @@ moo->gci.stack.len = 0;
 	MOO_LOG4 (moo, MOO_LOG_GC | MOO_LOG_INFO, 
 		"Finished GC curheap base %p ptr %p newheap base %p ptr %p\n",
 		moo->heap->curspace.base, moo->heap->curspace.ptr, moo->heap->newspace.base, moo->heap->newspace.ptr); 
+}
+
+
+void moo_gc (moo_t* moo)
+{
+#if defined(MOO_ENABLE_GC_MARK_SWEEP)
+	if (moo->gc_type == MOO_GC_TYPE_MARK_SWEEP)
+	{
+		MOO_LOG1 (moo, MOO_LOG_GC | MOO_LOG_INFO, "Starting GC (mark-sweep) - gci.bsz = %zu\n", moo->gci.bsz);
+		moo->gci.stack.len = 0;
+		/*moo->gci.stack.max = 0;*/
+		gc_mark_root (moo);
+		gc_sweep (moo);
+		MOO_LOG2 (moo, MOO_LOG_GC | MOO_LOG_INFO, "Finished GC (mark-sweep) - gci.bsz = %zu, gci.stack.max %zu\n", moo->gci.bsz, moo->gci.stack.max);
+	}
+	else
 #endif
+	{
+		scan_roots (moo);
+	}
+}
+
+moo_oop_t moo_moveoop (moo_t* moo, moo_oop_t oop)
+{
+#if defined(MOO_ENABLE_GC_MARK_SWEEP)
+	if (moo->gc_type == MOO_GC_TYPE_MARK_SWEEP)
+	{
+		gc_mark (moo, oop);
+		return oop;
+	}
+	else
+#endif
+	{
+		return move_oop_in_heap_space(moo, oop);
+	}
 }
 
 void moo_pushvolat (moo_t* moo, moo_oop_t* oop_ptr)

moo/lib/heap.c

@@ -67,10 +67,12 @@ moo_heap_t* moo_makeheap (moo_t* moo, moo_oow_t size)
 	{
 		if (size <= 0)
 		{
+			/* use the existing memory allocator */
 			heap->xmmgr = *moo_getmmgr(moo);
 		}
 		else
 		{
+			/* create a new memory allocator over the allocated heap */
 			heap->xma = moo_xma_open(moo_getmmgr(moo), 0, heap->base, heap->size);
 			if (MOO_UNLIKELY(!heap->xma))
 			{
@@ -87,7 +89,7 @@ moo_heap_t* moo_makeheap (moo_t* moo, moo_oow_t size)
 	}
 	else
 	{
-		MOO_ASSERT (moo, moo->gc_type == MOO_GC_TYPE_SS_COPY);
+		MOO_ASSERT (moo, moo->gc_type == MOO_GC_TYPE_SEMISPACE);
 
 		space_size = (size - PERM_SPACE_SIZE) / 2;
 
@@ -125,6 +127,8 @@ void* moo_allocheapspace (moo_t* moo, moo_space_t* space, moo_oow_t size)
 {
 	moo_uint8_t* ptr;
 
+	MOO_ASSERT (moo, moo->gc_type == MOO_GC_TYPE_SEMISPACE);
+
 	/* check the space size limit */
 	if (space->ptr >= space->limit || space->limit - space->ptr < size)
 	{
@@ -140,3 +144,41 @@ void* moo_allocheapspace (moo_t* moo, moo_space_t* space, moo_oow_t size)
 
 	return ptr;
 }
+
+void* moo_allocheapmem (moo_t* moo, moo_heap_t* heap, moo_oow_t size)
+{
+	void* ptr;
+
+	MOO_ASSERT (moo, moo->gc_type == MOO_GC_TYPE_MARK_SWEEP);
+	ptr = MOO_MMGR_ALLOC(&heap->xmmgr, size);
+	if (MOO_UNLIKELY(!ptr)) 
+	{
+		MOO_DEBUG2 (moo, "Cannot allocate %zd bytes from heap - ptr %p\n", size, heap);
+		moo_seterrnum (moo, MOO_EOOMEM);
+	}
+	return ptr;
+}
+
+void* moo_callocheapmem (moo_t* moo, moo_heap_t* heap, moo_oow_t size)
+{
+	void* ptr;
+
+	MOO_ASSERT (moo, moo->gc_type == MOO_GC_TYPE_MARK_SWEEP);
+	ptr = MOO_MMGR_ALLOC(&heap->xmmgr, size);
+	if (MOO_UNLIKELY(!ptr)) 
+	{
+		MOO_DEBUG2 (moo, "Cannot callocate %zd bytes from heap - ptr %p\n", size, heap);
+		moo_seterrnum (moo, MOO_EOOMEM);
+	}
+	else
+	{
+		MOO_MEMSET (ptr, 0, size);
+	}
+	return ptr;
+}
+
+void moo_freeheapmem (moo_t* moo, moo_heap_t* heap, void* ptr)
+{
+	MOO_ASSERT (moo, moo->gc_type == MOO_GC_TYPE_MARK_SWEEP);
+	MOO_MMGR_FREE (&heap->xmmgr, ptr);
+}

moo/lib/moo-prv.h

@@ -1109,8 +1109,8 @@ void moo_killheap (
 );
 
 /**
- * The moo_allocheapspace() function allocates \a size bytes in the heap pointed
+ * The moo_allocheapspace() function allocates \a size bytes in a semi-space 
- * to by \a heap.
+ * of the heap pointed to by \a heap.
  *
  * \return memory pointer on success and #MOO_NULL on failure.
  */
@@ -1120,6 +1120,27 @@ void* moo_allocheapspace (
 	moo_oow_t    size
 );
 
+
+/** 
+ * The moo_allocheapmem(0 function allocates  \a size bytes from the given heap.
+ */
+void* moo_allocheapmem (
+	moo_t*       moo,
+	moo_heap_t*  heap,
+	moo_oow_t    size
+);
+
+void* moo_callocheapmem (
+	moo_t*       moo,
+	moo_heap_t*  heap,
+	moo_oow_t    size
+);
+
+void moo_freeheapmem (
+	moo_t*       moo,
+	moo_heap_t*  heap,
+	void*        ptr
+);
 /* ========================================================================= */
 /* obj.c                                                                     */
 /* ========================================================================= */

moo/lib/moo-std.h

@@ -15,6 +15,7 @@ struct moo_cfgstd_t
 {
 	moo_cfgstd_type_t type;
 
+	moo_gc_type_t gc_type;
 	moo_oow_t proc_stk_size;
 	int large_pages;
 	moo_cmgr_t* cmgr;

moo/lib/moo-xma.h

@@ -115,7 +115,7 @@ struct moo_xma_t
  * The moo_xma_dumper_t type defines a printf-like output function
  * for moo_xma_dump().
  */
-typedef int (*moo_xma_dumper_t) (
+typedef void (*moo_xma_dumper_t) (
 	void*            ctx,
 	const moo_bch_t* fmt,
 	...

moo/lib/moo.c

@@ -26,7 +26,7 @@
 
 #include "moo-prv.h"
 
-moo_t* moo_open (moo_mmgr_t* mmgr, moo_oow_t xtnsize, moo_cmgr_t* cmgr, const moo_vmprim_t* vmprim, moo_errinf_t* errinfo)
+moo_t* moo_open (moo_mmgr_t* mmgr, moo_oow_t xtnsize, moo_cmgr_t* cmgr, const moo_vmprim_t* vmprim, moo_gc_type_t gctype, moo_errinf_t* errinfo)
 {
 	moo_t* moo;
 
@@ -36,7 +36,7 @@ moo_t* moo_open (moo_mmgr_t* mmgr, moo_oow_t xtnsize, moo_cmgr_t* cmgr, const mo
 	moo = (moo_t*)MOO_MMGR_ALLOC(mmgr, MOO_SIZEOF(*moo) + xtnsize);
 	if (moo)
 	{
-		if (moo_init(moo, mmgr, cmgr, vmprim) <= -1)
+		if (moo_init(moo, mmgr, cmgr, vmprim, gctype) <= -1)
 		{
 			if (errinfo) moo_geterrinf (moo, errinfo);
 			MOO_MMGR_FREE (mmgr, moo);
@@ -96,7 +96,7 @@ static MOO_INLINE void free_heap (moo_t* moo, void* ptr)
 	moo_freemem (moo, ptr);
 }
 
-int moo_init (moo_t* moo, moo_mmgr_t* mmgr, moo_cmgr_t* cmgr, const moo_vmprim_t* vmprim)
+int moo_init (moo_t* moo, moo_mmgr_t* mmgr, moo_cmgr_t* cmgr, const moo_vmprim_t* vmprim, moo_gc_type_t gctype)
 {
 	int modtab_inited = 0;
 
@@ -111,6 +111,7 @@ int moo_init (moo_t* moo, moo_mmgr_t* mmgr, moo_cmgr_t* cmgr, const moo_vmprim_t
 	moo->_mmgr = mmgr;
 	moo->_cmgr = cmgr;
 
+	moo->gc_type = gctype;
 	moo->vmprim = *vmprim;
 	if (!moo->vmprim.alloc_heap) moo->vmprim.alloc_heap = alloc_heap;
 	if (!moo->vmprim.free_heap) moo->vmprim.free_heap = free_heap;
@@ -260,11 +261,7 @@ void moo_fini (moo_t* moo)
 		moo->proc_map_free_last = -1;
 	}
 
-/* TOOD: persistency? storing objects to image file? */
+/* TOOD: persistency? storing objects to image file before destroying all objects and the heap? */
-
-	/* if the moo object is closed without moo_ignite(),
-	 * the heap may not exist */
-	if (moo->heap) moo_killheap (moo, moo->heap);
 
 #if defined(MOO_ENABLE_GC_MARK_SWEEP)
 	if (moo->gci.b)
@@ -273,9 +270,8 @@ void moo_fini (moo_t* moo)
 		do
 		{
 			next = moo->gci.b->next;
-
 			moo->gci.bsz -= MOO_SIZEOF(moo_obj_t) + moo_getobjpayloadbytes(moo, (moo_oop_t)(moo->gci.b + 1));
-			moo_freemem (moo, moo->gci.b);
+			moo_freeheapmem (moo, moo->heap, moo->gci.b);
 			moo->gci.b = next;
 		}
 		while (moo->gci.b);
@@ -292,6 +288,10 @@ void moo_fini (moo_t* moo)
 	}
 #endif
 
+	/* if the moo object is closed without moo_ignite(),
+	 * the heap may not exist */
+	if (moo->heap) moo_killheap (moo, moo->heap);
+
 	moo_finidbgi (moo);
 
 	for (i = 0; i < MOO_COUNTOF(moo->sbuf); i++)

moo/lib/moo.h

@@ -35,7 +35,7 @@
 /* TODO: move this macro out to the build files.... */
 #define MOO_INCLUDE_COMPILER
 
-//#define MOO_ENABLE_GC_MARK_SWEEP
+#define MOO_ENABLE_GC_MARK_SWEEP
 
 
 typedef struct moo_mod_t moo_mod_t;
@@ -218,7 +218,7 @@ struct moo_gchdr_t
 
 enum moo_gc_type_t
 {
-	MOO_GC_TYPE_SS_COPY,
+	MOO_GC_TYPE_SEMISPACE,
 	MOO_GC_TYPE_MARK_SWEEP
 };
 typedef enum moo_gc_type_t moo_gc_type_t;
@@ -1012,10 +1012,13 @@ struct moo_heap_t
 	moo_uint8_t* base;
 	moo_oow_t    size;
 
+/* for semi-space gc */
 	moo_space_t  permspace;
 	moo_space_t  curspace;
 	moo_space_t  newspace;
 
+/* for mark sweep gc */
+/* TODO: use union ... */
 	moo_xma_t*   xma; /* used if MARK_SWEEP is enabled */
 	moo_mmgr_t   xmmgr;
 };
@@ -2084,6 +2087,7 @@ MOO_EXPORT moo_t* moo_open (
 	moo_oow_t           xtnsize,
 	moo_cmgr_t*         cmgr,
 	const moo_vmprim_t* vmprim,
+	moo_gc_type_t       gctype,
 	moo_errinf_t*       errinfo
 );
 
@@ -2095,7 +2099,8 @@ MOO_EXPORT int moo_init (
 	moo_t*              moo,
 	moo_mmgr_t*         mmgr,
 	moo_cmgr_t*         cmgr,
-	const moo_vmprim_t* vmprim
+	const moo_vmprim_t* vmprim,
+	moo_gc_type_t       gctype
 );
 
 MOO_EXPORT void moo_fini (

moo/lib/obj.c

@@ -28,71 +28,74 @@
 
 void* moo_allocbytes (moo_t* moo, moo_oow_t size)
 {
-	moo_uint8_t* ptr;
-#if defined(MOO_ENABLE_GC_MARK_SWEEP)
-	moo_gchdr_t* gch;
-#endif
-
 #if defined(MOO_BUILD_DEBUG)
 	/* DEBUG_GC is set but NOGC is not set */
 	if ((moo->option.trait & (MOO_TRAIT_DEBUG_GC | MOO_TRAIT_NOGC)) == MOO_TRAIT_DEBUG_GC) moo_gc (moo);
 #endif
 
 #if defined(MOO_ENABLE_GC_MARK_SWEEP)
-	if (MOO_UNLIKELY(moo->igniting))
+	if (moo->gc_type == MOO_GC_TYPE_MARK_SWEEP)
 	{
-/* TODO: use heap.xmmgr for allocation... */
+		moo_gchdr_t* gch;
-		gch = (moo_gchdr_t*)moo_callocmem(moo, MOO_SIZEOF(*gch) + size); 
-		if (MOO_UNLIKELY(!gch)) return MOO_NULL;
-	}
-	else
-	{
-		if (moo->gci.bsz >= moo->gci.threshold) 
-		{
-			moo_gc (moo);
-			moo->gci.threshold = moo->gci.bsz + 100000; /* TODO: change this fomula */
-		}
 
-		gch = (moo_gchdr_t*)moo_callocmem(moo, MOO_SIZEOF(*gch) + size); 
+		if (MOO_UNLIKELY(moo->igniting))
-		if (!gch && moo->errnum == MOO_EOOMEM && !(moo->option.trait & MOO_TRAIT_NOGC))
 		{
-			moo_gc (moo);
+			gch = (moo_gchdr_t*)moo_callocheapmem(moo, moo->heap, MOO_SIZEOF(*gch) + size); 
-			MOO_LOG0 (moo, MOO_LOG_GC | MOO_LOG_INFO, "GC completed\n"); /* TODO: add more inforamtion */
-			gch = (moo_gchdr_t*)moo_callocmem(moo, MOO_SIZEOF(*gch) + size); 
 			if (MOO_UNLIKELY(!gch)) return MOO_NULL;
 		}
-	}
+		else
+		{
+			if (moo->gci.bsz >= moo->gci.threshold) 
+			{
+				moo_gc (moo);
+				moo->gci.threshold = moo->gci.bsz + 100000; /* TODO: change this fomula */
+			}
 
-	gch->next = moo->gci.b;
+			gch = (moo_gchdr_t*)moo_callocheapmem(moo, moo->heap, MOO_SIZEOF(*gch) + size); 
-	moo->gci.b = gch;
+			if (!gch && moo->errnum == MOO_EOOMEM && !(moo->option.trait & MOO_TRAIT_NOGC))
-	moo->gci.bsz += size;
+			{
+				moo_gc (moo);
+				MOO_LOG0 (moo, MOO_LOG_GC | MOO_LOG_INFO, "GC completed\n"); /* TODO: add more inforamtion */
+				gch = (moo_gchdr_t*)moo_callocheapmem(moo, moo->heap, MOO_SIZEOF(*gch) + size); 
+				if (MOO_UNLIKELY(!gch)) return MOO_NULL;
+			}
+		}
 
-	ptr = (moo_uint8_t*)(gch + 1);
+		gch->next = moo->gci.b;
-#else
+		moo->gci.b = gch;
-	if (MOO_UNLIKELY(moo->igniting))
+		moo->gci.bsz += size;
-	{
+
-		/* you must increase the size of the permspace if this allocation fails */
+		return (moo_uint8_t*)(gch + 1);
-		ptr = (moo_uint8_t*)moo_allocheapspace(moo, &moo->heap->permspace, size); 
 	}
 	else
-	{
-		ptr = (moo_uint8_t*)moo_allocheapspace(moo, &moo->heap->curspace, size);
-		if (!ptr && moo->errnum == MOO_EOOMEM && !(moo->option.trait & MOO_TRAIT_NOGC))
-		{
-			moo_gc (moo);
-			MOO_LOG4 (moo, MOO_LOG_GC | MOO_LOG_INFO,
-				"GC completed - current heap ptr %p limit %p size %zd free %zd\n", 
-				moo->heap->curspace.ptr, moo->heap->curspace.limit,
-				(moo_oow_t)(moo->heap->curspace.limit - moo->heap->curspace.base),
-				(moo_oow_t)(moo->heap->curspace.limit - moo->heap->curspace.ptr)
-			);
-			ptr = (moo_uint8_t*)moo_allocheapspace(moo, &moo->heap->curspace, size);
-	/* TODO: grow heap if ptr is still null. */
-		}
-	}
 #endif
+	{
+		moo_uint8_t* ptr;
 
-	return ptr;
+		if (MOO_UNLIKELY(moo->igniting))
+		{
+			/* you must increase the size of the permspace if this allocation fails */
+			ptr = (moo_uint8_t*)moo_allocheapspace(moo, &moo->heap->permspace, size); 
+		}
+		else
+		{
+			ptr = (moo_uint8_t*)moo_allocheapspace(moo, &moo->heap->curspace, size);
+			if (!ptr && moo->errnum == MOO_EOOMEM && !(moo->option.trait & MOO_TRAIT_NOGC))
+			{
+				moo_gc (moo);
+				MOO_LOG4 (moo, MOO_LOG_GC | MOO_LOG_INFO,
+					"GC completed - current heap ptr %p limit %p size %zd free %zd\n", 
+					moo->heap->curspace.ptr, moo->heap->curspace.limit,
+					(moo_oow_t)(moo->heap->curspace.limit - moo->heap->curspace.base),
+					(moo_oow_t)(moo->heap->curspace.limit - moo->heap->curspace.ptr)
+				);
+				ptr = (moo_uint8_t*)moo_allocheapspace(moo, &moo->heap->curspace, size);
+		/* TODO: grow heap if ptr is still null. */
+			}
+		}
+
+		return ptr;
+	}
 }
 
 moo_oop_t moo_allocoopobj (moo_t* moo, moo_oow_t size)

moo/lib/std.c

@@ -4207,8 +4207,8 @@ moo_t* moo_openstd (moo_oow_t xtnsize, const moo_cfgstd_t* cfg, moo_errinf_t* er
 	vmprim.vm_getsig = vm_getsig;
 	vmprim.vm_setsig = vm_setsig;
 
-	moo = moo_open(&sys_mmgr, MOO_SIZEOF(xtn_t) + xtnsize, ((cfg && cfg->cmgr)? cfg->cmgr: moo_get_utf8_cmgr()), &vmprim, errinfo);
+	moo = moo_open(&sys_mmgr, MOO_SIZEOF(xtn_t) + xtnsize, ((cfg && cfg->cmgr)? cfg->cmgr: moo_get_utf8_cmgr()), &vmprim, cfg->gc_type, errinfo);
-	if (!moo) return MOO_NULL;
+	if (MOO_UNLIKELY(!moo)) return MOO_NULL;
 
 	/* adjust the object size by the sizeof xtn_t so that moo_getxtn() returns the right pointer. */
 	moo->_instsize += MOO_SIZEOF(xtn_t);

moo/lib/xma.c

@@ -234,7 +234,7 @@ int moo_xma_init (moo_xma_t* xma, moo_mmgr_t* mmgr, void* zoneptr, moo_oow_t zon
 		zoneptr = MOO_MMGR_ALLOC(mmgr, zonesize);
 		if (MOO_UNLIKELY(!zoneptr)) return -1;
 
-		internal = 1;
+		internal = 1; /* internally created. must be freed upon moo_xma_fini() */
 	}
 
 	first = (moo_xma_fblk_t*)zoneptr;
@@ -259,7 +259,7 @@ int moo_xma_init (moo_xma_t* xma, moo_mmgr_t* mmgr, void* zoneptr, moo_oow_t zon
 	/* let it be the head, which is natural with only a block */
 	xma->start = (moo_uint8_t*)first;
 	xma->end = xma->start + zonesize;
-	xma->internal = 1;
+	xma->internal = internal;
 
 	/* initialize some statistical variables */
 #if defined(MOO_XMA_ENABLE_STAT)