shithub: sl

Info  •  Files  •  Log  •  Branches

use segments for heap

Instead of allocating using malloc, use mmap (or segattach on Plan 9).
On POSIX systems use madvise with DONTNEED on heap after GC to specify
how much of the heap is actually used.

Fixes: https://todo.sr.ht/~ft/sl/45

--- a/src/mem.h

+++ b/src/mem.h

@@ -23,6 +23,7 @@

 #define MEM_STRDUP(s) sl_strdup(s)

 #define sl_segalloc(sz) MEM_ALLOC((size_t)sz)

 #define sl_segfree(s, sz) MEM_FREE(s)

+#define sl_segused(s, sz, used) do{}while(0)

 #else

 #define MEM_CALLOC(n, sz) calloc((size_t)(n), (size_t)(sz))

 #define MEM_ALLOC(n) malloc((size_t)(n))

@@ -31,4 +32,5 @@

 #define MEM_STRDUP(s) strdup(s)

 void *sl_segalloc(size_t sz);

 void sl_segfree(void *s, size_t sz);

+void sl_segused(void *s, size_t sz, size_t used);

 #endif

--- a/src/plan9/sys.c

+++ b/src/plan9/sys.c

@@ -25,7 +25,14 @@

 sl_segfree(void *s, size_t sz)

 {

 	USED(sz);

-	segdetach(s);

+	if(s != nil)

+		segdetach(s);

+}

+

+void

+sl_segused(void *s, size_t sz, size_t used)

+{

+	USED(s); USED(sz); USED(used);

 }

 /*

--- a/src/posix/sys.c

+++ b/src/posix/sys.c

@@ -18,9 +18,20 @@

 void

 sl_segfree(void *s, size_t sz)

 {

+	if(s == nil)

+		return;

 	sz = PAGEALIGNED(sz);

 	if(munmap(s, sz) != 0)

 		abort();

+}

+

+void

+sl_segused(void *s, size_t sz, size_t used)

+{

+	sz = PAGEALIGNED(sz);

+	used = PAGEALIGNED(used);

+	// it's fine if this fails

+	madvise((uint8_t*)s+used, sz-used, MADV_DONTNEED);

 }

 double

--- a/src/sl.c

+++ b/src/sl.c

@@ -515,14 +515,25 @@

 	SL(tospace) = SL(fromspace);

 	SL(fromspace) = temp;

+	// FIXME(sigrid): add some extra to the "used"?

+	sl_segused(SL(fromspace), SL(heapsize), SL(curheap)-SL(fromspace));

+

 	// if we're using > 80% of the space, resize tospace so we have

 	// more space to fill next time. if we grew tospace last time,

 	// grow the other half of the heap this time to catch up.

 	if(SL(grew) || ((intptr_t)(SL(lim)-SL(curheap)) < (intptr_t)SL(heapsize)/5) || mustgrow){

-		temp = MEM_REALLOC(SL(tospace), SL(heapsize)*2);

-		if(sl_unlikely(temp == nil))

+		sl_segfree(SL(tospace), SL(heapsize));

+		SL(tospace) = sl_segalloc(SL(heapsize)*2);

+		if(sl_unlikely(SL(tospace) == nil)){

+			SL(tospace) = sl_segalloc(SL(heapsize));

+			if(SL(tospace) == nil){

+				// FIXME(sigrid): lost it entirely. give up?

+				// alternatively, wait and try indefinitely?

+				ios_printf(ios_stderr, "lost tospace\n");

+				exit(1);

+			}

 			sl_raise(SL(memory_exception_value));

-		SL(tospace) = temp;

+		}

 		if(SL(grew)){

 			SL(heapsize) *= 2;

 			temp = bitvector_resize(SL(consflags), 0, SL(heapsize)/sizeof(cons_t), 1);

@@ -1185,12 +1196,12 @@

 	SL(heapsize) = heapsize*sizeof(value_t);

-	if((SL(fromspace) = MEM_ALLOC(SL(heapsize))) == nil){

+	if((SL(fromspace) = sl_segalloc(SL(heapsize))) == nil){

 failed:

-		MEM_FREE(SL(fromspace));

-		MEM_FREE(SL(tospace));

 		MEM_FREE(SL(consflags));

 		MEM_FREE(SL(finalizers));

+		sl_segfree(SL(fromspace), SL(heapsize));

+		sl_segfree(SL(tospace), SL(heapsize));

 		sl_segfree(SL(stack), stacksize*sizeof(value_t));

 		htable_free(&SL(printconses));

 		MEM_FREE(sl);

@@ -1197,7 +1208,7 @@

 		return -1;

 	}

-	if((SL(tospace) = MEM_ALLOC(SL(heapsize))) == nil)

+	if((SL(tospace) = sl_segalloc(SL(heapsize))) == nil)

 		goto failed;

 	SL(curheap) = SL(fromspace);

 	SL(lim) = SL(curheap)+SL(heapsize)-sizeof(cons_t);