X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2Flisp%2Fao_lisp_mem.c;h=0dfad1d7c87bcc6286b924698730a63a849c3dcb;hb=e600fc409c577eec02af612a36431c477a9c875e;hp=37d0af2b3e317194ddf70f07c4ca0b6f849be264;hpb=c8f9db184cc929ebde845730a6d4b7864e423a84;p=fw%2Faltos

diff --git a/src/lisp/ao_lisp_mem.c b/src/lisp/ao_lisp_mem.c
index 37d0af2b..0dfad1d7 100644
--- a/src/lisp/ao_lisp_mem.c
+++ b/src/lisp/ao_lisp_mem.c
@@ -144,6 +144,7 @@ struct ao_lisp_root {
 
 static struct ao_lisp_cons 	*save_cons[2];
 static char			*save_string[2];
+static struct ao_lisp_stack	*save_stack[3];
 static ao_poly			save_poly[2];
 
 static const struct ao_lisp_root	ao_lisp_root[] = {
@@ -155,6 +156,18 @@ static const struct ao_lisp_root	ao_lisp_root[] = {
 		.type = &ao_lisp_cons_type,
 		.addr = (void **) &save_cons[1],
 	},
+	{
+		.type = &ao_lisp_stack_type,
+		.addr = (void **) &save_stack[0]
+	},
+	{
+		.type = &ao_lisp_stack_type,
+		.addr = (void **) &save_stack[1]
+	},
+	{
+		.type = &ao_lisp_stack_type,
+		.addr = (void **) &save_stack[2]
+	},
 	{
 		.type = &ao_lisp_string_type,
 		.addr = (void **) &save_string[0]
@@ -252,23 +265,6 @@ static inline uint16_t pool_offset(void *addr) {
 	return ((uint8_t *) addr) - ao_lisp_pool;
 }
 
-/*
- * Convert back and forth between 'poly's used
- * as short addresses in the pool and addresses.
- * These are used in the chunk code.
- */
-static inline ao_poly pool_poly(void *addr) {
-#if DBG_MEM
-	if (!AO_LISP_IS_POOL(addr))
-		ao_lisp_abort();
-#endif
-	return ((uint8_t *) addr) - AO_LISP_POOL_BASE;
-}
-
-static inline void *pool_ref(ao_poly p) {
-	return AO_LISP_POOL_BASE + p;
-}
-
 static inline void mark(uint8_t *tag, int offset) {
 	int	byte = offset >> 5;
 	int	bit = (offset >> 2) & 7;
@@ -307,37 +303,70 @@ note_cons(void *addr)
 	}
 }
 
-static uint16_t	chunk_low;
+static uint16_t	chunk_low, chunk_high;
 static uint16_t	chunk_first, chunk_last;
+static int chunk_busy;
 
 static void
 note_chunk(uint16_t addr, uint16_t size)
 {
-	int i;
+	int l, r;
 
-	if (addr < chunk_low)
+	if (addr < chunk_low || chunk_high <= addr)
 		return;
 
-	for (i = 0; i < AO_LISP_NCHUNK; i++) {
-		if (ao_lisp_chunk[i].size && ao_lisp_chunk[i].old_addr == addr) {
+	/* Binary search for the location */
+	l = 0;
+	r = chunk_busy - 1;
+	while (l <= r) {
+		int m = (l + r) >> 1;
+		if (ao_lisp_chunk[m].old_addr < addr)
+			l = m + 1;
+		else
+			r = m - 1;
+	}
+	/*
+	 * The correct location is always in 'l', with r = l-1 being
+	 * the entry before the right one
+	 */
+
 #if DBG_MEM
-			if (ao_lisp_chunk[i].size != size)
-				ao_lisp_abort();
+	/* Off the right side */
+	if (l >= AO_LISP_NCHUNK)
+		ao_lisp_abort();
+
+	/* Off the left side */
+	if (l == 0 && chunk_busy && addr > ao_lisp_chunk[0].old_addr)
+		ao_lisp_abort();
 #endif
-			return;
-		}
-		if (ao_lisp_chunk[i].old_addr > addr) {
-			memmove(&ao_lisp_chunk[i+1],
-				&ao_lisp_chunk[i],
-				(AO_LISP_NCHUNK - (i+1)) * sizeof (struct ao_lisp_chunk));
-			ao_lisp_chunk[i].size = 0;
-		}
-		if (ao_lisp_chunk[i].size == 0) {
-			ao_lisp_chunk[i].old_addr = addr;
-			ao_lisp_chunk[i].size = size;
-			return;
-		}
-	}
+
+	/* Shuffle existing entries right */
+	int end = min(AO_LISP_NCHUNK, chunk_busy + 1);
+
+	memmove(&ao_lisp_chunk[l+1],
+		&ao_lisp_chunk[l],
+		(end - (l+1)) * sizeof (struct ao_lisp_chunk));
+
+	/* Add new entry */
+	ao_lisp_chunk[l].old_addr = addr;
+	ao_lisp_chunk[l].size = size;
+
+	/* Increment the number of elements up to the size of the array */
+	if (chunk_busy < AO_LISP_NCHUNK)
+		chunk_busy++;
+
+	/* Set the top address if the array is full */
+	if (chunk_busy == AO_LISP_NCHUNK)
+		chunk_high = ao_lisp_chunk[AO_LISP_NCHUNK-1].old_addr +
+			ao_lisp_chunk[AO_LISP_NCHUNK-1].size;
+}
+
+static void
+reset_chunks(void)
+{
+	memset(ao_lisp_chunk, '\0', sizeof (ao_lisp_chunk));
+	chunk_high = ao_lisp_top;
+	chunk_busy = 0;
 }
 
 /*
@@ -418,6 +447,7 @@ static const struct ao_lisp_type const *ao_lisp_types[AO_LISP_NUM_TYPE] = {
 	[AO_LISP_BUILTIN] = &ao_lisp_builtin_type,
 	[AO_LISP_FRAME] = &ao_lisp_frame_type,
 	[AO_LISP_LAMBDA] = &ao_lisp_lambda_type,
+	[AO_LISP_STACK] = &ao_lisp_stack_type,
 };
 
 static int
@@ -434,6 +464,7 @@ ao_lisp_poly_mark_ref(ao_poly *p, uint8_t do_note_cons)
 
 int ao_lisp_collects[2];
 int ao_lisp_freed[2];
+int ao_lisp_loops[2];
 
 int ao_lisp_last_top;
 
@@ -453,7 +484,9 @@ ao_lisp_collect(uint8_t style)
 	marked = moved = 0;
 #endif
 
-	++ao_lisp_collects[style];
+	/* The first time through, we're doing a full collect */
+	if (ao_lisp_last_top == 0)
+		style = AO_LISP_COLLECT_FULL;
 
 	/* Clear references to all caches */
 	for (i = 0; i < (int) AO_LISP_CACHE; i++)
@@ -467,7 +500,7 @@ ao_lisp_collect(uint8_t style)
 		loops++;
 		MDBG_MOVE("move chunks from %d to %d\n", chunk_low, top);
 		/* Find the sizes of the first chunk of objects to move */
-		memset(ao_lisp_chunk, '\0', sizeof (ao_lisp_chunk));
+		reset_chunks();
 		walk(ao_lisp_mark_ref, ao_lisp_poly_mark_ref);
 #if DBG_MEM
 		marked = total_marked;
@@ -501,7 +534,6 @@ ao_lisp_collect(uint8_t style)
 			MDBG_MOVE("chunk %d %d not moving\n",
 				  ao_lisp_chunk[i].old_addr,
 				  ao_lisp_chunk[i].size);
-			chunk_low = ao_lisp_chunk[i].old_addr + size;
 		}
 
 		chunk_first = i;
@@ -521,7 +553,6 @@ ao_lisp_collect(uint8_t style)
 				&ao_lisp_pool[ao_lisp_chunk[i].old_addr],
 				size);
 			top += size;
