[cmucl-commit] CMUCL commit: src/lisp (Config.x86_darwin Darwin-os.h gencgc.c gencgc.h)

Raymond Toy rtoy at common-lisp.net
Sun Jan 9 01:12:36 CET 2011


    Date: Saturday, January 8, 2011 @ 19:12:36
  Author: rtoy
    Path: /project/cmucl/cvsroot/src/lisp

Modified: Config.x86_darwin Darwin-os.h gencgc.c gencgc.h

Changes to support building on Mac OS X 10.6.  When compiled on 10.6,
the resulting binary still works on 10.5.

lisp/Config.x86_darwin:
o Add -m32 flag to build and link a 32-bit binary.

lisp/Darwin-os.h:
o Include <sys/ucontext.h> instead of <ucontext.h> to get rid of the
  error about deprecated functions in ucontext.h.

lisp/gencgc.h:
o Mac OS X defines PAGE_SIZE in a header and that conflicts with our
  name.  Rename our PAGE_SIZE to GC_PAGE_SIZE.

lisp/gencgc.c:
o Rename PAGE_SIZE to GC_PAGE_SIZE.


-------------------+
 Config.x86_darwin |    4 -
 Darwin-os.h       |    4 -
 gencgc.c          |  162 ++++++++++++++++++++++++++--------------------------
 gencgc.h          |   14 ++--
 4 files changed, 92 insertions(+), 92 deletions(-)


Index: src/lisp/Config.x86_darwin
diff -u src/lisp/Config.x86_darwin:1.9 src/lisp/Config.x86_darwin:1.10
--- src/lisp/Config.x86_darwin:1.9	Fri Jul 30 18:51:58 2010
+++ src/lisp/Config.x86_darwin	Sat Jan  8 19:12:36 2011
@@ -5,7 +5,7 @@
 # Compile code that will run on OSX 10.4 (Tiger)
 MIN_VER = -mmacosx-version-min=10.4
 
-CPPFLAGS += -DDARWIN $(MIN_VER)
+CPPFLAGS += -DDARWIN $(MIN_VER) -m32
 CFLAGS += -g3
 ASFLAGS += -g3 $(MIN_VER)
 
@@ -13,7 +13,7 @@
 UNDEFSYMPATTERN = -Xlinker -u -Xlinker &
 
 OS_SRC += Darwin-os.c mach-o.c
-OS_LINK_FLAGS = $(MIN_VER)
+OS_LINK_FLAGS = -m32 $(MIN_VER)
 OS_LIBS =
 
 EXEC_FINAL_OBJ = exec-final.o
Index: src/lisp/Darwin-os.h
diff -u src/lisp/Darwin-os.h:1.7 src/lisp/Darwin-os.h:1.8
--- src/lisp/Darwin-os.h:1.7	Thu Jan  3 06:41:54 2008
+++ src/lisp/Darwin-os.h	Sat Jan  8 19:12:36 2011
@@ -1,6 +1,6 @@
 /*
 
- $Header: /project/cmucl/cvsroot/src/lisp/Darwin-os.h,v 1.7 2008-01-03 11:41:54 cshapiro Rel $
+ $Header: /project/cmucl/cvsroot/src/lisp/Darwin-os.h,v 1.8 2011-01-09 00:12:36 rtoy Exp $
 
  This code was written as part of the CMU Common Lisp project at
  Carnegie Mellon University, and has been placed in the public domain.
@@ -14,7 +14,7 @@
 #include <sys/mman.h>
 #include <sys/signal.h>
 #include <signal.h>
-#include <ucontext.h>
+#include <sys/ucontext.h>
 #include <mach/vm_types.h>
 
 typedef caddr_t os_vm_address_t;
Index: src/lisp/gencgc.c
diff -u src/lisp/gencgc.c:1.111 src/lisp/gencgc.c:1.112
--- src/lisp/gencgc.c:1.111	Tue Dec 21 21:12:52 2010
+++ src/lisp/gencgc.c	Sat Jan  8 19:12:36 2011
@@ -7,7 +7,7 @@
  *
  * Douglas Crosher, 1996, 1997, 1998, 1999.
  *
- * $Header: /project/cmucl/cvsroot/src/lisp/gencgc.c,v 1.111 2010-12-22 02:12:52 rtoy Exp $
+ * $Header: /project/cmucl/cvsroot/src/lisp/gencgc.c,v 1.112 2011-01-09 00:12:36 rtoy Exp $
  *
  */
 
