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;
}
}
-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;
}
/*
int ao_lisp_collects[2];
int ao_lisp_freed[2];
+int ao_lisp_loops[2];
int ao_lisp_last_top;
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++)
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;
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;
&ao_lisp_pool[ao_lisp_chunk[i].old_addr],
size);
top += size;
- chunk_low = ao_lisp_chunk[i].old_addr + size;
}
chunk_last = i;
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;
}