#include <stdio.h>
#include <signal.h>
#include <errno.h>
-#include "runtime.h"
+#include <string.h>
#include "sbcl.h"
+#include "runtime.h"
#include "os.h"
#include "interr.h"
#include "globals.h"
#include "validate.h"
#include "lispregs.h"
#include "arch.h"
+#include "fixnump.h"
#include "gc.h"
#include "gc-internal.h"
#include "thread.h"
#include "genesis/weak-pointer.h"
#include "genesis/simple-fun.h"
-#ifdef LISP_FEATURE_SB_THREAD
-#include <sys/ptrace.h>
-#include <linux/user.h> /* threading is presently linux-only */
-#endif
-
/* assembly language stub that executes trap_PendingInterrupt */
void do_pending_interrupt(void);
/* forward declarations */
-int gc_find_freeish_pages(int *restart_page_ptr, int nbytes, int unboxed, struct alloc_region *alloc_region);
-void gc_set_region_empty(struct alloc_region *region);
-void gc_alloc_update_all_page_tables(void);
+int gc_find_freeish_pages(int *restart_page_ptr, int nbytes, int unboxed);
static void gencgc_pickup_dynamic(void);
boolean interrupt_maybe_gc_int(int, siginfo_t *, void *);
boolean enable_page_protection = 1;
/* Should we unmap a page and re-mmap it to have it zero filled? */
-#if defined(__FreeBSD__) || defined(__OpenBSD__)
+#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__)
/* comment from cmucl-2.4.8: This can waste a lot of swap on FreeBSD
* so don't unmap there.
*
#endif
/* the minimum size (in bytes) for a large object*/
-/* FIXME: Should this really be PAGE_BYTES? */
unsigned large_object_size = 4 * PAGE_BYTES;
\f
/* the verbosity level. All non-error messages are disabled at level 0;
* and only a few rare messages are printed at level 1. */
-unsigned gencgc_verbose = (QSHOW ? 1 : 0);
+#ifdef QSHOW
+unsigned gencgc_verbose = 1;
+#else
+unsigned gencgc_verbose = 0;
+#endif
/* FIXME: At some point enable the various error-checking things below
* and see what they say. */
int count = 0;
for (i = 0; i < last_free_page; i++)
- if ((page_table[i].allocated != FREE_PAGE)
+ if ((page_table[i].allocated != FREE_PAGE_FLAG)
&& (page_table[i].gen == generation)
&& (page_table[i].write_protected == 1))
count++;
return count;
}
-/* Count the number of dont_move pages. */
+#ifdef QSHOW
static int
count_dont_move_pages(void)
{
}
return count;
}
+#endif /* QSHOW */
/* Work through the pages and add up the number of bytes used for the
* given generation. */
/* Print the heap stats. */
fprintf(stderr,
- " Generation Boxed Unboxed LB LUB Alloc Waste Trig WP GCs Mem-age\n");
+ " Gen Boxed Unboxed LB LUB !move Alloc Waste Trig WP GCs Mem-age\n");
for (i = 0; i < gens; i++) {
int j;
int unboxed_cnt = 0;
int large_boxed_cnt = 0;
int large_unboxed_cnt = 0;
+ int pinned_cnt=0;
for (j = 0; j < last_free_page; j++)
if (page_table[j].gen == i) {
/* Count the number of boxed pages within the given
* generation. */
- if (page_table[j].allocated & BOXED_PAGE) {
+ if (page_table[j].allocated & BOXED_PAGE_FLAG) {
if (page_table[j].large_object)
large_boxed_cnt++;
else
boxed_cnt++;
}
-
+ if(page_table[j].dont_move) pinned_cnt++;
/* Count the number of unboxed pages within the given
* generation. */
- if (page_table[j].allocated & UNBOXED_PAGE) {
+ if (page_table[j].allocated & UNBOXED_PAGE_FLAG) {
if (page_table[j].large_object)
large_unboxed_cnt++;
else
gc_assert(generations[i].bytes_allocated
== count_generation_bytes_allocated(i));
fprintf(stderr,
- " %8d: %5d %5d %5d %5d %8d %5d %8d %4d %3d %7.4f\n",
+ " %1d: %5d %5d %5d %5d %5d %8d %5d %8d %4d %3d %7.4f\n",
i,
boxed_cnt, unboxed_cnt, large_boxed_cnt, large_unboxed_cnt,
+ pinned_cnt,
generations[i].bytes_allocated,
(count_generation_pages(i)*PAGE_BYTES
- generations[i].bytes_allocated),
first_page =
generations[gc_alloc_generation].alloc_start_page;
}
- last_page=gc_find_freeish_pages(&first_page,nbytes,unboxed,alloc_region);
+ last_page=gc_find_freeish_pages(&first_page,nbytes,unboxed);
bytes_found=(PAGE_BYTES - page_table[first_page].bytes_used)
+ PAGE_BYTES*(last_page-first_page);
/* The first page may have already been in use. */
if (page_table[first_page].bytes_used == 0) {
if (unboxed)
- page_table[first_page].allocated = UNBOXED_PAGE;
+ page_table[first_page].allocated = UNBOXED_PAGE_FLAG;
else
- page_table[first_page].allocated = BOXED_PAGE;
+ page_table[first_page].allocated = BOXED_PAGE_FLAG;
page_table[first_page].gen = gc_alloc_generation;
page_table[first_page].large_object = 0;
page_table[first_page].first_object_offset = 0;
}
if (unboxed)
- gc_assert(page_table[first_page].allocated == UNBOXED_PAGE);
+ gc_assert(page_table[first_page].allocated == UNBOXED_PAGE_FLAG);
else
- gc_assert(page_table[first_page].allocated == BOXED_PAGE);
- page_table[first_page].allocated |= OPEN_REGION_PAGE;
+ gc_assert(page_table[first_page].allocated == BOXED_PAGE_FLAG);
+ page_table[first_page].allocated |= OPEN_REGION_PAGE_FLAG;
gc_assert(page_table[first_page].gen == gc_alloc_generation);
gc_assert(page_table[first_page].large_object == 0);
for (i = first_page+1; i <= last_page; i++) {
if (unboxed)
- page_table[i].allocated = UNBOXED_PAGE;
+ page_table[i].allocated = UNBOXED_PAGE_FLAG;
else
- page_table[i].allocated = BOXED_PAGE;
+ page_table[i].allocated = BOXED_PAGE_FLAG;
page_table[i].gen = gc_alloc_generation;
page_table[i].large_object = 0;
/* This may not be necessary for unboxed regions (think it was
* broken before!) */
page_table[i].first_object_offset =
alloc_region->start_addr - page_address(i);
- page_table[i].allocated |= OPEN_REGION_PAGE ;
+ page_table[i].allocated |= OPEN_REGION_PAGE_FLAG ;
}
/* Bump up last_free_page. */
if (last_page+1 > last_free_page) {
int region_size;
int byte_cnt;
- /*
- FSHOW((stderr,
- "/gc_alloc_update_page_tables() to gen %d:\n",
- gc_alloc_generation));
- */
first_page = alloc_region->first_page;
* first_object_offset. */
if (page_table[first_page].bytes_used == 0)
gc_assert(page_table[first_page].first_object_offset == 0);
- page_table[first_page].allocated &= ~(OPEN_REGION_PAGE);
+ page_table[first_page].allocated &= ~(OPEN_REGION_PAGE_FLAG);
if (unboxed)
- gc_assert(page_table[first_page].allocated == UNBOXED_PAGE);
+ gc_assert(page_table[first_page].allocated == UNBOXED_PAGE_FLAG);
else
- gc_assert(page_table[first_page].allocated == BOXED_PAGE);
+ gc_assert(page_table[first_page].allocated == BOXED_PAGE_FLAG);
gc_assert(page_table[first_page].gen == gc_alloc_generation);
gc_assert(page_table[first_page].large_object == 0);
* first_object_offset pointer to the start of the region, and set
* the bytes_used. */
while (more) {
- page_table[next_page].allocated &= ~(OPEN_REGION_PAGE);
+ page_table[next_page].allocated &= ~(OPEN_REGION_PAGE_FLAG);
if (unboxed)
- gc_assert(page_table[next_page].allocated == UNBOXED_PAGE);
+ gc_assert(page_table[next_page].allocated==UNBOXED_PAGE_FLAG);
else
- gc_assert(page_table[next_page].allocated == BOXED_PAGE);
+ gc_assert(page_table[next_page].allocated == BOXED_PAGE_FLAG);
gc_assert(page_table[next_page].bytes_used == 0);
gc_assert(page_table[next_page].gen == gc_alloc_generation);
gc_assert(page_table[next_page].large_object == 0);
} else {
/* There are no bytes allocated. Unallocate the first_page if
* there are 0 bytes_used. */
- page_table[first_page].allocated &= ~(OPEN_REGION_PAGE);
+ page_table[first_page].allocated &= ~(OPEN_REGION_PAGE_FLAG);
if (page_table[first_page].bytes_used == 0)
- page_table[first_page].allocated = FREE_PAGE;
+ page_table[first_page].allocated = FREE_PAGE_FLAG;
}
/* Unallocate any unused pages. */
while (next_page <= alloc_region->last_page) {
gc_assert(page_table[next_page].bytes_used == 0);
- page_table[next_page].allocated = FREE_PAGE;
+ page_table[next_page].allocated = FREE_PAGE_FLAG;
next_page++;
}
release_spinlock(&free_pages_lock);
int more;
int bytes_used;
int next_page;
- int large = (nbytes >= large_object_size);
-
- /*
- if (nbytes > 200000)
- FSHOW((stderr, "/alloc_large %d\n", nbytes));
- */
-
- /*
- FSHOW((stderr,
- "/gc_alloc_large() for %d bytes from gen %d\n",
- nbytes, gc_alloc_generation));
- */
-
- /* If the object is small, and there is room in the current region
- then allocate it in the current region. */
- if (!large
- && ((alloc_region->end_addr-alloc_region->free_pointer) >= nbytes))
- return gc_quick_alloc(nbytes);
-
- /* To allow the allocation of small objects without the danger of
- using a page in the current boxed region, the search starts after
- the current boxed free region. XX could probably keep a page
- index ahead of the current region and bumped up here to save a
- lot of re-scanning. */
get_spinlock(&free_pages_lock,(int) alloc_region);
first_page = alloc_region->last_page+1;
}
- last_page=gc_find_freeish_pages(&first_page,nbytes,unboxed,0);
+ last_page=gc_find_freeish_pages(&first_page,nbytes,unboxed);
gc_assert(first_page > alloc_region->last_page);
if (unboxed)
* first_object_offset. */
if (page_table[first_page].bytes_used == 0) {
if (unboxed)
- page_table[first_page].allocated = UNBOXED_PAGE;
+ page_table[first_page].allocated = UNBOXED_PAGE_FLAG;
else
- page_table[first_page].allocated = BOXED_PAGE;
+ page_table[first_page].allocated = BOXED_PAGE_FLAG;
page_table[first_page].gen = gc_alloc_generation;
page_table[first_page].first_object_offset = 0;
- page_table[first_page].large_object = large;
+ page_table[first_page].large_object = 1;
}
if (unboxed)
- gc_assert(page_table[first_page].allocated == UNBOXED_PAGE);
+ gc_assert(page_table[first_page].allocated == UNBOXED_PAGE_FLAG);
else
- gc_assert(page_table[first_page].allocated == BOXED_PAGE);
+ gc_assert(page_table[first_page].allocated == BOXED_PAGE_FLAG);
gc_assert(page_table[first_page].gen == gc_alloc_generation);
- gc_assert(page_table[first_page].large_object == large);
+ gc_assert(page_table[first_page].large_object == 1);
byte_cnt = 0;
* first_object_offset pointer to the start of the region, and
* set the bytes_used. */
while (more) {
- gc_assert(page_table[next_page].allocated == FREE_PAGE);
+ gc_assert(page_table[next_page].allocated == FREE_PAGE_FLAG);
gc_assert(page_table[next_page].bytes_used == 0);
if (unboxed)
- page_table[next_page].allocated = UNBOXED_PAGE;
+ page_table[next_page].allocated = UNBOXED_PAGE_FLAG;
else
- page_table[next_page].allocated = BOXED_PAGE;
+ page_table[next_page].allocated = BOXED_PAGE_FLAG;
page_table[next_page].gen = gc_alloc_generation;
- page_table[next_page].large_object = large;
+ page_table[next_page].large_object = 1;
page_table[next_page].first_object_offset =
orig_first_page_bytes_used - PAGE_BYTES*(next_page-first_page);
more = 1;
}
page_table[next_page].bytes_used = bytes_used;
+ page_table[next_page].write_protected=0;
+ page_table[next_page].dont_move=0;
byte_cnt += bytes_used;
-
next_page++;
}
}
int
-gc_find_freeish_pages(int *restart_page_ptr, int nbytes, int unboxed, struct alloc_region *alloc_region)
+gc_find_freeish_pages(int *restart_page_ptr, int nbytes, int unboxed)
{
- /* if alloc_region is 0, we assume this is for a potentially large
- object */
int first_page;
int last_page;
int region_size;
int restart_page=*restart_page_ptr;
int bytes_found;
int num_pages;
- int large = !alloc_region && (nbytes >= large_object_size);
-
+ int large_p=(nbytes>=large_object_size);
gc_assert(free_pages_lock);
- /* Search for a contiguous free space of at least nbytes. If it's a
- large object then align it on a page boundary by searching for a
- free page. */
- /* To allow the allocation of small objects without the danger of
- using a page in the current boxed region, the search starts after
- the current boxed free region. XX could probably keep a page
- index ahead of the current region and bumped up here to save a
- lot of re-scanning. */
+ /* Search for a contiguous free space of at least nbytes. If it's
+ * a large object then align it on a page boundary by searching
+ * for a free page. */
do {
first_page = restart_page;
- if (large)
+ if (large_p)
while ((first_page < NUM_PAGES)
- && (page_table[first_page].allocated != FREE_PAGE))
+ && (page_table[first_page].allocated != FREE_PAGE_FLAG))
first_page++;
else
while (first_page < NUM_PAGES) {
- if(page_table[first_page].allocated == FREE_PAGE)
+ if(page_table[first_page].allocated == FREE_PAGE_FLAG)
break;
- /* I don't know why we need the gen=0 test, but it
- * breaks randomly if that's omitted -dan 2003.02.26
- */
if((page_table[first_page].allocated ==
- (unboxed ? UNBOXED_PAGE : BOXED_PAGE)) &&
+ (unboxed ? UNBOXED_PAGE_FLAG : BOXED_PAGE_FLAG)) &&
(page_table[first_page].large_object == 0) &&
- (gc_alloc_generation == 0) &&
(page_table[first_page].gen == gc_alloc_generation) &&
(page_table[first_page].bytes_used < (PAGE_BYTES-32)) &&
(page_table[first_page].write_protected == 0) &&
- (page_table[first_page].dont_move == 0))
+ (page_table[first_page].dont_move == 0)) {
break;
+ }
first_page++;
}
bytes_found = PAGE_BYTES - page_table[first_page].bytes_used;
num_pages = 1;
while (((bytes_found < nbytes)
- || (alloc_region && (num_pages < 2)))
+ || (!large_p && (num_pages < 2)))
&& (last_page < (NUM_PAGES-1))
- && (page_table[last_page+1].allocated == FREE_PAGE)) {
+ && (page_table[last_page+1].allocated == FREE_PAGE_FLAG)) {
last_page++;
num_pages++;
bytes_found += PAGE_BYTES;
}
/* Allocate bytes. All the rest of the special-purpose allocation
- * functions will eventually call this (instead of just duplicating
- * parts of its code) */
+ * functions will eventually call this */
void *
gc_alloc_with_region(int nbytes,int unboxed_p, struct alloc_region *my_region,
{
void *new_free_pointer;
- /* FSHOW((stderr, "/gc_alloc %d\n", nbytes)); */
+ if(nbytes>=large_object_size)
+ return gc_alloc_large(nbytes,unboxed_p,my_region);
/* Check whether there is room in the current alloc region. */
new_free_pointer = my_region->free_pointer + nbytes;
return((void *)new_obj);
}
- /* Else not enough free space in the current region. */
-
- /* If there some room left in the current region, enough to be worth
- * saving, then allocate a large object. */
- /* FIXME: "32" should be a named parameter. */
- if ((my_region->end_addr-my_region->free_pointer) > 32)
- return gc_alloc_large(nbytes, unboxed_p, my_region);
+ /* Else not enough free space in the current region: retry with a
+ * new region. */
- /* Else find a new region. */
-
- /* Finished with the current region. */
gc_alloc_update_page_tables(unboxed_p, my_region);
-
- /* Set up a new region. */
gc_alloc_new_region(nbytes, unboxed_p, my_region);
-
- /* Should now be enough room. */
-
- /* Check whether there is room in the current region. */
- new_free_pointer = my_region->free_pointer + nbytes;
-
- if (new_free_pointer <= my_region->end_addr) {
- /* If so then allocate from the current region. */
- void *new_obj = my_region->free_pointer;
- my_region->free_pointer = new_free_pointer;
- /* Check whether the current region is almost empty. */
- if ((my_region->end_addr - my_region->free_pointer) <= 32) {
- /* If so find, finished with the current region. */
- gc_alloc_update_page_tables(unboxed_p, my_region);
-
- /* Set up a new region. */
- gc_alloc_new_region(32, unboxed_p, my_region);
- }
-
- return((void *)new_obj);
- }
-
- /* shouldn't happen */
- gc_assert(0);
- return((void *) NIL); /* dummy value: return something ... */
+ return gc_alloc_with_region(nbytes,unboxed_p,my_region,0);
}
+/* these are only used during GC: all allocation from the mutator calls
+ * alloc() -> gc_alloc_with_region() with the appropriate per-thread
+ * region */
+
void *
gc_general_alloc(int nbytes,int unboxed_p,int quick_p)
{
return gc_alloc_with_region(nbytes,unboxed_p, my_region,quick_p);
}
-
-
-static void *
-gc_alloc(int nbytes,int unboxed_p)
-{
- /* this is the only function that the external interface to
- * allocation presently knows how to call: Lisp code will never
- * allocate large objects, or to unboxed space, or `quick'ly.
- * Any of that stuff will only ever happen inside of GC */
- return gc_general_alloc(nbytes,unboxed_p,0);
-}
-
-/* Allocate space from the boxed_region. If there is not enough free
- * space then call gc_alloc to do the job. A pointer to the start of
- * the object is returned. */
static inline void *
gc_quick_alloc(int nbytes)
{
return gc_general_alloc(nbytes,ALLOC_BOXED,ALLOC_QUICK);
}
-/* Allocate space for the possibly large boxed object. If it is a
- * large object then do a large alloc else use gc_quick_alloc. Note
- * that gc_quick_alloc will eventually fall through to
- * gc_general_alloc which may allocate the object in a large way
- * anyway, but based on decisions about the free space in the current
- * region, not the object size itself */
-
static inline void *
gc_quick_alloc_large(int nbytes)
{
- if (nbytes >= large_object_size)
- return gc_alloc_large(nbytes, ALLOC_BOXED, &boxed_region);
- else
- return gc_general_alloc(nbytes,ALLOC_BOXED,ALLOC_QUICK);
+ return gc_general_alloc(nbytes,ALLOC_BOXED,ALLOC_QUICK);
}
static inline void *
return gc_general_alloc(nbytes,ALLOC_UNBOXED,ALLOC_QUICK);
}
-/* Allocate space for the object. If it is a large object then do a
- * large alloc else allocate from the current region. If there is not
- * enough free space then call general gc_alloc_unboxed() to do the job.
- *
- * A pointer to the start of the object is returned. */
static inline void *
gc_quick_alloc_large_unboxed(int nbytes)
{
- if (nbytes >= large_object_size)
- return gc_alloc_large(nbytes,ALLOC_UNBOXED,&unboxed_region);
- else
- return gc_quick_alloc_unboxed(nbytes);
+ return gc_general_alloc(nbytes,ALLOC_UNBOXED,ALLOC_QUICK);
}
\f
/*
{
int tag;
lispobj *new;
- lispobj *source, *dest;
int first_page;
gc_assert(is_lisp_pointer(object));
gc_assert((nwords & 0x01) == 0);
- /* Check whether it's a large object. */
+ /* Check whether it's in a large object region. */
first_page = find_page_index((void *)object);
gc_assert(first_page >= 0);
gc_assert(page_table[first_page].first_object_offset == 0);
next_page = first_page;
- remaining_bytes = nwords*4;
+ remaining_bytes = nwords*N_WORD_BYTES;
while (remaining_bytes > PAGE_BYTES) {
gc_assert(page_table[next_page].gen == from_space);
- gc_assert(page_table[next_page].allocated == BOXED_PAGE);
+ gc_assert(page_table[next_page].allocated == BOXED_PAGE_FLAG);
gc_assert(page_table[next_page].large_object);
gc_assert(page_table[next_page].first_object_offset==
-PAGE_BYTES*(next_page-first_page));
gc_assert(page_table[next_page].bytes_used >= remaining_bytes);
page_table[next_page].gen = new_space;
- gc_assert(page_table[next_page].allocated == BOXED_PAGE);
+ gc_assert(page_table[next_page].allocated == BOXED_PAGE_FLAG);
/* Adjust the bytes_used. */
old_bytes_used = page_table[next_page].bytes_used;
next_page++;
while ((old_bytes_used == PAGE_BYTES) &&
(page_table[next_page].gen == from_space) &&
- (page_table[next_page].allocated == BOXED_PAGE) &&
+ (page_table[next_page].allocated == BOXED_PAGE_FLAG) &&
page_table[next_page].large_object &&
(page_table[next_page].first_object_offset ==
-(next_page - first_page)*PAGE_BYTES)) {
gc_assert(page_table[next_page].write_protected == 0);
old_bytes_used = page_table[next_page].bytes_used;
- page_table[next_page].allocated = FREE_PAGE;
+ page_table[next_page].allocated = FREE_PAGE_FLAG;
page_table[next_page].bytes_used = 0;
bytes_freed += old_bytes_used;
next_page++;
bytes_allocated -= bytes_freed;
/* Add the region to the new_areas if requested. */
- add_new_area(first_page,0,nwords*4);
+ add_new_area(first_page,0,nwords*N_WORD_BYTES);
return(object);
} else {
tag = lowtag_of(object);
/* Allocate space. */
- new = gc_quick_alloc_large(nwords*4);
-
- dest = new;
- source = (lispobj *) native_pointer(object);
-
- /* Copy the object. */
- while (nwords > 0) {
- dest[0] = source[0];
- dest[1] = source[1];
- dest += 2;
- source += 2;
- nwords -= 2;
- }
+ new = gc_quick_alloc_large(nwords*N_WORD_BYTES);
+
+ memcpy(new,native_pointer(object),nwords*N_WORD_BYTES);
/* Return Lisp pointer of new object. */
return ((lispobj) new) | tag;
{
int tag;
lispobj *new;
- lispobj *source, *dest;
gc_assert(is_lisp_pointer(object));
gc_assert(from_space_p(object));
tag = lowtag_of(object);
/* Allocate space. */
- new = gc_quick_alloc_unboxed(nwords*4);
-
- dest = new;
- source = (lispobj *) native_pointer(object);
-
- /* Copy the object. */
- while (nwords > 0) {
- dest[0] = source[0];
- dest[1] = source[1];
- dest += 2;
- source += 2;
- nwords -= 2;
- }
+ new = gc_quick_alloc_unboxed(nwords*N_WORD_BYTES);
+
+ memcpy(new,native_pointer(object),nwords*N_WORD_BYTES);
/* Return Lisp pointer of new object. */
return ((lispobj) new) | tag;
{
int tag;
lispobj *new;
- lispobj *source, *dest;
int first_page;
gc_assert(is_lisp_pointer(object));
gc_assert((nwords & 0x01) == 0);
if ((nwords > 1024*1024) && gencgc_verbose)
- FSHOW((stderr, "/copy_large_unboxed_object: %d bytes\n", nwords*4));
+ FSHOW((stderr, "/copy_large_unboxed_object: %d bytes\n", nwords*N_WORD_BYTES));
/* Check whether it's a large object. */
first_page = find_page_index((void *)object);
gc_assert(page_table[first_page].first_object_offset == 0);
next_page = first_page;
- remaining_bytes = nwords*4;
+ remaining_bytes = nwords*N_WORD_BYTES;
while (remaining_bytes > PAGE_BYTES) {
gc_assert(page_table[next_page].gen == from_space);
- gc_assert((page_table[next_page].allocated == UNBOXED_PAGE)
- || (page_table[next_page].allocated == BOXED_PAGE));
+ gc_assert((page_table[next_page].allocated == UNBOXED_PAGE_FLAG)
+ || (page_table[next_page].allocated == BOXED_PAGE_FLAG));
gc_assert(page_table[next_page].large_object);
gc_assert(page_table[next_page].first_object_offset==
-PAGE_BYTES*(next_page-first_page));
gc_assert(page_table[next_page].bytes_used == PAGE_BYTES);
page_table[next_page].gen = new_space;
- page_table[next_page].allocated = UNBOXED_PAGE;
+ page_table[next_page].allocated = UNBOXED_PAGE_FLAG;
remaining_bytes -= PAGE_BYTES;
next_page++;
}
gc_assert(page_table[next_page].bytes_used >= remaining_bytes);
page_table[next_page].gen = new_space;
- page_table[next_page].allocated = UNBOXED_PAGE;
+ page_table[next_page].allocated = UNBOXED_PAGE_FLAG;
/* Adjust the bytes_used. */
old_bytes_used = page_table[next_page].bytes_used;
next_page++;
while ((old_bytes_used == PAGE_BYTES) &&
(page_table[next_page].gen == from_space) &&
- ((page_table[next_page].allocated == UNBOXED_PAGE)
- || (page_table[next_page].allocated == BOXED_PAGE)) &&
+ ((page_table[next_page].allocated == UNBOXED_PAGE_FLAG)
+ || (page_table[next_page].allocated == BOXED_PAGE_FLAG)) &&
page_table[next_page].large_object &&
(page_table[next_page].first_object_offset ==
-(next_page - first_page)*PAGE_BYTES)) {
gc_assert(page_table[next_page].write_protected == 0);
old_bytes_used = page_table[next_page].bytes_used;
- page_table[next_page].allocated = FREE_PAGE;
+ page_table[next_page].allocated = FREE_PAGE_FLAG;
page_table[next_page].bytes_used = 0;
bytes_freed += old_bytes_used;
next_page++;
"/copy_large_unboxed bytes_freed=%d\n",
bytes_freed));
- generations[from_space].bytes_allocated -= 4*nwords + bytes_freed;
- generations[new_space].bytes_allocated += 4*nwords;
+ generations[from_space].bytes_allocated -= nwords*N_WORD_BYTES + bytes_freed;
+ generations[new_space].bytes_allocated += nwords*N_WORD_BYTES;
bytes_allocated -= bytes_freed;
return(object);
tag = lowtag_of(object);
/* Allocate space. */
- new = gc_quick_alloc_large_unboxed(nwords*4);
-
- dest = new;
- source = (lispobj *) native_pointer(object);
-
- /* Copy the object. */
- while (nwords > 0) {
- dest[0] = source[0];
- dest[1] = source[1];
- dest += 2;
- source += 2;
- nwords -= 2;
- }
+ new = gc_quick_alloc_large_unboxed(nwords*N_WORD_BYTES);
+
+ /* Copy the object. */
+ memcpy(new,native_pointer(object),nwords*N_WORD_BYTES);
/* Return Lisp pointer of new object. */
return ((lispobj) new) | tag;
nheader_words = HeaderValue(*(lispobj *)code);
nwords = ncode_words + nheader_words;
- constants_start_addr = (void *)code + 5*4;
- constants_end_addr = (void *)code + nheader_words*4;
- code_start_addr = (void *)code + nheader_words*4;
- code_end_addr = (void *)code + nwords*4;
+ constants_start_addr = (void *)code + 5*N_WORD_BYTES;
+ constants_end_addr = (void *)code + nheader_words*N_WORD_BYTES;
+ code_start_addr = (void *)code + nheader_words*N_WORD_BYTES;
+ code_end_addr = (void *)code + nwords*N_WORD_BYTES;
/* Work through the unboxed code. */
for (p = code_start_addr; p < code_end_addr; p++) {
unsigned d2 = *((unsigned char *)p - 2);
unsigned d3 = *((unsigned char *)p - 3);
unsigned d4 = *((unsigned char *)p - 4);
-#if QSHOW
+#ifdef QSHOW
unsigned d5 = *((unsigned char *)p - 5);
unsigned d6 = *((unsigned char *)p - 6);
#endif
/* FSHOW((stderr,
"/compiled code object at %x: header words = %d, code words = %d\n",
new_code, nheader_words, ncode_words)); */
- constants_start_addr = (void *)new_code + 5*4;
- constants_end_addr = (void *)new_code + nheader_words*4;
- code_start_addr = (void *)new_code + nheader_words*4;
- code_end_addr = (void *)new_code + nwords*4;
+ constants_start_addr = (void *)new_code + 5*N_WORD_BYTES;
+ constants_end_addr = (void *)new_code + nheader_words*N_WORD_BYTES;
+ code_start_addr = (void *)new_code + nheader_words*N_WORD_BYTES;
+ code_end_addr = (void *)new_code + nwords*N_WORD_BYTES;
/*
FSHOW((stderr,
"/const start = %x, end = %x\n",
code objects. Check. */
fixups = new_code->constants[0];
- /* It will be 0 or the unbound-marker if there are no fixups, and
- * will be an other pointer if it is valid. */
+ /* It will be 0 or the unbound-marker if there are no fixups (as
+ * will be the case if the code object has been purified, for
+ * example) and will be an other pointer if it is valid. */
if ((fixups == 0) || (fixups == UNBOUND_MARKER_WIDETAG) ||
!is_lisp_pointer(fixups)) {
/* Check for possible errors. */
if (check_code_fixups)
sniff_code_object(new_code, displacement);
- /*fprintf(stderr,"Fixups for code object not found!?\n");
- fprintf(stderr,"*** Compiled code object at %x: header_words=%d code_words=%d .\n",
- new_code, nheader_words, ncode_words);
- fprintf(stderr,"*** Const. start = %x; end= %x; Code start = %x; end = %x\n",
- constants_start_addr,constants_end_addr,
- code_start_addr,code_end_addr);*/
return;
}
fixups_vector = (struct vector *)native_pointer(fixups);
/* Could be pointing to a forwarding pointer. */
+ /* FIXME is this always in from_space? if so, could replace this code with
+ * forwarding_pointer_p/forwarding_pointer_value */
if (is_lisp_pointer(fixups) &&
(find_page_index((void*)fixups_vector) != -1) &&
(fixups_vector->header == 0x01)) {
/* If it's within the old_code object then it must be an
* absolute fixup (relative ones are not saved) */
if ((old_value >= (unsigned)old_code)
- && (old_value < ((unsigned)old_code + nwords*4)))
+ && (old_value < ((unsigned)old_code + nwords*N_WORD_BYTES)))
/* So add the dispacement. */
*(unsigned *)((unsigned)code_start_addr + offset) =
old_value + displacement;
}
\f
-/* Scan an area looking for an object which encloses the given pointer.
- * Return the object start on success or NULL on failure. */
-static lispobj *
-search_space(lispobj *start, size_t words, lispobj *pointer)
-{
- while (words > 0) {
- size_t count = 1;
- lispobj thing = *start;
-
- /* If thing is an immediate then this is a cons. */
- if (is_lisp_pointer(thing)
- || ((thing & 3) == 0) /* fixnum */
- || (widetag_of(thing) == BASE_CHAR_WIDETAG)
- || (widetag_of(thing) == UNBOUND_MARKER_WIDETAG))
- count = 2;
- else
- count = (sizetab[widetag_of(thing)])(start);
-
- /* Check whether the pointer is within this object. */
- if ((pointer >= start) && (pointer < (start+count))) {
- /* found it! */
- /*FSHOW((stderr,"/found %x in %x %x\n", pointer, start, thing));*/
- return(start);
- }
-
- /* Round up the count. */
- count = CEILING(count,2);
-
- start += count;
- words -= count;
- }
- return (NULL);
-}
-
-lispobj*
-search_read_only_space(lispobj *pointer)
+lispobj *
+search_read_only_space(void *pointer)
{
- lispobj* start = (lispobj*)READ_ONLY_SPACE_START;
- lispobj* end = (lispobj*)SymbolValue(READ_ONLY_SPACE_FREE_POINTER,0);
- if ((pointer < start) || (pointer >= end))
+ lispobj *start = (lispobj *) READ_ONLY_SPACE_START;
+ lispobj *end = (lispobj *) SymbolValue(READ_ONLY_SPACE_FREE_POINTER,0);
+ if ((pointer < (void *)start) || (pointer >= (void *)end))
return NULL;
- return (search_space(start, (pointer+2)-start, pointer));
+ return (search_space(start,
+ (((lispobj *)pointer)+2)-start,
+ (lispobj *) pointer));
}
lispobj *
-search_static_space(lispobj *pointer)
+search_static_space(void *pointer)
{
- lispobj* start = (lispobj*)STATIC_SPACE_START;
- lispobj* end = (lispobj*)SymbolValue(STATIC_SPACE_FREE_POINTER,0);
- if ((pointer < start) || (pointer >= end))
+ lispobj *start = (lispobj *)STATIC_SPACE_START;
+ lispobj *end = (lispobj *)SymbolValue(STATIC_SPACE_FREE_POINTER,0);
+ if ((pointer < (void *)start) || (pointer >= (void *)end))
return NULL;
- return (search_space(start, (pointer+2)-start, pointer));
+ return (search_space(start,
+ (((lispobj *)pointer)+2)-start,
+ (lispobj *) pointer));
}
/* a faster version for searching the dynamic space. This will work even
* if the object is in a current allocation region. */
lispobj *
-search_dynamic_space(lispobj *pointer)
+search_dynamic_space(void *pointer)
{
- int page_index = find_page_index(pointer);
+ int page_index = find_page_index(pointer);
lispobj *start;
/* The address may be invalid, so do some checks. */
- if ((page_index == -1) || (page_table[page_index].allocated == FREE_PAGE))
+ if ((page_index == -1) ||
+ (page_table[page_index].allocated == FREE_PAGE_FLAG))
return NULL;
start = (lispobj *)((void *)page_address(page_index)
+ page_table[page_index].first_object_offset);
- return (search_space(start, (pointer+2)-start, pointer));
+ return (search_space(start,
+ (((lispobj *)pointer)+2)-start,
+ (lispobj *)pointer));
}
/* Is there any possibility that pointer is a valid Lisp object
}
/* Is it plausible cons? */
if ((is_lisp_pointer(start_addr[0])
- || ((start_addr[0] & 3) == 0) /* fixnum */
- || (widetag_of(start_addr[0]) == BASE_CHAR_WIDETAG)
+ || (fixnump(start_addr[0]))
+ || (widetag_of(start_addr[0]) == CHARACTER_WIDETAG)
|| (widetag_of(start_addr[0]) == UNBOUND_MARKER_WIDETAG))
&& (is_lisp_pointer(start_addr[1])
- || ((start_addr[1] & 3) == 0) /* fixnum */
- || (widetag_of(start_addr[1]) == BASE_CHAR_WIDETAG)
+ || (fixnump(start_addr[1]))
+ || (widetag_of(start_addr[1]) == CHARACTER_WIDETAG)
|| (widetag_of(start_addr[1]) == UNBOUND_MARKER_WIDETAG)))
break;
else {
}
switch (widetag_of(start_addr[0])) {
case UNBOUND_MARKER_WIDETAG:
- case BASE_CHAR_WIDETAG:
+ case CHARACTER_WIDETAG:
if (gencgc_verbose)
FSHOW((stderr,
"*Wo3: %x %x %x\n",
#endif
case SIMPLE_ARRAY_WIDETAG:
case COMPLEX_BASE_STRING_WIDETAG:
+#ifdef COMPLEX_CHARACTER_STRING_WIDETAG
+ case COMPLEX_CHARACTER_STRING_WIDETAG:
+#endif
case COMPLEX_VECTOR_NIL_WIDETAG:
case COMPLEX_BIT_VECTOR_WIDETAG:
case COMPLEX_VECTOR_WIDETAG:
case LONG_FLOAT_WIDETAG:
#endif
case SIMPLE_BASE_STRING_WIDETAG:
+#ifdef SIMPLE_CHARACTER_STRING_WIDETAG
+ case SIMPLE_CHARACTER_STRING_WIDETAG:
+#endif
case SIMPLE_BIT_VECTOR_WIDETAG:
case SIMPLE_ARRAY_NIL_WIDETAG:
case SIMPLE_ARRAY_UNSIGNED_BYTE_2_WIDETAG:
/* Check whether it's a vector or bignum object. */
switch (widetag_of(where[0])) {
case SIMPLE_VECTOR_WIDETAG:
- boxed = BOXED_PAGE;
+ boxed = BOXED_PAGE_FLAG;
break;
case BIGNUM_WIDETAG:
case SIMPLE_BASE_STRING_WIDETAG:
+#ifdef SIMPLE_CHARACTER_STRING_WIDETAG
+ case SIMPLE_CHARACTER_STRING_WIDETAG:
+#endif
case SIMPLE_BIT_VECTOR_WIDETAG:
case SIMPLE_ARRAY_NIL_WIDETAG:
case SIMPLE_ARRAY_UNSIGNED_BYTE_2_WIDETAG:
#ifdef SIMPLE_ARRAY_COMPLEX_LONG_FLOAT_WIDETAG
case SIMPLE_ARRAY_COMPLEX_LONG_FLOAT_WIDETAG:
#endif
- boxed = UNBOXED_PAGE;
+ boxed = UNBOXED_PAGE_FLAG;
break;
default:
return;
gc_assert(page_table[first_page].first_object_offset == 0);
next_page = first_page;
- remaining_bytes = nwords*4;
+ remaining_bytes = nwords*N_WORD_BYTES;
while (remaining_bytes > PAGE_BYTES) {
gc_assert(page_table[next_page].gen == from_space);
- gc_assert((page_table[next_page].allocated == BOXED_PAGE)
- || (page_table[next_page].allocated == UNBOXED_PAGE));
+ gc_assert((page_table[next_page].allocated == BOXED_PAGE_FLAG)
+ || (page_table[next_page].allocated == UNBOXED_PAGE_FLAG));
gc_assert(page_table[next_page].large_object);
gc_assert(page_table[next_page].first_object_offset ==
-PAGE_BYTES*(next_page-first_page));
next_page++;
while ((old_bytes_used == PAGE_BYTES) &&
(page_table[next_page].gen == from_space) &&
- ((page_table[next_page].allocated == UNBOXED_PAGE)
- || (page_table[next_page].allocated == BOXED_PAGE)) &&
+ ((page_table[next_page].allocated == UNBOXED_PAGE_FLAG)
+ || (page_table[next_page].allocated == BOXED_PAGE_FLAG)) &&
page_table[next_page].large_object &&
(page_table[next_page].first_object_offset ==
-(next_page - first_page)*PAGE_BYTES)) {
gc_assert(page_table[next_page].write_protected == 0);
old_bytes_used = page_table[next_page].bytes_used;
- page_table[next_page].allocated = FREE_PAGE;
+ page_table[next_page].allocated = FREE_PAGE_FLAG;
page_table[next_page].bytes_used = 0;
bytes_freed += old_bytes_used;
next_page++;
* page_table so that it will not be relocated during a GC.
*
* This involves locating the page it points to, then backing up to
- * the first page that has its first object start at offset 0, and
- * then marking all pages dont_move from the first until a page that
- * ends by being full, or having free gen.
- *
- * This ensures that objects spanning pages are not broken.
+ * the start of its region, then marking all pages dont_move from there
+ * up to the first page that's not full or has a different generation
*
* It is assumed that all the page static flags have been cleared at
* the start of a GC.
/* quick check 1: Address is quite likely to have been invalid. */
if ((addr_page_index == -1)
- || (page_table[addr_page_index].allocated == FREE_PAGE)
+ || (page_table[addr_page_index].allocated == FREE_PAGE_FLAG)
|| (page_table[addr_page_index].bytes_used == 0)
|| (page_table[addr_page_index].gen != from_space)
/* Skip if already marked dont_move. */
|| (page_table[addr_page_index].dont_move != 0))
return;
- gc_assert(!(page_table[addr_page_index].allocated & OPEN_REGION_PAGE));
+ gc_assert(!(page_table[addr_page_index].allocated&OPEN_REGION_PAGE_FLAG));
/* (Now that we know that addr_page_index is in range, it's
* safe to index into page_table[] with it.) */
region_allocation = page_table[addr_page_index].allocated;
* a pointer which prevents a page from moving. */
if (!(possibly_valid_dynamic_space_pointer(addr)))
return;
- first_page = addr_page_index;
- /* Work backwards to find a page with a first_object_offset of 0.
- * The pages should be contiguous with all bytes used in the same
- * gen. Assumes the first_object_offset is negative or zero. */
-
- /* this is probably needlessly conservative. The first object in
- * the page may not even be the one we were passed a pointer to:
- * if this is the case, we will write-protect all the previous
- * object's pages too.
- */
+ /* Find the beginning of the region. Note that there may be
+ * objects in the region preceding the one that we were passed a
+ * pointer to: if this is the case, we will write-protect all the
+ * previous objects' pages too. */
+#if 0
+ /* I think this'd work just as well, but without the assertions.
+ * -dan 2004.01.01 */
+ first_page=
+ find_page_index(page_address(addr_page_index)+
+ page_table[addr_page_index].first_object_offset);
+#else
+ first_page = addr_page_index;
while (page_table[first_page].first_object_offset != 0) {
--first_page;
/* Do some checks. */
gc_assert(page_table[first_page].gen == from_space);
gc_assert(page_table[first_page].allocated == region_allocation);
}
+#endif
/* Adjust any large objects before promotion as they won't be
* copied after promotion. */
* free area in which case it's ignored here. Note it gets
* through the valid pointer test above because the tail looks
* like conses. */
- if ((page_table[addr_page_index].allocated == FREE_PAGE)
+ if ((page_table[addr_page_index].allocated == FREE_PAGE_FLAG)
|| (page_table[addr_page_index].bytes_used == 0)
/* Check the offset within the page. */
|| (((unsigned)addr & (PAGE_BYTES - 1))
/* Check whether this is the last page in this contiguous block.. */
if ((page_table[i].bytes_used < PAGE_BYTES)
/* ..or it is PAGE_BYTES and is the last in the block */
- || (page_table[i+1].allocated == FREE_PAGE)
+ || (page_table[i+1].allocated == FREE_PAGE_FLAG)
|| (page_table[i+1].bytes_used == 0) /* next page free */
|| (page_table[i+1].gen != from_space) /* diff. gen */
|| (page_table[i+1].first_object_offset == 0))
int j;
int wp_it = 1;
void **page_addr = (void **)page_address(page);
- int num_words = page_table[page].bytes_used / 4;
+ int num_words = page_table[page].bytes_used / N_WORD_BYTES;
/* Shouldn't be a free page. */
- gc_assert(page_table[page].allocated != FREE_PAGE);
+ gc_assert(page_table[page].allocated != FREE_PAGE_FLAG);
gc_assert(page_table[page].bytes_used != 0);
/* Skip if it's already write-protected, pinned, or unboxed */
if (page_table[page].write_protected
|| page_table[page].dont_move
- || (page_table[page].allocated & UNBOXED_PAGE))
+ || (page_table[page].allocated & UNBOXED_PAGE_FLAG))
return (0);
/* Scan the page for pointers to younger generations or the
/* Check that it's in the dynamic space */
if (index != -1)
if (/* Does it point to a younger or the temp. generation? */
- ((page_table[index].allocated != FREE_PAGE)
+ ((page_table[index].allocated != FREE_PAGE_FLAG)
&& (page_table[index].bytes_used != 0)
&& ((page_table[index].gen < gen)
|| (page_table[index].gen == NUM_GENERATIONS)))
/* Scavenge a generation.
*
* This will not resolve all pointers when generation is the new
- * space, as new objects may be added which are not check here - use
+ * space, as new objects may be added which are not checked here - use
* scavenge_newspace generation.
*
* Write-protected pages should not have any pointers to the
#endif
for (i = 0; i < last_free_page; i++) {
- if ((page_table[i].allocated & BOXED_PAGE)
+ if ((page_table[i].allocated & BOXED_PAGE_FLAG)
&& (page_table[i].bytes_used != 0)
&& (page_table[i].gen == generation)) {
- int last_page;
+ int last_page,j;
+ int write_protected=1;
- /* This should be the start of a contiguous block. */
+ /* This should be the start of a region */
gc_assert(page_table[i].first_object_offset == 0);
- /* We need to find the full extent of this contiguous
- * block in case objects span pages. */
-
- /* Now work forward until the end of this contiguous area
- * is found. A small area is preferred as there is a
- * better chance of its pages being write-protected. */
- for (last_page = i; ; last_page++)
- /* Check whether this is the last page in this contiguous
- * block. */
+ /* Now work forward until the end of the region */
+ for (last_page = i; ; last_page++) {
+ write_protected =
+ write_protected && page_table[last_page].write_protected;
if ((page_table[last_page].bytes_used < PAGE_BYTES)
/* Or it is PAGE_BYTES and is the last in the block */
- || (!(page_table[last_page+1].allocated & BOXED_PAGE))
+ || (!(page_table[last_page+1].allocated & BOXED_PAGE_FLAG))
|| (page_table[last_page+1].bytes_used == 0)
|| (page_table[last_page+1].gen != generation)
|| (page_table[last_page+1].first_object_offset == 0))
break;
-
- /* Do a limited check for write_protected pages. If all pages
- * are write_protected then there is no need to scavenge. */
- {
- int j, all_wp = 1;
- for (j = i; j <= last_page; j++)
- if (page_table[j].write_protected == 0) {
- all_wp = 0;
- break;
- }
-#if !SC_GEN_CK
- if (all_wp == 0)
-#endif
- {
- scavenge(page_address(i), (page_table[last_page].bytes_used
- + (last_page-i)*PAGE_BYTES)/4);
-
- /* Now scan the pages and write protect those
- * that don't have pointers to younger
- * generations. */
- if (enable_page_protection) {
- for (j = i; j <= last_page; j++) {
- num_wp += update_page_write_prot(j);
- }
- }
+ }
+ if (!write_protected) {
+ scavenge(page_address(i), (page_table[last_page].bytes_used
+ + (last_page-i)*PAGE_BYTES)/4);
+
+ /* Now scan the pages and write protect those that
+ * don't have pointers to younger generations. */
+ if (enable_page_protection) {
+ for (j = i; j <= last_page; j++) {
+ num_wp += update_page_write_prot(j);
}
+ }
}
i = last_page;
}
}
-
if ((gencgc_verbose > 1) && (num_wp != 0)) {
FSHOW((stderr,
"/write protected %d pages within generation %d\n",
/* Check that none of the write_protected pages in this generation
* have been written to. */
for (i = 0; i < NUM_PAGES; i++) {
- if ((page_table[i].allocation ! =FREE_PAGE)
+ if ((page_table[i].allocation != FREE_PAGE_FLAG)
&& (page_table[i].bytes_used != 0)
&& (page_table[i].gen == generation)
&& (page_table[i].write_protected_cleared != 0)) {
"/starting one full scan of newspace generation %d\n",
generation));
for (i = 0; i < last_free_page; i++) {
- /* note that this skips over open regions when it encounters them */
- if ((page_table[i].allocated == BOXED_PAGE)
+ /* Note that this skips over open regions when it encounters them. */
+ if ((page_table[i].allocated & BOXED_PAGE_FLAG)
&& (page_table[i].bytes_used != 0)
&& (page_table[i].gen == generation)
&& ((page_table[i].write_protected == 0)
* cleared before promotion.) */
|| (page_table[i].dont_move == 1))) {
int last_page;
+ int all_wp=1;
/* The scavenge will start at the first_object_offset of page i.
*
* is found. A small area is preferred as there is a
* better chance of its pages being write-protected. */
for (last_page = i; ;last_page++) {
+ /* If all pages are write-protected and movable,
+ * then no need to scavenge */
+ all_wp=all_wp && page_table[last_page].write_protected &&
+ !page_table[last_page].dont_move;
+
/* Check whether this is the last page in this
* contiguous block */
if ((page_table[last_page].bytes_used < PAGE_BYTES)
/* Or it is PAGE_BYTES and is the last in the block */
- || (!(page_table[last_page+1].allocated & BOXED_PAGE))
+ || (!(page_table[last_page+1].allocated & BOXED_PAGE_FLAG))
|| (page_table[last_page+1].bytes_used == 0)
|| (page_table[last_page+1].gen != generation)
|| (page_table[last_page+1].first_object_offset == 0))
break;
}
- /* Do a limited check for write-protected pages. If all
- * pages are write-protected then no need to scavenge,
- * except if the pages are marked dont_move. */
- {
- int j, all_wp = 1;
- for (j = i; j <= last_page; j++)
- if ((page_table[j].write_protected == 0)
- || (page_table[j].dont_move != 0)) {
- all_wp = 0;
- break;
- }
-
- if (!all_wp) {
- int size;
-
- /* Calculate the size. */
- if (last_page == i)
- size = (page_table[last_page].bytes_used
- - page_table[i].first_object_offset)/4;
- else
- size = (page_table[last_page].bytes_used
- + (last_page-i)*PAGE_BYTES
- - page_table[i].first_object_offset)/4;
-
- {
- new_areas_ignore_page = last_page;
-
- scavenge(page_address(i) +
- page_table[i].first_object_offset,
- size);
-
- }
- }
+ /* Do a limited check for write-protected pages. */
+ if (!all_wp) {
+ int size;
+
+ size = (page_table[last_page].bytes_used
+ + (last_page-i)*PAGE_BYTES
+ - page_table[i].first_object_offset)/4;
+ new_areas_ignore_page = last_page;
+
+ scavenge(page_address(i) +
+ page_table[i].first_object_offset,
+ size);
+
}
-
i = last_page;
}
}
struct new_area (*current_new_areas)[] = &new_areas_1;
int current_new_areas_index;
- /* the new_areas created but the previous scavenge cycle */
+ /* the new_areas created by the previous scavenge cycle */
struct new_area (*previous_new_areas)[] = NULL;
int previous_new_areas_index;
/* Work through previous_new_areas. */
for (i = 0; i < previous_new_areas_index; i++) {
- /* FIXME: All these bare *4 and /4 should be something
- * like BYTES_PER_WORD or WBYTES. */
int page = (*previous_new_areas)[i].page;
int offset = (*previous_new_areas)[i].offset;
- int size = (*previous_new_areas)[i].size / 4;
- gc_assert((*previous_new_areas)[i].size % 4 == 0);
+ int size = (*previous_new_areas)[i].size / N_WORD_BYTES;
+ gc_assert((*previous_new_areas)[i].size % N_WORD_BYTES == 0);
scavenge(page_address(page)+offset, size);
}
/* Check that none of the write_protected pages in this generation
* have been written to. */
for (i = 0; i < NUM_PAGES; i++) {
- if ((page_table[i].allocation != FREE_PAGE)
+ if ((page_table[i].allocation != FREE_PAGE_FLAG)
&& (page_table[i].bytes_used != 0)
&& (page_table[i].gen == generation)
&& (page_table[i].write_protected_cleared != 0)
int i;
for (i = 0; i < last_free_page; i++) {
- if ((page_table[i].allocated != FREE_PAGE)
+ if ((page_table[i].allocated != FREE_PAGE_FLAG)
&& (page_table[i].bytes_used != 0)
&& (page_table[i].gen == from_space)) {
void *page_start;
* assumes that all objects have been copied or promoted to an older
* generation. Bytes_allocated and the generation bytes_allocated
* counter are updated. The number of bytes freed is returned. */
-extern void i586_bzero(void *addr, int nbytes);
static int
free_oldspace(void)
{
do {
/* Find a first page for the next region of pages. */
while ((first_page < last_free_page)
- && ((page_table[first_page].allocated == FREE_PAGE)
+ && ((page_table[first_page].allocated == FREE_PAGE_FLAG)
|| (page_table[first_page].bytes_used == 0)
|| (page_table[first_page].gen != from_space)))
first_page++;
bytes_freed += page_table[last_page].bytes_used;
generations[page_table[last_page].gen].bytes_allocated -=
page_table[last_page].bytes_used;
- page_table[last_page].allocated = FREE_PAGE;
+ page_table[last_page].allocated = FREE_PAGE_FLAG;
page_table[last_page].bytes_used = 0;
/* Remove any write-protection. We should be able to rely
last_page++;
}
while ((last_page < last_free_page)
- && (page_table[last_page].allocated != FREE_PAGE)
+ && (page_table[last_page].allocated != FREE_PAGE_FLAG)
&& (page_table[last_page].bytes_used != 0)
&& (page_table[last_page].gen == from_space));
os_invalidate(page_start, PAGE_BYTES*(last_page-first_page));
addr = os_validate(page_start, PAGE_BYTES*(last_page-first_page));
if (addr == NULL || addr != page_start) {
- /* Is this an error condition? I couldn't really tell from
- * the old CMU CL code, which fprintf'ed a message with
- * an exclamation point at the end. But I've never seen the
- * message, so it must at least be unusual..
- *
- * (The same condition is also tested for in gc_free_heap.)
- *
- * -- WHN 19991129 */
- lose("i586_bzero: page moved, 0x%08x ==> 0x%08x",
- page_start,
+ lose("free_oldspace: page moved, 0x%08x ==> 0x%08x",page_start,
addr);
}
} else {
int *page_start;
page_start = (int *)page_address(first_page);
- i586_bzero(page_start, PAGE_BYTES*(last_page-first_page));
+ memset(page_start, 0,PAGE_BYTES*(last_page-first_page));
}
first_page = last_page;
if (page_index != -1) {
/* If it's within the dynamic space it should point to a used
* page. XX Could check the offset too. */
- if ((page_table[page_index].allocated != FREE_PAGE)
+ if ((page_table[page_index].allocated != FREE_PAGE_FLAG)
&& (page_table[page_index].bytes_used == 0))
lose ("Ptr %x @ %x sees free page.", thing, start);
/* Check that it doesn't point to a forwarding pointer! */
}
}
} else {
- if (thing & 0x3) { /* Skip fixnums. FIXME: There should be an
- * is_fixnum for this. */
-
+ if (!(fixnump(thing))) {
+ /* skip fixnums */
switch(widetag_of(*start)) {
/* boxed objects */
case COMPLEX_WIDETAG:
case SIMPLE_ARRAY_WIDETAG:
case COMPLEX_BASE_STRING_WIDETAG:
+#ifdef COMPLEX_CHARACTER_STRING_WIDETAG
+ case COMPLEX_CHARACTER_STRING_WIDETAG:
+#endif
case COMPLEX_VECTOR_NIL_WIDETAG:
case COMPLEX_BIT_VECTOR_WIDETAG:
case COMPLEX_VECTOR_WIDETAG:
case FUNCALLABLE_INSTANCE_HEADER_WIDETAG:
case VALUE_CELL_HEADER_WIDETAG:
case SYMBOL_HEADER_WIDETAG:
- case BASE_CHAR_WIDETAG:
+ case CHARACTER_WIDETAG:
case UNBOUND_MARKER_WIDETAG:
case INSTANCE_HEADER_WIDETAG:
case FDEFN_WIDETAG:
* there's no byte compiler, but I've got
* too much to worry about right now to try
* to make sure. -- WHN 2001-10-06 */
- && !(code->trace_table_offset & 0x3)
+ && fixnump(code->trace_table_offset)
/* Only when enabled */
&& verify_dynamic_code_check) {
FSHOW((stderr,
case COMPLEX_LONG_FLOAT_WIDETAG:
#endif
case SIMPLE_BASE_STRING_WIDETAG:
+#ifdef SIMPLE_CHARACTER_STRING_WIDETAG
+ case SIMPLE_CHARACTER_STRING_WIDETAG:
+#endif
case SIMPLE_BIT_VECTOR_WIDETAG:
case SIMPLE_ARRAY_NIL_WIDETAG:
case SIMPLE_ARRAY_UNSIGNED_BYTE_2_WIDETAG:
int i;
for (i = 0; i < last_free_page; i++) {
- if ((page_table[i].allocated != FREE_PAGE)
+ if ((page_table[i].allocated != FREE_PAGE_FLAG)
&& (page_table[i].bytes_used != 0)
&& (page_table[i].gen == generation)) {
int last_page;
int page;
for (page = 0; page < last_free_page; page++) {
- if (page_table[page].allocated == FREE_PAGE) {
+ if (page_table[page].allocated == FREE_PAGE_FLAG) {
/* The whole page should be zero filled. */
int *start_addr = (int *)page_address(page);
int size = 1024;
if (free_bytes > 0) {
int *start_addr = (int *)((unsigned)page_address(page)
+ page_table[page].bytes_used);
- int size = free_bytes / 4;
+ int size = free_bytes / N_WORD_BYTES;
int i;
for (i = 0; i < size; i++) {
if (start_addr[i] != 0) {
gc_assert(generation < NUM_GENERATIONS);
for (i = 0; i < last_free_page; i++)
- if ((page_table[i].allocated == BOXED_PAGE)
+ if ((page_table[i].allocated == BOXED_PAGE_FLAG)
&& (page_table[i].bytes_used != 0)
&& !page_table[i].dont_move
&& (page_table[i].gen == generation)) {
for_each_thread(th) {
void **ptr;
void **esp=(void **)-1;
- int i,free;
#ifdef LISP_FEATURE_SB_THREAD
+ int i,free;
if(th==arch_os_get_current_thread()) {
esp = (void **) &raise;
} else {
}
}
-#if QSHOW
+#ifdef QSHOW
if (gencgc_verbose > 1) {
int num_dont_move_pages = count_dont_move_pages();
fprintf(stderr,
int i;
for (i = 0; i < NUM_PAGES; i++)
- if ((page_table[i].allocated != FREE_PAGE)
+ if ((page_table[i].allocated != FREE_PAGE_FLAG)
&& (page_table[i].bytes_used != 0))
last_page = i;
for (page = 0; page < NUM_PAGES; page++) {
/* Skip free pages which should already be zero filled. */
- if (page_table[page].allocated != FREE_PAGE) {
+ if (page_table[page].allocated != FREE_PAGE_FLAG) {
void *page_start, *addr;
/* Mark the page free. The other slots are assumed invalid
- * when it is a FREE_PAGE and bytes_used is 0 and it
+ * when it is a FREE_PAGE_FLAG and bytes_used is 0 and it
* should not be write-protected -- except that the
* generation is used for the current region but it sets
* that up. */
- page_table[page].allocated = FREE_PAGE;
+ page_table[page].allocated = FREE_PAGE_FLAG;
page_table[page].bytes_used = 0;
/* Zero the page. */
} else if (gencgc_zero_check_during_free_heap) {
/* Double-check that the page is zero filled. */
int *page_start, i;
- gc_assert(page_table[page].allocated == FREE_PAGE);
+ gc_assert(page_table[page].allocated == FREE_PAGE_FLAG);
gc_assert(page_table[page].bytes_used == 0);
page_start = (int *)page_address(page);
for (i=0; i<1024; i++) {
/* Initialize each page structure. */
for (i = 0; i < NUM_PAGES; i++) {
/* Initialize all pages as free. */
- page_table[i].allocated = FREE_PAGE;
+ page_table[i].allocated = FREE_PAGE_FLAG;
page_table[i].bytes_used = 0;
/* Pages are not write-protected at startup. */
/* Pick up the dynamic space from after a core load.
*
* The ALLOCATION_POINTER points to the end of the dynamic space.
- *
- * XX A scan is needed to identify the closest first objects for pages. */
+ */
+
static void
gencgc_pickup_dynamic(void)
{
int page = 0;
- int addr = DYNAMIC_SPACE_START;
int alloc_ptr = SymbolValue(ALLOCATION_POINTER,0);
+ lispobj *prev=(lispobj *)page_address(page);
- /* Initialize the first region. */
do {
- page_table[page].allocated = BOXED_PAGE;
+ lispobj *first,*ptr= (lispobj *)page_address(page);
+ page_table[page].allocated = BOXED_PAGE_FLAG;
page_table[page].gen = 0;
page_table[page].bytes_used = PAGE_BYTES;
page_table[page].large_object = 0;
+
+ first=search_space(prev,(ptr+2)-prev,ptr);
+ if(ptr == first) prev=ptr;
page_table[page].first_object_offset =
- (void *)DYNAMIC_SPACE_START - page_address(page);
- addr += PAGE_BYTES;
+ (void *)prev - page_address(page);
page++;
- } while (addr < alloc_ptr);
+ } while (page_address(page) < alloc_ptr);
generations[0].bytes_allocated = PAGE_BYTES*page;
bytes_allocated = PAGE_BYTES*page;
}
+
void
gc_initialize_pointers(void)
{
alloc(int nbytes)
{
struct thread *th=arch_os_get_current_thread();
- struct alloc_region *region=
+ struct alloc_region *region=
+#ifdef LISP_FEATURE_SB_THREAD
th ? &(th->alloc_region) : &boxed_region;
+#else
+ &boxed_region;
+#endif
void *new_obj;
void *new_free_pointer;
fprintf(stderr, "fatal error in thread 0x%x, pid=%d\n",
th,getpid());
__asm__("movl %fs,%0" : "=r" (fs) : );
- fprintf(stderr, "fs is %x, th->tls_cookie=%x (should be identical)\n",
+ fprintf(stderr, "fs is %x, th->tls_cookie=%x \n",
debug_get_fs(),th->tls_cookie);
- lose("If you see this message before 2003.12.01, mail details to sbcl-devel\n");
+ lose("If you see this message before 2004.01.31, mail details to sbcl-devel\n");
}
#else
gc_assert(SymbolValue(PSEUDO_ATOMIC_ATOMIC,th));
new_obj = gc_alloc_with_region(nbytes,0,region,0);
return (new_obj);
}
-
-\f
-/* Find the code object for the given pc, or return NULL on failure.
- *
- * FIXME: PC shouldn't be lispobj*, should it? Maybe void*? */
-lispobj *
-component_ptr_from_pc(lispobj *pc)
-{
- lispobj *object = NULL;
-
- if ( (object = search_read_only_space(pc)) )
- ;
- else if ( (object = search_static_space(pc)) )
- ;
- else
- object = search_dynamic_space(pc);
-
- if (object) /* if we found something */
- if (widetag_of(*object) == CODE_HEADER_WIDETAG) /* if it's a code object */
- return(object);
-
- return (NULL);
-}
\f
/*
* shared support for the OS-dependent signal handlers which
{
int page_index = find_page_index(fault_addr);
-#if defined QSHOW_SIGNALS
+#ifdef QSHOW_SIGNALS
FSHOW((stderr, "heap WP violation? fault_addr=%x, page_index=%d\n",
fault_addr, page_index));
#endif
projects / sbcl.git / blobdiff