@@ -324,7 +324,7 @@
 /*
  * The minimum size for a large object.
  */
-unsigned large_object_size = 4 * PAGE_SIZE;
+unsigned large_object_size = 4 * GC_PAGE_SIZE;
 
 /*
  * Enable the filtering of stack/register pointers. This could reduce
@@ -394,7 +394,7 @@
 static char *
 page_address(int page_num)
 {
-    return heap_base + PAGE_SIZE * page_num;
+    return heap_base + GC_PAGE_SIZE * page_num;
 }
 
 /*
@@ -407,7 +407,7 @@
     int index = (char *) addr - heap_base;
 
     if (index >= 0) {
-	index = (unsigned int) index / PAGE_SIZE;
+	index = (unsigned int) index / GC_PAGE_SIZE;
 	if (index < dynamic_space_pages)
 	    return index;
     }
@@ -441,7 +441,7 @@
 		 "*** Page fault in page not marked as write protected\n");
 
     /* Un-protect the page */
-    os_protect((os_vm_address_t) page_address(page_index), PAGE_SIZE, OS_VM_PROT_ALL);
+    os_protect((os_vm_address_t) page_address(page_index), GC_PAGE_SIZE, OS_VM_PROT_ALL);
     page_table[page_index].flags &= ~PAGE_WRITE_PROTECTED_MASK;
     page_table[page_index].flags |= PAGE_WRITE_PROTECT_CLEARED_MASK;
 
@@ -712,7 +712,7 @@
 	gens = NUM_GENERATIONS;
 
     /* Print the heap stats */
-    fprintf(stderr, "          Page count (%d KB)\n", PAGE_SIZE / 1024);
+    fprintf(stderr, "          Page count (%d KB)\n", GC_PAGE_SIZE / 1024);
     fprintf(stderr,
 	    "   Gen  Boxed Unboxed  LB   LUB    Alloc    Waste    Trigger   WP  GCs Mem-age\n");
 
@@ -750,7 +750,7 @@
 	fprintf(stderr, " %5d: %5d %5d %5d %5d %10d %6d %10d %4d %3d %7.4f\n",
 		i, boxed_cnt, unboxed_cnt, large_boxed_cnt, large_unboxed_cnt,
 		generations[i].bytes_allocated,
-		PAGE_SIZE * count_generation_pages(i) -
+		GC_PAGE_SIZE * count_generation_pages(i) -
 		generations[i].bytes_allocated, generations[i].gc_trigger,
 		count_write_protect_generation_pages(i), generations[i].num_gc,
 		gen_av_mem_age(i));
@@ -993,7 +993,7 @@
 
 	    if (!(flags & PAGE_ALLOCATED_MASK)
 		|| ((flags & mmask) == mflags &&
-		    page_table[first_page].bytes_used < PAGE_SIZE - 32))
+		    page_table[first_page].bytes_used < GC_PAGE_SIZE - 32))
 		break;
 	    first_page++;
 	}
@@ -1022,19 +1022,19 @@
 	 * number of pages in a region.
 	 */
 	last_page = first_page;
-	bytes_found = PAGE_SIZE - page_table[first_page].bytes_used;
+	bytes_found = GC_PAGE_SIZE - page_table[first_page].bytes_used;
 	num_pages = 1;
 	while ((bytes_found < nbytes || num_pages < 2)
 	       && last_page < dynamic_space_pages - 1
 	       && !PAGE_ALLOCATED(last_page + 1)) {
 	    last_page++;
 	    num_pages++;
-	    bytes_found += PAGE_SIZE;
+	    bytes_found += GC_PAGE_SIZE;
 	    gc_assert(!PAGE_WRITE_PROTECTED(last_page));
 	}
 
-	region_size = (PAGE_SIZE - page_table[first_page].bytes_used)
-	    + PAGE_SIZE * (last_page - first_page);
+	region_size = (GC_PAGE_SIZE - page_table[first_page].bytes_used)
+	    + GC_PAGE_SIZE * (last_page - first_page);
 
 	gc_assert(bytes_found == region_size);
 