-			chunk_low = ao_lisp_chunk[i].old_addr + size;
 		}
 
 		chunk_last = i;
@@ -544,18 +575,25 @@ ao_lisp_collect(uint8_t style)
 
 		if (chunk_last != AO_LISP_NCHUNK)
 			break;
+
+		chunk_low = chunk_high;
 	}
+
+	/* Compute amount of memory freed */
 	ret = ao_lisp_top - top;
+
+	/* Collect stats */
+	++ao_lisp_collects[style];
 	ao_lisp_freed[style] += ret;
+	ao_lisp_loops[style] += loops;
 
 	ao_lisp_top = top;
-	if (style == AO_LISP_COLLECT_FULL || ao_lisp_last_top == 0)
+	if (style == AO_LISP_COLLECT_FULL)
 		ao_lisp_last_top = top;
 
 	MDBG_DO(memset(ao_lisp_chunk, '\0', sizeof (ao_lisp_chunk));
 		walk(ao_lisp_mark_ref, ao_lisp_poly_mark_ref));
 
-//	printf ("collect. style %d loops %d freed %d\n", style, loops, ret);
 	return ret;
 }
 
@@ -794,6 +832,20 @@ ao_lisp_cons_fetch(int id)
 	return cons;
 }
 
+void
+ao_lisp_stack_stash(int id, struct ao_lisp_stack *stack)
+{
+	save_stack[id] = stack;
+}
+
+struct ao_lisp_stack *
+ao_lisp_stack_fetch(int id)
+{
+	struct ao_lisp_stack *stack = save_stack[id];
+	save_stack[id] = NULL;
+	return stack;
+}
+
 void
 ao_lisp_string_stash(int id, char *string)
 {