@@ -1113,7 +1113,7 @@
     if (last_page + 1 > last_free_page) {
 	last_free_page = last_page + 1;
 	set_alloc_pointer((lispobj) ((char *) heap_base +
-				     PAGE_SIZE * last_free_page));
+				     GC_PAGE_SIZE * last_free_page));
 
     }
 }
@@ -1174,14 +1174,14 @@
 	  gc_abort();
     }
 
-    new_area_start = PAGE_SIZE * first_page + offset;
+    new_area_start = GC_PAGE_SIZE * first_page + offset;
 
     /*
      * Search backwards for a prior area that this follows from.  If
      * found this will save adding a new area.
      */
     for (i = new_areas_index - 1, c = 0; i >= 0 && c < 8; i--, c++) {
-	unsigned area_end = PAGE_SIZE * (*new_areas)[i].page
+	unsigned area_end = GC_PAGE_SIZE * (*new_areas)[i].page
 	    + (*new_areas)[i].offset + (*new_areas)[i].size;
 
 #if 0
@@ -1281,8 +1281,8 @@
 	 */
 	more = 0;
 	bytes_used = alloc_region->free_pointer - page_address(first_page);
-	if (bytes_used > PAGE_SIZE) {
-	    bytes_used = PAGE_SIZE;
+	if (bytes_used > GC_PAGE_SIZE) {
+	    bytes_used = GC_PAGE_SIZE;
 	    more = 1;
 	}
 	page_table[first_page].bytes_used = bytes_used;
@@ -1309,8 +1309,8 @@
 	    /* Calc. the number of bytes used in this page. */
 	    more = 0;
 	    bytes_used = alloc_region->free_pointer - page_address(next_page);
-	    if (bytes_used > PAGE_SIZE) {
-		bytes_used = PAGE_SIZE;
+	    if (bytes_used > GC_PAGE_SIZE) {
+		bytes_used = GC_PAGE_SIZE;
 		more = 1;
 	    }
 	    page_table[next_page].bytes_used = bytes_used;
@@ -1456,7 +1456,7 @@
 
 		if (!(flags & PAGE_ALLOCATED_MASK)
 		    || ((flags & mmask) == mflags &&
-			page_table[first_page].bytes_used < PAGE_SIZE - 32))
+			page_table[first_page].bytes_used < GC_PAGE_SIZE - 32))
 		    break;
 		first_page++;
 	    }
@@ -1478,19 +1478,19 @@
 #endif
 
 	last_page = first_page;
-	bytes_found = PAGE_SIZE - page_table[first_page].bytes_used;
+	bytes_found = GC_PAGE_SIZE - page_table[first_page].bytes_used;
 	num_pages = 1;
 	while (bytes_found < nbytes
 	       && last_page < dynamic_space_pages - 1
 	       && !PAGE_ALLOCATED(last_page + 1)) {
 	    last_page++;
 	    num_pages++;
-	    bytes_found += PAGE_SIZE;
+	    bytes_found += GC_PAGE_SIZE;
 	    gc_assert(!PAGE_WRITE_PROTECTED(last_page));
 	}
 
-	region_size = (PAGE_SIZE - page_table[first_page].bytes_used)
-	    + PAGE_SIZE * (last_page - first_page);
+	region_size = (GC_PAGE_SIZE - page_table[first_page].bytes_used)
+	    + GC_PAGE_SIZE * (last_page - first_page);
 
 	gc_assert(bytes_found == region_size);
 
@@ -1555,8 +1555,8 @@
      */
     more = 0;
     bytes_used = nbytes + orig_first_page_bytes_used;
-    if (bytes_used > PAGE_SIZE) {
-	bytes_used = PAGE_SIZE;
+    if (bytes_used > GC_PAGE_SIZE) {
+	bytes_used = GC_PAGE_SIZE;
 	more = 1;
     }
     page_table[first_page].bytes_used = bytes_used;
@@ -1579,13 +1579,13 @@
 	PAGE_FLAGS_UPDATE(next_page, mmask, mflags);
 
 	page_table[next_page].first_object_offset =
-	    orig_first_page_bytes_used - PAGE_SIZE * (next_page - first_page);
+	    orig_first_page_bytes_used - GC_PAGE_SIZE * (next_page - first_page);
 
 	/* Calc. the number of bytes used in this page. */
 	more = 0;
 	bytes_used = nbytes + orig_first_page_bytes_used - byte_cnt;
-	if (bytes_used > PAGE_SIZE) {
-	    bytes_used = PAGE_SIZE;
+	if (bytes_used > GC_PAGE_SIZE) {
+	    bytes_used = GC_PAGE_SIZE;
 	    more = 1;
 	}
 	page_table[next_page].bytes_used = bytes_used;
@@ -1607,7 +1607,7 @@
     if (last_page + 1 > last_free_page) {
 	last_free_page = last_page + 1;
 	set_alloc_pointer((lispobj) ((char *) heap_base +
-				     PAGE_SIZE * last_free_page));
+				     GC_PAGE_SIZE * last_free_page));
     }
 
     return (void *) (page_address(first_page) + orig_first_page_bytes_used);
@@ -1961,7 +1961,7 @@
 
     return page_index >= 0
 	&& (page_index =
-	    (unsigned int) page_index / PAGE_SIZE) < dynamic_space_pages
+	    (unsigned int) page_index / GC_PAGE_SIZE) < dynamic_space_pages
 	&& PAGE_GENERATION(page_index) == from_space;
 }
 
@@ -1972,7 +1972,7 @@
 
     return page_index >= 0
 	&& (page_index =
-	    (unsigned int) page_index / PAGE_SIZE) < dynamic_space_pages
+	    (unsigned int) page_index / GC_PAGE_SIZE) < dynamic_space_pages
 	&& PAGE_GENERATION(page_index) == new_space;
 }
 
@@ -2170,14 +2170,14 @@
 
 	next_page = first_page;
 	remaining_bytes = nwords * sizeof(lispobj);
-	while (remaining_bytes > PAGE_SIZE) {
+	while (remaining_bytes > GC_PAGE_SIZE) {
 	    gc_assert(PAGE_GENERATION(next_page) == from_space);
 	    gc_assert(PAGE_ALLOCATED(next_page));
 	    gc_assert(!PAGE_UNBOXED(next_page));
 	    gc_assert(PAGE_LARGE_OBJECT(next_page));
 	    gc_assert(page_table[next_page].first_object_offset ==
-		      PAGE_SIZE * (first_page - next_page));
-	    gc_assert(page_table[next_page].bytes_used == PAGE_SIZE);
+		      GC_PAGE_SIZE * (first_page - next_page));
+	    gc_assert(page_table[next_page].bytes_used == GC_PAGE_SIZE);
 
 	    PAGE_FLAGS_UPDATE(next_page, PAGE_GENERATION_MASK, new_space);
 
@@ -2186,11 +2186,11 @@
 	     * WP flag to avoid redundant calls.
 	     */
 	    if (PAGE_WRITE_PROTECTED(next_page)) {
-		os_protect((os_vm_address_t) page_address(next_page), PAGE_SIZE,
+		os_protect((os_vm_address_t) page_address(next_page), GC_PAGE_SIZE,
 			   OS_VM_PROT_ALL);
 		page_table[next_page].flags &= ~PAGE_WRITE_PROTECTED_MASK;
 	    }
-	    remaining_bytes -= PAGE_SIZE;
+	    remaining_bytes -= GC_PAGE_SIZE;
 	    next_page++;
 	}
 
@@ -2218,10 +2218,10 @@
 
 	/* Free any remaining pages; needs care. */
 	next_page++;
-	while (old_bytes_used == PAGE_SIZE &&
+	while (old_bytes_used == GC_PAGE_SIZE &&
 	       PAGE_FLAGS(next_page, mmask) == mflags &&
 	       page_table[next_page].first_object_offset ==
-	       PAGE_SIZE * (first_page - next_page)) {
+	       GC_PAGE_SIZE * (first_page - next_page)) {
 	    /*
 	     * Checks out OK, free the page. Don't need to both zeroing
 	     * pages as this should have been done before shrinking the
@@ -2352,18 +2352,18 @@
 
 	next_page = first_page;
 	remaining_bytes = nwords * sizeof(lispobj);
-	while (remaining_bytes > PAGE_SIZE) {
+	while (remaining_bytes > GC_PAGE_SIZE) {
 	    gc_assert(PAGE_GENERATION(next_page) == from_space);
 	    gc_assert(PAGE_ALLOCATED(next_page));
 	    gc_assert(PAGE_LARGE_OBJECT(next_page));
 	    gc_assert(page_table[next_page].first_object_offset ==
-		      PAGE_SIZE * (first_page - next_page));
-	    gc_assert(page_table[next_page].bytes_used == PAGE_SIZE);
+		      GC_PAGE_SIZE * (first_page - next_page));
+	    gc_assert(page_table[next_page].bytes_used == GC_PAGE_SIZE);
 
 	    PAGE_FLAGS_UPDATE(next_page,
 			      PAGE_UNBOXED_MASK | PAGE_GENERATION_MASK,
 			      PAGE_UNBOXED_MASK | new_space);
-	    remaining_bytes -= PAGE_SIZE;
+	    remaining_bytes -= GC_PAGE_SIZE;
 	    next_page++;
 	}
 
@@ -2391,10 +2391,10 @@
 
 	/* Free any remaining pages; needs care. */
 	next_page++;
-	while (old_bytes_used == PAGE_SIZE &&
+	while (old_bytes_used == GC_PAGE_SIZE &&
 	       PAGE_FLAGS(next_page, mmask) == mflags &&
 	       page_table[next_page].first_object_offset ==
-	       PAGE_SIZE * (first_page - next_page)) {
+	       GC_PAGE_SIZE * (first_page - next_page)) {
 	    /*
 	     * Checks out OK, free the page. Don't need to both zeroing
 	     * pages as this should have been done before shrinking the
@@ -5880,13 +5880,13 @@
 
     next_page = first_page;
     remaining_bytes = nwords * sizeof(lispobj);
-    while (remaining_bytes > PAGE_SIZE) {
+    while (remaining_bytes > GC_PAGE_SIZE) {
 	gc_assert(PAGE_GENERATION(next_page) == from_space);
 	gc_assert(PAGE_ALLOCATED(next_page));
 	gc_assert(PAGE_LARGE_OBJECT(next_page));
 	gc_assert(page_table[next_page].first_object_offset ==
-		  PAGE_SIZE * (first_page - next_page));
-	gc_assert(page_table[next_page].bytes_used == PAGE_SIZE);
+		  GC_PAGE_SIZE * (first_page - next_page));
+	gc_assert(page_table[next_page].bytes_used == GC_PAGE_SIZE);
 
 	PAGE_FLAGS_UPDATE(next_page, PAGE_UNBOXED_MASK,
 			  unboxed << PAGE_UNBOXED_SHIFT);
@@ -5896,7 +5896,7 @@
 	 * pages aren't.
 	 */
 	gc_assert(!PAGE_WRITE_PROTECTED(next_page));
-	remaining_bytes -= PAGE_SIZE;
+	remaining_bytes -= GC_PAGE_SIZE;
 	next_page++;
     }
 
@@ -5924,9 +5924,9 @@
 
     /* Free any remaining pages; needs care. */
     next_page++;
-    while (old_bytes_used == PAGE_SIZE &&
+    while (old_bytes_used == GC_PAGE_SIZE &&
 	   PAGE_FLAGS(next_page, mmask) == mflags &&
-	   page_table[next_page].first_object_offset == PAGE_SIZE * (first_page
+	   page_table[next_page].first_object_offset == GC_PAGE_SIZE * (first_page
 								     -
 								     next_page))
     {
@@ -6010,7 +6010,7 @@
     while (page_table[first_page].first_object_offset != 0) {
 	first_page--;
 	/* Do some checks */
-	gc_assert(page_table[first_page].bytes_used == PAGE_SIZE);
+	gc_assert(page_table[first_page].bytes_used == GC_PAGE_SIZE);
 	gc_assert(PAGE_GENERATION(first_page) == from_space);
 	gc_assert(PAGE_ALLOCATED(first_page));
 	gc_assert(PAGE_UNBOXED(first_page) == region_unboxed);
@@ -6072,8 +6072,8 @@
 	gc_assert(!PAGE_WRITE_PROTECTED(i));
 
 	/* Check if this is the last page in this contiguous block */
-	if (page_table[i].bytes_used < PAGE_SIZE
-	    /* Or it is PAGE_SIZE and is the last in the block */
+	if (page_table[i].bytes_used < GC_PAGE_SIZE
+	    /* Or it is GC_PAGE_SIZE and is the last in the block */
 	    || !PAGE_ALLOCATED(i + 1)
 	    || page_table[i + 1].bytes_used == 0	/* Next page free */
 	    || PAGE_GENERATION(i + 1) != from_space	/* Diff. gen */
@@ -6214,7 +6214,7 @@
 	fprintf(stderr, "* WP page %d of gen %d\n", page, gen);
 #endif
 
-	os_protect((os_vm_address_t) page_addr, PAGE_SIZE,
+	os_protect((os_vm_address_t) page_addr, GC_PAGE_SIZE,
 		   OS_VM_PROT_READ | OS_VM_PROT_EXECUTE);
 
 	/* Note the page as protected in the page tables */
@@ -6292,8 +6292,8 @@
 	     */
 	    for (last_page = i;; last_page++)
 		/* Check if this is the last page in this contiguous block */
-		if (page_table[last_page].bytes_used < PAGE_SIZE
-		    /* Or it is PAGE_SIZE and is the last in the block */
+		if (page_table[last_page].bytes_used < GC_PAGE_SIZE
+		    /* Or it is GC_PAGE_SIZE and is the last in the block */
 		    || !PAGE_ALLOCATED(last_page + 1)
 		    || PAGE_UNBOXED(last_page + 1)
 		    || page_table[last_page + 1].bytes_used == 0
@@ -6318,7 +6318,7 @@
 #endif
 		{
 		    scavenge(page_address(i), (page_table[last_page].bytes_used
-					       + PAGE_SIZE * (last_page -
+					       + GC_PAGE_SIZE * (last_page -
 							      i)) /
 			     sizeof(lispobj));
 
@@ -6425,8 +6425,8 @@
 	     */
 	    for (last_page = i;; last_page++)
 		/* Check if this is the last page in this contiguous block */
-		if (page_table[last_page].bytes_used < PAGE_SIZE
-		    /* Or it is PAGE_SIZE and is the last in the block */
+		if (page_table[last_page].bytes_used < GC_PAGE_SIZE
+		    /* Or it is GC_PAGE_SIZE and is the last in the block */
 		    || !PAGE_ALLOCATED(last_page + 1)
 		    || PAGE_UNBOXED(last_page + 1)
 		    || page_table[last_page + 1].bytes_used == 0
@@ -6462,7 +6462,7 @@
 		    else
 			size =
 			    (page_table[last_page].bytes_used +
-			     PAGE_SIZE * (last_page - i) -
+			     GC_PAGE_SIZE * (last_page - i) -
 			     page_table[i].first_object_offset) /
 			    sizeof(lispobj);
 
@@ -6750,7 +6750,7 @@
 	     * WP flag to avoid redundant calls.
 	     */
 	    if (PAGE_WRITE_PROTECTED(i)) {
-		os_protect((os_vm_address_t) page_start, PAGE_SIZE,
+		os_protect((os_vm_address_t) page_start, GC_PAGE_SIZE,
 			   OS_VM_PROT_ALL);
 		page_table[i].flags &= ~PAGE_WRITE_PROTECTED_MASK;
 	    }
@@ -6802,7 +6802,7 @@
 		void *page_start = (void *) page_address(last_page);
 
 		if (PAGE_WRITE_PROTECTED(last_page)) {
-		    os_protect((os_vm_address_t) page_start, PAGE_SIZE,
+		    os_protect((os_vm_address_t) page_start, GC_PAGE_SIZE,
 			       OS_VM_PROT_ALL);
 		    page_table[last_page].flags &= ~PAGE_WRITE_PROTECTED_MASK;
 		}
@@ -6820,10 +6820,10 @@
 	    page_start = page_address(first_page);
 
 	    os_invalidate((os_vm_address_t) page_start,
-			  PAGE_SIZE * (last_page - first_page));
+			  GC_PAGE_SIZE * (last_page - first_page));
 	    addr =
 		(char *) os_validate((os_vm_address_t) page_start,
-				     PAGE_SIZE * (last_page - first_page));
+				     GC_PAGE_SIZE * (last_page - first_page));
 	    if (addr == NULL || addr != page_start)
 		fprintf(stderr, "gc_zero: page moved, 0x%08lx ==> 0x%08lx!\n",
 			(unsigned long) page_start, (unsigned long) addr);
@@ -6831,7 +6831,7 @@
 	    int *page_start;
 
 	    page_start = (int *) page_address(first_page);
-	    memset(page_start, 0, PAGE_SIZE * (last_page - first_page));
+	    memset(page_start, 0, GC_PAGE_SIZE * (last_page - first_page));
 	}
 
 	first_page = last_page;
@@ -7150,8 +7150,8 @@
 	     */
 	    for (last_page = i;; last_page++)
 		/* Check if this is the last page in this contiguous block */
-		if (page_table[last_page].bytes_used < PAGE_SIZE
-		    /* Or it is PAGE_SIZE and is the last in the block */
+		if (page_table[last_page].bytes_used < GC_PAGE_SIZE
+		    /* Or it is GC_PAGE_SIZE and is the last in the block */
 		    || !PAGE_ALLOCATED(last_page + 1)
 		    || PAGE_UNBOXED(last_page + 1) != region_unboxed
 		    || page_table[last_page + 1].bytes_used == 0
@@ -7161,7 +7161,7 @@
 
 	    verify_space((lispobj *) page_address(i),
 			 (page_table[last_page].bytes_used +
-			  PAGE_SIZE * (last_page - i)) / sizeof(lispobj));
+			  GC_PAGE_SIZE * (last_page - i)) / sizeof(lispobj));
 	    i = last_page;
 	}
     }
@@ -7185,7 +7185,7 @@
 		    fprintf(stderr, "** free page not zero @ %lx\n",
 			    (unsigned long) (start_addr + i));
 	} else {
-	    int free_bytes = PAGE_SIZE - page_table[page].bytes_used;
+	    int free_bytes = GC_PAGE_SIZE - page_table[page].bytes_used;
 
 	    if (free_bytes > 0) {
 		unsigned long *start_addr =
@@ -7251,7 +7251,7 @@
 
 	    page_start = (void *) page_address(i);
 
-	    os_protect((os_vm_address_t) page_start, PAGE_SIZE,
+	    os_protect((os_vm_address_t) page_start, GC_PAGE_SIZE,
 		       OS_VM_PROT_READ | OS_VM_PROT_EXECUTE);
 
 	    /* Note the page as protected in the page tables */
@@ -7396,7 +7396,7 @@
 
 	fprintf(stderr,
 		"Non-movable pages due to conservative pointers = %d, %d bytes\n",
-		num_dont_move_pages, PAGE_SIZE * num_dont_move_pages);
+		num_dont_move_pages, GC_PAGE_SIZE * num_dont_move_pages);
 #if !(defined(i386) || defined(__x86_64))
 	/*
 	 * There shouldn't be any non-movable pages because we don't have
@@ -7576,7 +7576,7 @@
     last_free_page = last_page + 1;
 
     set_alloc_pointer((lispobj)
-		      ((char *) heap_base + PAGE_SIZE * last_free_page));
+		      ((char *) heap_base + GC_PAGE_SIZE * last_free_page));
 }
 
 
@@ -7770,12 +7770,12 @@
 	    page_start = (void *) page_address(page);
 
 	    /* First remove any write protection */
-	    os_protect((os_vm_address_t) page_start, PAGE_SIZE, OS_VM_PROT_ALL);
+	    os_protect((os_vm_address_t) page_start, GC_PAGE_SIZE, OS_VM_PROT_ALL);
 	    page_table[page].flags &= ~PAGE_WRITE_PROTECTED_MASK;
 
-	    os_invalidate((os_vm_address_t) page_start, PAGE_SIZE);
+	    os_invalidate((os_vm_address_t) page_start, GC_PAGE_SIZE);
 	    addr =
-		(char *) os_validate((os_vm_address_t) page_start, PAGE_SIZE);
+		(char *) os_validate((os_vm_address_t) page_start, GC_PAGE_SIZE);
 	    if (addr == NULL || addr != page_start)
 		fprintf(stderr, "gc_zero: page moved, 0x%08lx ==> 0x%08lx!\n",
 			(unsigned long) page_start, (unsigned long) addr);
@@ -7853,7 +7853,7 @@
     heap_base = (void *) DYNAMIC_0_SPACE_START;
 
     /* The number of pages needed for the dynamic space - rounding up. */
-    dynamic_space_pages = (dynamic_space_size + (PAGE_SIZE - 1)) / PAGE_SIZE;
+    dynamic_space_pages = (dynamic_space_size + (GC_PAGE_SIZE - 1)) / GC_PAGE_SIZE;
 
     page_table =
         (struct page *) malloc(dynamic_space_pages * sizeof(struct page));
@@ -7932,16 +7932,16 @@
 	page_table[page].flags |= PAGE_ALLOCATED_MASK;
 	page_table[page].flags &= ~(PAGE_UNBOXED_MASK | PAGE_GENERATION_MASK
 				    | PAGE_LARGE_OBJECT_MASK);
-	page_table[page].bytes_used = PAGE_SIZE;
+	page_table[page].bytes_used = GC_PAGE_SIZE;
 	page_table[page].first_object_offset =
 	    (char *) DYNAMIC_0_SPACE_START - page_address(page);
-	addr += PAGE_SIZE;
+	addr += GC_PAGE_SIZE;
 	page++;
     }
     while (addr < alloc_ptr);
 
-    generations[0].bytes_allocated = PAGE_SIZE * page;
-    bytes_allocated = PAGE_SIZE * page;
+    generations[0].bytes_allocated = GC_PAGE_SIZE * page;
+    bytes_allocated = GC_PAGE_SIZE * page;
 
     set_current_region_free((lispobj) boxed_region.free_pointer);
     set_current_region_end((lispobj) boxed_region.end_addr);
Index: src/lisp/gencgc.h
diff -u src/lisp/gencgc.h:1.16 src/lisp/gencgc.h:1.17
--- src/lisp/gencgc.h:1.16	Mon Nov  2 10:05:07 2009
+++ src/lisp/gencgc.h	Sat Jan  8 19:12:36 2011
@@ -7,7 +7,7 @@
  *
  * Douglas Crosher, 1996, 1997.
  *
- * $Header: /project/cmucl/cvsroot/src/lisp/gencgc.h,v 1.16 2009-11-02 15:05:07 rtoy Rel $
+ * $Header: /project/cmucl/cvsroot/src/lisp/gencgc.h,v 1.17 2011-01-09 00:12:36 rtoy Exp $
  *
  */
 
@@ -124,7 +124,7 @@
  */
 
 #if defined(i386)
-#define PAGE_SIZE 4096
+#define GC_PAGE_SIZE 4096
 #elif defined(sparc)
 /*
  * For sparc, the minimum page size (physical page size) is 8K.
@@ -134,17 +134,17 @@
  * page size.  (I'm assuming the gain is because we do the kernel
  * allocation trap less often.)
  */
-#define PAGE_SIZE (4*8192)
+#define GC_PAGE_SIZE (4*8192)
 #elif defined(DARWIN)
 /*
  * The physical page size is 4K.  Like sparc, this appears to be
  * somewhat slow (but need to verify that), so let's make the page
  * size 32K so we hit the allocation trap less often.
  */
-/*#define PAGE_SIZE 4096*/
-/*#define PAGE_SIZE (2*4096)*/
-#define PAGE_SIZE (4*4096)
-/*#define PAGE_SIZE (8*4096)*/
+/*#define GC_PAGE_SIZE 4096*/
+/*#define GC_PAGE_SIZE (2*4096)*/
+#define GC_PAGE_SIZE (4*4096)
+/*#define GC_PAGE_SIZE (8*4096)*/
 #endif
 
 extern unsigned dynamic_space_pages;


More information about the cmucl-commit mailing list