From 83f243850a509a5eb692c578d34a432afcd88713 Mon Sep 17 00:00:00 2001 From: Douglas Katzman Date: Sat, 18 Nov 2017 13:05:00 -0500 Subject: [PATCH] Generalize immobile space addresses This is the first of several changes to split immobile space into two possibly discontiguous ranges. Certain assumptions are removed, but only in as much as they pertain to naming convention: (1) that *immobile-space-free-pointer* is the upper bound on both subspaces (2) that varyobj-space-start is fixedobj-space-start + fixedobj-space-size Those constraints are not actually removed as yet. A consequence of this patch is that GENCGC-SPACE-SETUP changed a lot, but hopefully the keyword arguments make more sense now. Corrected a fencepost error in IMMOBILE-SPACE-ADDR-P. --- package-data-list.lisp-expr | 9 +- src/code/alloc.lisp | 25 +++--- src/code/gc.lisp | 9 +- src/code/misc-aliens.lisp | 11 ++- src/code/room.lisp | 13 ++- src/compiler/generic/early-objdef.lisp | 2 +- src/compiler/generic/genesis.lisp | 7 +- src/compiler/generic/parms.lisp | 81 ++++++++++-------- src/compiler/x86-64/target-insts.lisp | 5 +- src/runtime/coreparse.c | 32 ++++---- src/runtime/fullcgc.c | 6 +- src/runtime/gc-common.c | 8 +- src/runtime/gencgc-internal.h | 2 +- src/runtime/gencgc.c | 4 +- src/runtime/globals.c | 4 +- src/runtime/globals.h | 4 +- src/runtime/immobile-space.c | 146 +++++++++++++++++---------------- src/runtime/os.h | 6 +- src/runtime/parse.c | 4 +- src/runtime/save.c | 8 +- src/runtime/traceroot.c | 9 +- src/runtime/validate.c | 2 +- tests/gc.impure.lisp | 8 ++ 23 files changed, 210 insertions(+), 195 deletions(-) diff --git a/package-data-list.lisp-expr b/package-data-list.lisp-expr index 165e9ec9c..9ddb2dd3f 100644 --- a/package-data-list.lisp-expr +++ b/package-data-list.lisp-expr @@ -3206,11 +3206,10 @@ structure representations" "DYNAMIC-1-SPACE-START" "DYNAMIC-1-SPACE-END") #!+immobile-space("IMMOBILE-CARD-BYTES" - "IMMOBILE-SPACE-SIZE" - "IMMOBILE-SPACE-START" - "IMMOBILE-FIXEDOBJ-SUBSPACE-SIZE" - "*IMMOBILE-FIXEDOBJ-FREE-POINTER*" - "*IMMOBILE-SPACE-FREE-POINTER*") + "FIXEDOBJ-SPACE-START" "FIXEDOBJ-SPACE-SIZE" + "VARYOBJ-SPACE-START" "VARYOBJ-SPACE-SIZE" + "*FIXEDOBJ-SPACE-FREE-POINTER*" + "*VARYOBJ-SPACE-FREE-POINTER*") "READ-ONLY-SPACE-START" "READ-ONLY-SPACE-END" "STATIC-SPACE-START" "STATIC-SPACE-END" #!+linkage-table("LINKAGE-TABLE-SPACE-START" diff --git a/src/code/alloc.lisp b/src/code/alloc.lisp index 3f9e9cebe..9cbbd7c90 100644 --- a/src/code/alloc.lisp +++ b/src/code/alloc.lisp @@ -68,17 +68,14 @@ ;;; Return the zero-based index within the varyobj subspace of immobile space. (defun varyobj-page-index (address) (declare (type (and fixnum unsigned-byte) address)) - (values (floor (- address (+ immobile-space-start immobile-fixedobj-subspace-size)) - immobile-card-bytes))) + (values (floor (- address varyobj-space-start) immobile-card-bytes))) (defun varyobj-page-address (index) - (+ immobile-space-start immobile-fixedobj-subspace-size - (* index immobile-card-bytes))) + (+ varyobj-space-start (* index immobile-card-bytes))) ;;; Convert a zero-based varyobj page index into a scan start address. (defun varyobj-page-scan-start (index) - (- (+ immobile-space-start immobile-fixedobj-subspace-size - (* (1+ index) immobile-card-bytes)) + (- (+ varyobj-space-start (* (1+ index) immobile-card-bytes)) (* 2 n-word-bytes (deref varyobj-page-scan-start-offset index)))) (declaim (inline hole-p)) @@ -167,9 +164,9 @@ (remove-from-freelist found)) found)) -(defun set-immobile-space-free-pointer (free-ptr) +(defun set-varyobj-space-free-pointer (free-ptr) (declare (type (and fixnum unsigned-byte) free-ptr)) - (setq *immobile-space-free-pointer* (int-sap free-ptr)) + (setq *varyobj-space-free-pointer* (int-sap free-ptr)) ;; When the free pointer is not page-aligned - it usually won't be - ;; then we create an unboxed array from the pointer to the page end ;; so that it appears as one contiguous object when scavenging. @@ -187,7 +184,7 @@ #!+immobile-space-debug (awhen *in-use-bits* (mark-range it hole (hole-size hole) nil)) (let* ((hole-end (hole-end-address hole)) - (end-is-free-ptr (eql hole-end (sap-int *immobile-space-free-pointer*)))) + (end-is-free-ptr (eql hole-end (sap-int *varyobj-space-free-pointer*)))) ;; First, ensure that no page's scan-start points to this hole. ;; For smaller-than-page objects, this will do nothing if the hole ;; was not the scan-start. For larger-than-page, we have to update @@ -243,7 +240,7 @@ ;; the free pointer diminishes the opportunity to use the frontier ;; to later allocate a larger object that would not have fit ;; into any existing hole. - (set-immobile-space-free-pointer hole) + (set-varyobj-space-free-pointer hole) (return-from unallocate)) (let* ((successor hole-end) (succ-is-free (freed-hole-p successor))) @@ -291,15 +288,15 @@ (add-to-freelist found) (+ found remaining)))))) ; Consume the upper piece ;; 3. Extend the frontier. - (let* ((addr (sap-int *immobile-space-free-pointer*)) + (let* ((addr (sap-int *varyobj-space-free-pointer*)) (free-ptr (+ addr n-bytes)) - (limit (+ immobile-space-start - (- immobile-space-size immobile-card-bytes)))) + (limit (+ varyobj-space-start + (- varyobj-space-size immobile-card-bytes)))) ;; The last page can't be used, because GC uses it as scratch space. (when (> free-ptr limit) (format t "~&Immobile space exhausted~%") (sb!impl::%halt)) - (set-immobile-space-free-pointer free-ptr) + (set-varyobj-space-free-pointer free-ptr) addr)))) (aver (not (logtest addr lowtag-mask))) ; Assert proper alignment ;; Compute the start and end of the first page consumed. diff --git a/src/code/gc.lisp b/src/code/gc.lisp index 497d038ea..dc3f9766f 100644 --- a/src/code/gc.lisp +++ b/src/code/gc.lisp @@ -41,11 +41,14 @@ #!+immobile-space (progn #!+relocatable-heap - (define-alien-variable ("IMMOBILE_SPACE_START" sb!vm:immobile-space-start) unsigned-long) + (progn + (define-alien-variable ("FIXEDOBJ_SPACE_START" sb!vm:fixedobj-space-start) unsigned-long) + (define-alien-variable ("VARYOBJ_SPACE_START" sb!vm:varyobj-space-start) unsigned-long)) (defun immobile-space-addr-p (addr) (declare (type word addr)) - (let ((start sb!vm:immobile-space-start)) - (<= start addr (truly-the word (+ start sb!vm:immobile-space-size))))) + (let ((start sb!vm:fixedobj-space-start)) + (<= start addr (truly-the word (+ start (1- (+ sb!vm:fixedobj-space-size + sb!vm:varyobj-space-size))))))) (defun immobile-space-obj-p (obj) (immobile-space-addr-p (get-lisp-obj-address obj)))) diff --git a/src/code/misc-aliens.lisp b/src/code/misc-aliens.lisp index b390670e0..9ca99a02c 100644 --- a/src/code/misc-aliens.lisp +++ b/src/code/misc-aliens.lisp @@ -18,12 +18,11 @@ (define-alien-variable ("static_space_free_pointer" sb!vm:*static-space-free-pointer*) system-area-pointer) #!+immobile-space -(progn (define-alien-variable ("immobile_space_free_pointer" - sb!vm:*immobile-space-free-pointer*) - system-area-pointer) - (define-alien-variable ("immobile_fixedobj_free_pointer" - sb!vm:*immobile-fixedobj-free-pointer*) - system-area-pointer)) +(progn + (define-alien-variable ("varyobj_free_pointer" sb!vm:*varyobj-space-free-pointer*) + system-area-pointer) + (define-alien-variable ("fixedobj_free_pointer" sb!vm:*fixedobj-space-free-pointer*) + system-area-pointer)) (declaim (inline memmove)) (define-alien-routine ("memmove" memmove) void diff --git a/src/code/room.lisp b/src/code/room.lisp index 6b0f3e553..2b606e5ed 100644 --- a/src/code/room.lisp +++ b/src/code/room.lisp @@ -149,8 +149,8 @@ (%make-lisp-obj (sap-int *read-only-space-free-pointer*)))) #+immobile-space (:immobile - (values (%make-lisp-obj immobile-space-start) - (%make-lisp-obj (sap-int *immobile-space-free-pointer*)))) + (values (%make-lisp-obj fixedobj-space-start) + (%make-lisp-obj (sap-int *varyobj-space-free-pointer*)))) (:dynamic (values (%make-lisp-obj (current-dynamic-space-start)) (%make-lisp-obj (sap-int (dynamic-space-free-pointer))))))) @@ -325,11 +325,10 @@ ;;; Return fixnums in the same fashion as %SPACE-BOUNDS. (defun immobile-subspace-bounds (subspace) (case subspace - (:fixed (values (%make-lisp-obj immobile-space-start) - (%make-lisp-obj (sap-int *immobile-fixedobj-free-pointer*)))) - (:variable (values (%make-lisp-obj (+ immobile-space-start - immobile-fixedobj-subspace-size)) - (%make-lisp-obj (sap-int *immobile-space-free-pointer*)))))) + (:fixed (values (%make-lisp-obj fixedobj-space-start) + (%make-lisp-obj (sap-int *fixedobj-space-free-pointer*)))) + (:variable (values (%make-lisp-obj varyobj-space-start) + (%make-lisp-obj (sap-int *varyobj-space-free-pointer*)))))) (declaim (ftype (sfunction (function &rest immobile-subspaces) null) map-immobile-objects)) diff --git a/src/compiler/generic/early-objdef.lisp b/src/compiler/generic/early-objdef.lisp index 30e1a5061..31bba8ca7 100644 --- a/src/compiler/generic/early-objdef.lisp +++ b/src/compiler/generic/early-objdef.lisp @@ -320,7 +320,7 @@ ;; The cross-compiler stores FUNCTION-LAYOUT in a more obvious way. #+sb-xc-host (defconstant function-layout ; kludge - verified by genesis - (logior (+ immobile-space-start layout-align) instance-pointer-lowtag))) + (logior (+ fixedobj-space-start layout-align) instance-pointer-lowtag))) #| ;; Run this in the SB-VM or SB!VM package once for each target feature combo. diff --git a/src/compiler/generic/genesis.lisp b/src/compiler/generic/genesis.lisp index d61704f39..8b52ee1f5 100644 --- a/src/compiler/generic/genesis.lisp +++ b/src/compiler/generic/genesis.lisp @@ -2906,7 +2906,7 @@ core and return a descriptor to it." #!+immobile-space ;; Must be a multiple of 32 because it makes the math a nicer ;; when computing word and bit index into the 'touched' bitmap. - (assert (zerop (rem sb!vm:immobile-fixedobj-subspace-size + (assert (zerop (rem sb!vm:fixedobj-space-size (* 32 sb!vm:immobile-card-bytes)))) #!-gencgc (progn @@ -3620,12 +3620,11 @@ III. initially undefined function references (alphabetically): #!+immobile-space (*immobile-fixedobj* (make-gspace :immobile-fixedobj immobile-fixedobj-core-space-id - sb!vm:immobile-space-start)) + sb!vm:fixedobj-space-start)) #!+immobile-space (*immobile-varyobj* (make-gspace :immobile-varyobj immobile-varyobj-core-space-id - (+ sb!vm:immobile-space-start - sb!vm:immobile-fixedobj-subspace-size))) + sb!vm:varyobj-space-start)) (*dynamic* (make-gspace :dynamic dynamic-core-space-id #!+gencgc sb!vm:dynamic-space-start diff --git a/src/compiler/generic/parms.lisp b/src/compiler/generic/parms.lisp index f45a84d5a..8c2754282 100644 --- a/src/compiler/generic/parms.lisp +++ b/src/compiler/generic/parms.lisp @@ -62,14 +62,21 @@ ;; for almost all platforms, but is too small to make VirtualProtect ;; happy -- hence the need for an extra `alignment' configuration ;; option below, which parms.lisp can set to #x10000 on Windows. +;; To clarify: there is a gap at the end of read-only space to +;; the safepoint page, but no gap at the end of the latter +;; to the start of static space. (What do these gaps achieve?) ;; (defmacro !gencgc-space-setup (small-spaces-start &key ((:dynamic-space-start dynamic-space-start*)) ((:dynamic-space-size dynamic-space-size*)) - #!+immobile-space - ((:immobile-space-size immobile-space-size*) (* 128 1024 1024)) - #!+immobile-space (immobile-code-space-size (* 104 1024 1024)) + ;; The immobile-space START parameters should not be used + ;; except in forcing discontiguous addresses for testing. + ;; And of course, don't use them if unsupported. + ((:fixedobj-space-start fixedobj-space-start*)) + ((:fixedobj-space-size fixedobj-space-size*) (* 24 1024 1024)) + ((:varyobj-space-start varyobj-space-start*)) + ((:varyobj-space-size varyobj-space-size*) (* 104 1024 1024)) ;; Smallest os_validate()able alignment; used as safepoint ;; page size. Default suitable for POSIX platforms. (alignment #x1000) @@ -88,53 +95,61 @@ ;; but can't be due to dependency order problem. ))) (let* - ((spaces '(read-only static - #!+linkage-table linkage-table - #!+immobile-space immobile)) + ((spaces (append `((read-only . ,small-space-spread) + (static . ,small-space-spread)) + #!+linkage-table + `((linkage-table . ,small-space-spread)) + #!+immobile-space + `((fixedobj . ,fixedobj-space-size*) + (varyobj . ,varyobj-space-size*)))) (ptr small-spaces-start) safepoint-address (small-space-forms - (loop for (space next-space) on spaces appending + (loop for (space . size) in spaces appending (let* ((relocatable - ;; TODO: immobile and linkage-table should be relocatable - #!+relocatable-heap (member space '(immobile))) - (next-start - (+ ptr (cond #!+immobile-space - ((eq space 'immobile) - ;; We subtract margin-size when - ;; computing FOO-SPACE-END, - ;; so add it in here to compensate. - (+ immobile-space-size* margin-size)) - (t - small-space-spread)))) - (end next-start)) - (when (eq next-space 'static) + ;; TODO: linkage-table could move with code, if the CPU + ;; prefers PC-relative jumps, and we emit better code + ;; (which we don't- for x86 we jmp via RBX always) + #!+relocatable-heap (member space '(fixedobj varyobj))) + (start ptr) + (end (+ ptr size))) + (setf ptr end) + (when (eq space 'read-only) ;; margin becomes safepoint page; substract margin again. (decf end alignment) (setf safepoint-address end)) - (let* ((start-sym (symbolicate space "-SPACE-START")) - (start-val ptr) - (end-val (- end margin-size))) - (setf ptr next-start) - `(,(defconstantish relocatable start-sym start-val) + (let ((start-sym (symbolicate space "-SPACE-START"))) + ;; Allow expressly given addresses / sizes for immobile space. + ;; The addresses are for testing only - you should not need them. + (case space + (varyobj (setq start (or varyobj-space-start* start) + end (+ start varyobj-space-size*))) + (fixedobj (setq start (or fixedobj-space-start* start) + end (+ start fixedobj-space-size*))) + (t (setq end (- end margin-size)))) + `(,(defconstantish relocatable start-sym start) ,(if relocatable - `(defconstant ,(symbolicate space "-SPACE-SIZE") - ,(- end-val start-val)) - `(defconstant ,(symbolicate space "-SPACE-END") - ,end-val))))))) + `(defconstant ,(symbolicate space "-SPACE-SIZE") ,(- end start)) + `(defconstant ,(symbolicate space "-SPACE-END") ,end))))))) (safepoint-page-forms (list #!+sb-safepoint `(defconstant gc-safepoint-page-addr ,safepoint-address))) ) - #+ccl safepoint-address ; workaround for incorrect "Unused" warning + ;; CCL warns about a variable that is assigned but never read. + ;; That's actually reasonable. We consider it used, as do others. + safepoint-address ; "use" it here just to be sure it's used `(progn ,@safepoint-page-forms ,@small-space-forms - #!+immobile-space - (defconstant immobile-fixedobj-subspace-size - ,(- immobile-space-size* immobile-code-space-size)) ,(defconstantish (or #!+relocatable-heap t) 'dynamic-space-start (or dynamic-space-start* ptr)) + #!+(and immobile-space (host-feature sb-xc-host)) + (unless (and (< fixedobj-space-start varyobj-space-start) + (= (+ fixedobj-space-start fixedobj-space-size) + varyobj-space-start)) + (error "Incorrect immobile space setup: ~X:~X ~X:~X" + fixedobj-space-start (+ fixedobj-space-start fixedobj-space-size) + varyobj-space-start (+ varyobj-space-start varyobj-space-size))) (defconstant default-dynamic-space-size ;; Build-time make-config.sh option "--dynamic-space-size" overrides ;; keyword argument :dynamic-space-size which overrides general default. diff --git a/src/compiler/x86-64/target-insts.lisp b/src/compiler/x86-64/target-insts.lisp index 5a227032a..24970ec0f 100644 --- a/src/compiler/x86-64/target-insts.lisp +++ b/src/compiler/x86-64/target-insts.lisp @@ -535,9 +535,8 @@ ,@body)))) ;; Slowness here is bothersome, especially for SB!VM::REMOVE-STATIC-LINKS, ;; so skip right over all fixedobj pages. - (ash (+ immobile-space-start immobile-fixedobj-subspace-size) - (- n-fixnum-tag-bits)) - (%make-lisp-obj (sap-int *immobile-space-free-pointer*))))) + (ash varyobj-space-start (- n-fixnum-tag-bits)) + (%make-lisp-obj (sap-int *varyobj-space-free-pointer*))))) (defun sb!vm::statically-link-core (&key callers exclude-callers callees exclude-callees diff --git a/src/runtime/coreparse.c b/src/runtime/coreparse.c index 1d71a6f1e..0f5ed517a 100644 --- a/src/runtime/coreparse.c +++ b/src/runtime/coreparse.c @@ -550,8 +550,8 @@ void relocate_heap(struct heap_adjust* adj) fprintf(stderr, "Relocating immobile space from [%p:%p] to [%p:%p]\n", (char*)adj->range[0].start, (char*)adj->range[0].end, - (char*)IMMOBILE_SPACE_START, - (char*)IMMOBILE_SPACE_START+(adj->range[0].end-adj->range[0].start)); + (char*)FIXEDOBJ_SPACE_START, + (char*)FIXEDOBJ_SPACE_START+(adj->range[0].end-adj->range[0].start)); #endif fprintf(stderr, "Relocating dynamic space from [%p:%p] to [%p:%p]\n", (char*)adj->range[1].start, @@ -561,8 +561,8 @@ void relocate_heap(struct heap_adjust* adj) } relocate_space(STATIC_SPACE_START, static_space_free_pointer, adj); #ifdef LISP_FEATURE_IMMOBILE_SPACE - relocate_space(IMMOBILE_SPACE_START, immobile_fixedobj_free_pointer, adj); - relocate_space(IMMOBILE_VARYOBJ_SUBSPACE_START, immobile_space_free_pointer, adj); + relocate_space(FIXEDOBJ_SPACE_START, fixedobj_free_pointer, adj); + relocate_space(VARYOBJ_SPACE_START, varyobj_free_pointer, adj); SYMBOL(FUNCTION_LAYOUT)->value = \ adjust_word(adj, SYMBOL(FUNCTION_LAYOUT)->value >> 32) << 32; #endif @@ -606,8 +606,8 @@ process_directory(int count, struct ndir_entry *entry, {0, STATIC_SPACE_START, &static_space_free_pointer}, {0, READ_ONLY_SPACE_START, &read_only_space_free_pointer}, #ifdef LISP_FEATURE_IMMOBILE_SPACE - {0, IMMOBILE_SPACE_START, &immobile_fixedobj_free_pointer}, - {0, IMMOBILE_VARYOBJ_SUBSPACE_START, &immobile_space_free_pointer} + {0, FIXEDOBJ_SPACE_START, &fixedobj_free_pointer}, + {0, VARYOBJ_SPACE_START, &varyobj_free_pointer} #endif }; @@ -674,7 +674,7 @@ process_directory(int count, struct ndir_entry *entry, # ifndef LISP_FEATURE_IMMOBILE_SPACE } # else - if (DYNAMIC_SPACE_START < IMMOBILE_SPACE_START) + if (DYNAMIC_SPACE_START < FIXEDOBJ_SPACE_START) lose("Won't map dynamic space below immobile space"); /* Assume presence of linkage-table space for this platform. * An unusable gap may exist between the linkage table and immobile space @@ -682,18 +682,18 @@ process_directory(int count, struct ndir_entry *entry, * unmapping the alleged gap */ } else if (id == IMMOBILE_FIXEDOBJ_CORE_SPACE_ID) { addr = (uword_t)os_validate(MOVABLE_LOW, (os_vm_address_t)addr, - IMMOBILE_SPACE_SIZE); - IMMOBILE_SPACE_START = addr; - if (IMMOBILE_SPACE_START + IMMOBILE_SPACE_SIZE > 0x80000000) + IMMOBILE_SPACE_TOTAL_SIZE); + FIXEDOBJ_SPACE_START = addr; + if (FIXEDOBJ_SPACE_START + IMMOBILE_SPACE_TOTAL_SIZE > 0x80000000) lose("Won't map immobile space above 2GB"); // varyobj subspace must be enforced to reside at a known offset // from fixedobj subspace. spaces[IMMOBILE_VARYOBJ_CORE_SPACE_ID].base = - spaces[id].base + IMMOBILE_FIXEDOBJ_SUBSPACE_SIZE; - IMMOBILE_VARYOBJ_SUBSPACE_START = addr + IMMOBILE_FIXEDOBJ_SUBSPACE_SIZE; + spaces[id].base + FIXEDOBJ_SPACE_SIZE; + VARYOBJ_SPACE_START = addr + FIXEDOBJ_SPACE_SIZE; } else if (id == IMMOBILE_VARYOBJ_CORE_SPACE_ID) { /* Ignore what the core file said */ - addr = IMMOBILE_VARYOBJ_SUBSPACE_START; + addr = VARYOBJ_SPACE_START; } # endif @@ -738,11 +738,11 @@ process_directory(int count, struct ndir_entry *entry, #ifdef LISP_FEATURE_RELOCATABLE_HEAP #ifdef LISP_FEATURE_IMMOBILE_SPACE - if (IMMOBILE_SPACE_START != spaces[IMMOBILE_FIXEDOBJ_CORE_SPACE_ID].base) { + if (FIXEDOBJ_SPACE_START != spaces[IMMOBILE_FIXEDOBJ_CORE_SPACE_ID].base) { adj->range[0].start = spaces[IMMOBILE_FIXEDOBJ_CORE_SPACE_ID].base; - adj->range[0].end = adj->range[0].start + IMMOBILE_FIXEDOBJ_SUBSPACE_SIZE + adj->range[0].end = adj->range[0].start + FIXEDOBJ_SPACE_SIZE + spaces[IMMOBILE_VARYOBJ_CORE_SPACE_ID].len; - adj->range[0].delta = IMMOBILE_SPACE_START - adj->range[0].start; + adj->range[0].delta = FIXEDOBJ_SPACE_START - adj->range[0].start; } #endif if (DYNAMIC_SPACE_START != spaces[DYNAMIC_CORE_SPACE_ID].base) { diff --git a/src/runtime/fullcgc.c b/src/runtime/fullcgc.c index fafc1596a..9c5a5e611 100644 --- a/src/runtime/fullcgc.c +++ b/src/runtime/fullcgc.c @@ -433,8 +433,8 @@ static void sweep_fixedobj_pages(long *zeroed) low_page_index_t page; for (page = 0 ; ; ++page) { - lispobj *obj = (lispobj*)((char*)IMMOBILE_SPACE_START + page * IMMOBILE_CARD_BYTES); - if (obj >= immobile_fixedobj_free_pointer) + lispobj *obj = (lispobj*)(FIXEDOBJ_SPACE_START + page * IMMOBILE_CARD_BYTES); + if (obj >= fixedobj_free_pointer) break; int obj_spacing = fixedobj_page_obj_align(page); if (!obj_spacing) @@ -518,7 +518,7 @@ void execute_full_sweep_phase() #ifdef LISP_FEATURE_IMMOBILE_SPACE sweep_fixedobj_pages(words_zeroed); if (sweeplog) fprintf(sweeplog, "-- varyobj pages --\n"); - sweep((lispobj*)IMMOBILE_VARYOBJ_SUBSPACE_START, immobile_space_free_pointer, + sweep((lispobj*)VARYOBJ_SPACE_START, varyobj_free_pointer, (uword_t)words_zeroed); #endif if (sweeplog) fprintf(sweeplog, "-- dynamic space --\n"); diff --git a/src/runtime/gc-common.c b/src/runtime/gc-common.c index 1b3dd6c64..d902e8de4 100644 --- a/src/runtime/gc-common.c +++ b/src/runtime/gc-common.c @@ -2187,12 +2187,8 @@ void coalesce_similar_objects() (uword_t)&ht); #endif #ifdef LISP_FEATURE_IMMOBILE_SPACE - coalesce_range((lispobj*)IMMOBILE_SPACE_START, - immobile_fixedobj_free_pointer, - (uword_t)&ht); - coalesce_range((lispobj*)IMMOBILE_VARYOBJ_SUBSPACE_START, - immobile_space_free_pointer, - (uword_t)&ht); + coalesce_range((lispobj*)FIXEDOBJ_SPACE_START, fixedobj_free_pointer, (uword_t)&ht); + coalesce_range((lispobj*)VARYOBJ_SPACE_START, varyobj_free_pointer, (uword_t)&ht); #endif #ifdef LISP_FEATURE_GENCGC walk_generation(coalesce_range, -1, (uword_t)&ht); diff --git a/src/runtime/gencgc-internal.h b/src/runtime/gencgc-internal.h index 173ff7f9d..942c2caa3 100644 --- a/src/runtime/gencgc-internal.h +++ b/src/runtime/gencgc-internal.h @@ -268,7 +268,7 @@ struct fixedobj_page { // 12 bytes per page extern struct fixedobj_page *fixedobj_pages; #define fixedobj_page_obj_align(i) (fixedobj_pages[i].attr.parts.obj_align<= (void*)IMMOBILE_SPACE_START) { + if (addr >= (void*)FIXEDOBJ_SPACE_START) { // Must use full register size here to avoid truncation of quotient // and bogus result! page_index_t index = ((uintptr_t)addr - - (uintptr_t)IMMOBILE_SPACE_START) / IMMOBILE_CARD_BYTES; - if (index < (int)(IMMOBILE_SPACE_SIZE/IMMOBILE_CARD_BYTES)) + (uintptr_t)FIXEDOBJ_SPACE_START) / IMMOBILE_CARD_BYTES; + if (index < (int)(IMMOBILE_SPACE_TOTAL_SIZE/IMMOBILE_CARD_BYTES)) return index; } return -1; @@ -192,7 +192,7 @@ static inline void set_visited(lispobj* obj) static inline void * low_page_address(low_page_index_t page_num) { - return ((char*)IMMOBILE_SPACE_START + (page_num * IMMOBILE_CARD_BYTES)); + return ((char*)FIXEDOBJ_SPACE_START + (page_num * IMMOBILE_CARD_BYTES)); } //// Variable-length utilities @@ -227,7 +227,7 @@ unsigned char varyobj_page_gens_augmented(low_page_index_t page_index) /* Return the index of an immobile page that is probably not totally full, starting with 'hint_page' and wrapping around. 'attributes' determine an eligible page. - *IMMOBILE-SPACE-FREE-POINTER* is updated to point beyond the found page + *FIXEDOBJ-SPACE-FREE-POINTER* is updated to point beyond the found page if it previously did not. */ static int get_freeish_page(int hint_page, int attributes) @@ -251,10 +251,10 @@ static int get_freeish_page(int hint_page, int attributes) // Atomically assign MAX(old_free_pointer, new_free_pointer) // into the free pointer. new_free_pointer = low_page_address(page+1); - old_free_pointer = immobile_fixedobj_free_pointer; + old_free_pointer = fixedobj_free_pointer; while (new_free_pointer > old_free_pointer) { actual_old = - __sync_val_compare_and_swap(&immobile_fixedobj_free_pointer, + __sync_val_compare_and_swap(&fixedobj_free_pointer, old_free_pointer, new_free_pointer); if (actual_old == old_free_pointer) @@ -315,7 +315,7 @@ lispobj alloc_immobile_obj(int page_attributes, lispobj header, int* hint) int spacing_in_bytes = OBJ_SPACING(page_attributes) << WORD_SHIFT; page = *hint; - gc_dcheck(low_page_address(page) < (void*)immobile_fixedobj_free_pointer); + gc_dcheck(low_page_address(page) < (void*)fixedobj_free_pointer); do { page_data = low_page_address(page); obj_ptr = page_data + fixedobj_pages[page].free_index; @@ -366,10 +366,8 @@ Threads A, and B, and C each want to claim index 6. // Find the high water marks for this GC scavenge phase // (avoid passing exactly IMMOBILE_SPACE_END, which has no page index) -#define calc_max_used_fixedobj_page() \ - find_immobile_page_index(immobile_fixedobj_free_pointer-1) -#define calc_max_used_varyobj_page() \ - find_immobile_page_index(immobile_space_free_pointer-1) +#define calc_max_used_fixedobj_page() find_immobile_page_index(fixedobj_free_pointer-1) +#define calc_max_used_varyobj_page() find_immobile_page_index(varyobj_free_pointer-1) void update_immobile_nursery_bits() { @@ -378,20 +376,21 @@ void update_immobile_nursery_bits() low_page_index_t page; immobile_scav_queue = (unsigned int*)low_page_address(max_used_varyobj_page+1); - gc_assert((IMMOBILE_SPACE_END - (uword_t)immobile_scav_queue) / sizeof(int) + gc_assert((FIXEDOBJ_SPACE_START + IMMOBILE_SPACE_TOTAL_SIZE + - (uword_t)immobile_scav_queue) / sizeof(int) >= QCAPACITY); if (ENABLE_PAGE_PROTECTION) { // Unprotect the in-use ranges. Any page could be written during scavenge - os_protect((os_vm_address_t)IMMOBILE_SPACE_START, - (lispobj)immobile_fixedobj_free_pointer - IMMOBILE_SPACE_START, + os_protect((os_vm_address_t)FIXEDOBJ_SPACE_START, + (lispobj)fixedobj_free_pointer - FIXEDOBJ_SPACE_START, OS_VM_PROT_ALL); // varyobj_free_ptr is typically not page-aligned - only by random chance // might it be. Additionally we need a page beyond that for the re-scan queue. os_vm_address_t limit = (char*)immobile_scav_queue + IMMOBILE_CARD_BYTES; - os_protect((os_vm_address_t)(IMMOBILE_VARYOBJ_SUBSPACE_START), - limit - (os_vm_address_t)IMMOBILE_VARYOBJ_SUBSPACE_START, + os_protect((os_vm_address_t)VARYOBJ_SPACE_START, + limit - (os_vm_address_t)VARYOBJ_SPACE_START, OS_VM_PROT_ALL); } @@ -467,12 +466,12 @@ void immobile_space_preserve_pointer(void* addr) int valid = 0; if (page_index >= FIRST_VARYOBJ_PAGE) { - // Restrict addr to lie below IMMOBILE_SPACE_FREE_POINTER. + // Restrict addr to lie below 'varyobj_free_pointer'. // This way, if the gens byte is nonzero but there is // a final array acting as filler on the remainder of the // final page, we won't accidentally find that. lispobj* scan_start; - valid = addr < (void*)immobile_space_free_pointer + valid = addr < (void*)varyobj_free_pointer && (varyobj_page_gens_augmented(page_index) & genmask) && (scan_start = varyobj_scan_start(page_index)) <= (lispobj*)addr && (object_start = gc_search_space(scan_start, addr)) != 0 @@ -693,8 +692,8 @@ scavenge_immobile_roots(generation_index_t min_gen, generation_index_t max_gen) #define LAYOUT_SIZE (sizeof (struct layout)/N_WORD_BYTES) /// First 5 layouts: T, FUNCTION, STRUCTURE-OBJECT, LAYOUT, PACKAGE /// (These #defines ought to be emitted by genesis) -#define LAYOUT_OF_LAYOUT ((IMMOBILE_SPACE_START+3*LAYOUT_ALIGN)|INSTANCE_POINTER_LOWTAG) -#define LAYOUT_OF_PACKAGE ((IMMOBILE_SPACE_START+4*LAYOUT_ALIGN)|INSTANCE_POINTER_LOWTAG) +#define LAYOUT_OF_LAYOUT ((FIXEDOBJ_SPACE_START+3*LAYOUT_ALIGN)|INSTANCE_POINTER_LOWTAG) +#define LAYOUT_OF_PACKAGE ((FIXEDOBJ_SPACE_START+4*LAYOUT_ALIGN)|INSTANCE_POINTER_LOWTAG) // As long as Lisp doesn't have any native allocators (vops and whatnot) // it doesn't need to access these values. @@ -926,7 +925,7 @@ static inline boolean can_wp_fixedobj_page(page_index_t page, int keep_gen, int // that any word satisfying is_lisp_pointer() is a pointer. static inline boolean can_wp_varyobj_page(page_index_t page, int keep_gen, int new_gen) { - lispobj *begin = (lispobj*)low_page_address(page); + lispobj *begin = low_page_address(page); lispobj *end = begin + WORDS_PER_PAGE; lispobj *obj = varyobj_scan_start(page); for ( ; obj < end ; obj += sizetab[widetag_of(*obj)](obj) ) { @@ -1085,7 +1084,7 @@ sweep_varyobj_pages(int raise) SETUP_GENS(); low_page_index_t max_used_varyobj_page = calc_max_used_varyobj_page(); - lispobj* free_pointer = immobile_space_free_pointer; + lispobj* free_pointer = varyobj_free_pointer; low_page_index_t page; for (page = FIRST_VARYOBJ_PAGE; page <= max_used_varyobj_page; ++page) { int genmask = VARYOBJ_PAGE_GENS(page); @@ -1097,7 +1096,7 @@ sweep_varyobj_pages(int raise) varyobj_page_touched_bits[(page - FIRST_VARYOBJ_PAGE)/32] &= ~(1U<<(page & 31)); continue; } - lispobj* page_base = (lispobj*)low_page_address(page); + lispobj* page_base = low_page_address(page); lispobj* limit = page_base + WORDS_PER_PAGE; if (limit > free_pointer) limit = free_pointer; int any_kept = 0; // was anything moved to the kept generation @@ -1187,9 +1186,8 @@ static void gc_init_immobile() #ifdef DEBUG logfile = stderr; #endif - int n_fixedobj_pages = FIRST_VARYOBJ_PAGE; - int n_varyobj_pages = (IMMOBILE_SPACE_SIZE - IMMOBILE_FIXEDOBJ_SUBSPACE_SIZE) - / IMMOBILE_CARD_BYTES; + int n_fixedobj_pages = FIXEDOBJ_SPACE_SIZE / IMMOBILE_CARD_BYTES; + int n_varyobj_pages = VARYOBJ_SPACE_SIZE / IMMOBILE_CARD_BYTES; fixedobj_pages = calloc(n_fixedobj_pages, sizeof(struct fixedobj_page)); gc_assert(fixedobj_pages); @@ -1231,7 +1229,7 @@ void immobile_space_coreparse(uword_t fixedobj_len, uword_t varyobj_len) gc_init_immobile(); - address = IMMOBILE_SPACE_START; + address = FIXEDOBJ_SPACE_START; n_pages = fixedobj_len / IMMOBILE_CARD_BYTES; for (page = 0 ; page < n_pages ; ++page) { lispobj* page_data = low_page_address(page); @@ -1251,13 +1249,13 @@ void immobile_space_coreparse(uword_t fixedobj_len, uword_t varyobj_len) } } } - address = IMMOBILE_VARYOBJ_SUBSPACE_START; + address = VARYOBJ_SPACE_START; n_pages = varyobj_len / IMMOBILE_CARD_BYTES; lispobj* obj = (lispobj*)address; int n_words; low_page_index_t last_page = 0; - // coreparse() already set immobile_space_free_pointer - lispobj* limit = immobile_space_free_pointer; + // coreparse() already set varyobj_free_pointer + lispobj* limit = varyobj_free_pointer; gc_assert(limit != 0 /* would be zero if not mmapped yet */ && limit <= (lispobj*)(address + varyobj_len)); for ( ; obj < limit ; obj += n_words ) { @@ -1314,12 +1312,12 @@ void prepare_immobile_space_for_final_gc() { int page; char* page_base; - char* page_end = (char*)immobile_fixedobj_free_pointer; + char* page_end = (char*)fixedobj_free_pointer; // The list of holes need not be saved. SYMBOL(IMMOBILE_FREELIST)->value = NIL; - for (page_base = (char*)IMMOBILE_SPACE_START, page = 0 ; + for (page_base = (char*)FIXEDOBJ_SPACE_START, page = 0 ; page_base < page_end ; page_base += IMMOBILE_CARD_BYTES, ++page) { unsigned char mask = fixedobj_pages[page].gens; @@ -1337,8 +1335,8 @@ void prepare_immobile_space_for_final_gc() } } - lispobj* obj = (lispobj*)IMMOBILE_VARYOBJ_SUBSPACE_START; - lispobj* limit = immobile_space_free_pointer; + lispobj* obj = (lispobj*)VARYOBJ_SPACE_START; + lispobj* limit = varyobj_free_pointer; for ( ; obj < limit ; obj += sizetab[widetag_of(*obj)](obj) ) { if (__immobile_obj_gen_bits(obj) == PSEUDO_STATIC_GENERATION) assign_generation(obj, HIGHEST_NORMAL_GENERATION); @@ -1363,20 +1361,21 @@ int* code_component_order; void prepare_immobile_space_for_save(lispobj init_function, boolean verbose) { // Don't use the page attributes now - defrag doesn't update them. - lispobj* obj = (lispobj*)IMMOBILE_SPACE_START; - lispobj* limit = immobile_fixedobj_free_pointer; + lispobj* obj = (lispobj*)FIXEDOBJ_SPACE_START; + lispobj* limit = fixedobj_free_pointer; while (obj < limit) { if (other_immediate_lowtag_p(*obj)) assign_generation(obj, PSEUDO_STATIC_GENERATION); obj += sizetab[widetag_of(*obj)](obj); } - obj = (lispobj*)IMMOBILE_VARYOBJ_SUBSPACE_START; - limit = immobile_space_free_pointer; + obj = (lispobj*)VARYOBJ_SPACE_START; + limit = varyobj_free_pointer; for ( varyobj_holes = 0 ; obj < limit ; obj += sizetab[widetag_of(*obj)](obj) ) { if (filler_obj_p(obj)) { struct code* code = (struct code*)obj; code->debug_info = varyobj_holes; + code->fixups = 0; varyobj_holes = (lispobj)code; // 0-fill the unused space. int nwords = sizetab[widetag_of(*obj)](obj); @@ -1437,19 +1436,19 @@ search_immobile_space(void *pointer) { lispobj *start; - if ((lispobj)pointer >= IMMOBILE_SPACE_START - && pointer < (void*)immobile_space_free_pointer) { + if ((lispobj)pointer >= FIXEDOBJ_SPACE_START + && pointer < (void*)varyobj_free_pointer) { low_page_index_t page_index = find_immobile_page_index(pointer); - if ((lispobj)pointer >= IMMOBILE_VARYOBJ_SUBSPACE_START) { + if ((lispobj)pointer >= VARYOBJ_SPACE_START) { if (page_attributes_valid) { start = (lispobj*)varyobj_scan_start(page_index); if (start > (lispobj*)pointer) return NULL; } else { - start = (lispobj*)IMMOBILE_VARYOBJ_SUBSPACE_START; + start = (lispobj*)VARYOBJ_SPACE_START; } lispobj* found = gc_search_space(start, pointer); return (found && filler_obj_p(found)) ? 0 : found; - } else if (pointer < (void*)immobile_fixedobj_free_pointer) { + } else if (pointer < (void*)fixedobj_free_pointer) { char *page_base = PTR_ALIGN_DOWN(pointer, IMMOBILE_CARD_BYTES); if (page_attributes_valid) { int spacing = fixedobj_page_obj_align(page_index); @@ -1471,6 +1470,7 @@ search_immobile_space(void *pointer) lispobj* find_preceding_object(lispobj* obj) { int page = find_immobile_page_index(obj); + gc_assert(page >= FIRST_VARYOBJ_PAGE); while (1) { int offset = varyobj_page_scan_start_offset[page - FIRST_VARYOBJ_PAGE]; if (offset) { // 0 means the page is empty. @@ -1611,11 +1611,11 @@ static struct { // physical address to read or write during defragmentation static lispobj* tempspace_addr(void* address) { - int byte_index = (char*)address - (char*)IMMOBILE_VARYOBJ_SUBSPACE_START; + int byte_index = (char*)address - (char*)VARYOBJ_SPACE_START; gc_assert(immobile_space_p((lispobj)address)); if (byte_index < 0) { // fixedobj subspace if (fixedobj_tempspace.n_bytes == 0) return address; - byte_index = (char*)address - (char*)IMMOBILE_SPACE_START; + byte_index = (char*)address - (char*)FIXEDOBJ_SPACE_START; gc_assert(byte_index < fixedobj_tempspace.n_bytes); return (void*)(fixedobj_tempspace.start + byte_index); } else { // varyobj subspace @@ -1917,7 +1917,7 @@ static char* compute_defrag_start_address() { // For technical reasons, objects on the first few pages created by genesis // must never move at all. So figure out where the end of that subspace is. - lispobj* obj = (lispobj*)IMMOBILE_SPACE_START; + lispobj* obj = (lispobj*)FIXEDOBJ_SPACE_START; gc_assert(widetag_of(*obj) == INSTANCE_WIDETAG); while (instance_layout(obj) != LAYOUT_OF_PACKAGE) { obj = (lispobj*)((char*)obj + IMMOBILE_CARD_BYTES); @@ -1989,13 +1989,13 @@ void defrag_immobile_space(int* components, boolean verbose) + calc_n_pages(sym_kind_histo[i], SYMBOL_SIZE) * IMMOBILE_CARD_BYTES; char* ending_alloc_ptr = symbol_alloc_ptr[N_SYMBOL_KINDS]; - fixedobj_tempspace.n_bytes = ending_alloc_ptr - (char*)IMMOBILE_SPACE_START; + fixedobj_tempspace.n_bytes = ending_alloc_ptr - (char*)FIXEDOBJ_SPACE_START; fixedobj_tempspace.start = calloc(fixedobj_tempspace.n_bytes, 1); // Copy the first few pages (the permanent pages) from immobile space // into the temporary copy, so that tempspace_addr() // does not have to return the unadjusted addr if below defrag_base. - memcpy(fixedobj_tempspace.start, (char*)IMMOBILE_SPACE_START, - (lispobj)defrag_base - IMMOBILE_SPACE_START); + memcpy(fixedobj_tempspace.start, (char*)FIXEDOBJ_SPACE_START, + (lispobj)defrag_base - FIXEDOBJ_SPACE_START); #endif // Compute where each code component will be moved to. @@ -2010,7 +2010,7 @@ void defrag_immobile_space(int* components, boolean verbose) gc_assert(widetag == CODE_HEADER_WIDETAG); if (!filler_obj_p(addr)) { ++n_code_components; - new_vaddr = IMMOBILE_VARYOBJ_SUBSPACE_START + varyobj_tempspace.n_bytes; + new_vaddr = VARYOBJ_SPACE_START + varyobj_tempspace.n_bytes; varyobj_tempspace.n_bytes += sizetab[widetag](addr) << WORD_SHIFT; } components[i*2+1] = new_vaddr; @@ -2158,7 +2158,7 @@ void defrag_immobile_space(int* components, boolean verbose) // - funcallable-instance with self-contained trampoline (ditto) // - a simple-fun that was statically linked (varyobj subspace) if (immobile_space_p(target_addr)) { - lispobj *obj = target_addr < IMMOBILE_VARYOBJ_SUBSPACE_START + lispobj *obj = target_addr < VARYOBJ_SPACE_START ? search_immobile_space((void*)(uword_t)target_addr) : defrag_search_varyobj_subspace(target_addr); if (forwarding_pointer_p(obj)) @@ -2191,8 +2191,8 @@ void defrag_immobile_space(int* components, boolean verbose) fixup_space((lispobj*)fixedobj_tempspace.start, fixedobj_tempspace.n_bytes >> WORD_SHIFT); #else - fixup_space((lispobj*)IMMOBILE_SPACE_START, - IMMOBILE_FIXEDOBJ_SUBSPACE_SIZE >> WORD_SHIFT); + fixup_space((lispobj*)FIXEDOBJ_SPACE_START, + FIXEDOBJ_SPACE_SIZE >> WORD_SHIFT); #endif fixup_space((lispobj*)varyobj_tempspace.start, varyobj_tempspace.n_bytes >> WORD_SHIFT); @@ -2211,25 +2211,25 @@ void defrag_immobile_space(int* components, boolean verbose) lispobj old_free_ptr; lispobj free_ptr; #if DEFRAGMENT_FIXEDOBJ_SUBSPACE - int n_static_bytes = ((lispobj)defrag_base - IMMOBILE_SPACE_START); + int n_static_bytes = ((lispobj)defrag_base - FIXEDOBJ_SPACE_START); memcpy((char*)defrag_base, fixedobj_tempspace.start + n_static_bytes, fixedobj_tempspace.n_bytes - n_static_bytes); // Zero-fill the unused remainder - old_free_ptr = (lispobj)immobile_fixedobj_free_pointer; - free_ptr = IMMOBILE_SPACE_START + fixedobj_tempspace.n_bytes; + old_free_ptr = (lispobj)fixedobj_free_pointer; + free_ptr = FIXEDOBJ_SPACE_START + fixedobj_tempspace.n_bytes; bzero((char*)free_ptr, old_free_ptr - free_ptr); - immobile_fixedobj_free_pointer = (lispobj*)free_ptr; + fixedobj_free_pointer = (lispobj*)free_ptr; #endif // Variable-size object pages. - memcpy((char*)IMMOBILE_VARYOBJ_SUBSPACE_START, + memcpy((char*)VARYOBJ_SPACE_START, varyobj_tempspace.start, varyobj_tempspace.n_bytes); // Zero-fill the unused remainder - old_free_ptr = (lispobj)immobile_space_free_pointer; - free_ptr = IMMOBILE_VARYOBJ_SUBSPACE_START + varyobj_tempspace.n_bytes; + old_free_ptr = (lispobj)varyobj_free_pointer; + free_ptr = VARYOBJ_SPACE_START + varyobj_tempspace.n_bytes; bzero((char*)free_ptr, old_free_ptr - free_ptr); - immobile_space_free_pointer = (lispobj*)free_ptr; + varyobj_free_pointer = (lispobj*)free_ptr; free(components); page_attributes_valid = 0; #if 0 @@ -2246,7 +2246,7 @@ void defrag_immobile_space(int* components, boolean verbose) void verify_immobile_page_protection(int keep_gen, int new_gen) { low_page_index_t page; - lispobj* end = immobile_space_free_pointer; + lispobj* end = varyobj_free_pointer; low_page_index_t end_page = find_immobile_page_index((char*)end-1); lispobj* obj; @@ -2260,7 +2260,7 @@ void verify_immobile_page_protection(int keep_gen, int new_gen) // FIXME: It is is supposed to work to scan past the free pointer // on the last page, but the allocator needs to plop an array header there, // and sometimes it doesn't. - lispobj* varyobj_free_ptr = immobile_space_free_pointer; + lispobj* varyobj_free_ptr = varyobj_free_pointer; if (page_end > varyobj_free_ptr) page_end = varyobj_free_ptr; for ( ; obj < page_end ; obj += sizetab[widetag_of(*obj)](obj) ) { if (!filler_obj_p(obj) @@ -2299,7 +2299,7 @@ void fixup_immobile_refs(lispobj (*fixup_lispobj)(lispobj), UNALIGNED_STORE32(fixup_where, fixed); } else { lispobj* header_addr; - if (ptr < IMMOBILE_VARYOBJ_SUBSPACE_START) { + if (ptr < VARYOBJ_SPACE_START) { // It's an absolute interior pointer to a symbol value slot // or an fdefn raw address slot. header_addr = search_immobile_space((void*)ptr); @@ -2359,8 +2359,10 @@ void check_fixedobj_page(int page) genmask = 0; if (obj_size == 0) { gc_assert(!fixedobj_pages[page].gens); - for (i=0; i= (lispobj*)low_page_address(page+1)) { scan_start_obj = low_page_address(page+1); break; @@ -2515,7 +2517,7 @@ void check_varyobj_pages() // Skip the first object if it doesn't start on this page. if (obj < (lispobj*)low_page_address(page)) obj += n_words; lispobj* limit = (lispobj*)low_page_address(page) + WORDS_PER_PAGE; - lispobj* freeptr = immobile_space_free_pointer; + lispobj* freeptr = varyobj_free_pointer; if (limit > freeptr) limit = freeptr; int mask = 0; for ( ; obj < limit ; obj += sizetab[widetag_of(*obj)](obj) ) { diff --git a/src/runtime/os.h b/src/runtime/os.h index 0af9715f9..9444c0daa 100644 --- a/src/runtime/os.h +++ b/src/runtime/os.h @@ -24,14 +24,14 @@ extern uword_t DYNAMIC_SPACE_START; #endif #if defined(LISP_FEATURE_RELOCATABLE_HEAP) && defined(LISP_FEATURE_IMMOBILE_SPACE) -extern uword_t IMMOBILE_SPACE_START, IMMOBILE_VARYOBJ_SUBSPACE_START; -#define IMMOBILE_SPACE_END (IMMOBILE_SPACE_START+IMMOBILE_SPACE_SIZE) +extern uword_t FIXEDOBJ_SPACE_START, VARYOBJ_SPACE_START; #endif #ifdef LISP_FEATURE_IMMOBILE_SPACE +#define IMMOBILE_SPACE_TOTAL_SIZE (FIXEDOBJ_SPACE_SIZE+VARYOBJ_SPACE_SIZE) static inline boolean immobile_space_p(lispobj obj) { - return IMMOBILE_SPACE_START <= obj && obj < IMMOBILE_SPACE_END; + return FIXEDOBJ_SPACE_START <= obj && obj < (VARYOBJ_SPACE_START+VARYOBJ_SPACE_SIZE); } #else static inline boolean immobile_space_p(lispobj obj) { return 0; } diff --git a/src/runtime/parse.c b/src/runtime/parse.c index b0eea1bb6..d8c1b291d 100644 --- a/src/runtime/parse.c +++ b/src/runtime/parse.c @@ -215,8 +215,8 @@ static lispobj lookup_symbol(char *name) #ifdef LISP_FEATURE_IMMOBILE_SPACE /* Search immobile space. */ if ((headerptr = search_for_symbol(name, - IMMOBILE_SPACE_START, - (uword_t)immobile_fixedobj_free_pointer))) + FIXEDOBJ_SPACE_START, + (uword_t)fixedobj_free_pointer))) return make_lispobj(headerptr, OTHER_POINTER_LOWTAG); #endif diff --git a/src/runtime/save.c b/src/runtime/save.c index b2af93035..23cceb300 100644 --- a/src/runtime/save.c +++ b/src/runtime/save.c @@ -326,14 +326,14 @@ save_to_filehandle(FILE *file, char *filename, lispobj init_function, #ifdef LISP_FEATURE_IMMOBILE_SPACE output_space(file, IMMOBILE_FIXEDOBJ_CORE_SPACE_ID, - (lispobj *)IMMOBILE_SPACE_START, - immobile_fixedobj_free_pointer, + (lispobj *)FIXEDOBJ_SPACE_START, + fixedobj_free_pointer, core_start_pos, core_compression_level); output_space(file, IMMOBILE_VARYOBJ_CORE_SPACE_ID, - (lispobj *)IMMOBILE_VARYOBJ_SUBSPACE_START, - immobile_space_free_pointer, + (lispobj *)VARYOBJ_SPACE_START, + varyobj_free_pointer, core_start_pos, core_compression_level); #endif diff --git a/src/runtime/traceroot.c b/src/runtime/traceroot.c index 0f1ddf25f..b6ea325b2 100644 --- a/src/runtime/traceroot.c +++ b/src/runtime/traceroot.c @@ -192,8 +192,8 @@ static lispobj* find_sym_by_tls_index(lispobj tls_index) lispobj* where = 0; lispobj* end = 0; #ifdef LISP_FEATURE_IMMOBILE_SPACE - where = (lispobj*)IMMOBILE_SPACE_START; - end = immobile_fixedobj_free_pointer; + where = (lispobj*)FIXEDOBJ_SPACE_START; + end = fixedobj_free_pointer; #endif while (1) { while (where < end) { @@ -778,9 +778,8 @@ static void scan_spaces(struct scan_state* ss) { build_refs((lispobj*)STATIC_SPACE_START, static_space_free_pointer, ss); #ifdef LISP_FEATURE_IMMOBILE_SPACE - build_refs((lispobj*)IMMOBILE_SPACE_START, immobile_fixedobj_free_pointer, ss); - build_refs((lispobj*)IMMOBILE_VARYOBJ_SUBSPACE_START, - immobile_space_free_pointer, ss); + build_refs((lispobj*)FIXEDOBJ_SPACE_START, fixedobj_free_pointer, ss); + build_refs((lispobj*)VARYOBJ_SPACE_START, varyobj_free_pointer, ss); #endif walk_generation((uword_t(*)(lispobj*,lispobj*,uword_t))build_refs, -1, (uword_t)ss); diff --git a/src/runtime/validate.c b/src/runtime/validate.c index 1644493b2..8e0235f65 100644 --- a/src/runtime/validate.c +++ b/src/runtime/validate.c @@ -28,7 +28,7 @@ uword_t DYNAMIC_SPACE_START; #endif #if defined(LISP_FEATURE_RELOCATABLE_HEAP) && defined(LISP_FEATURE_IMMOBILE_SPACE) -uword_t IMMOBILE_SPACE_START, IMMOBILE_VARYOBJ_SUBSPACE_START; +uword_t FIXEDOBJ_SPACE_START, VARYOBJ_SPACE_START; #endif static void diff --git a/tests/gc.impure.lisp b/tests/gc.impure.lisp index 6c5e65300..15542985f 100644 --- a/tests/gc.impure.lisp +++ b/tests/gc.impure.lisp @@ -204,3 +204,11 @@ (with-test (:name :code/data-separation :skipped-on '(:not :gencgc)) (ensure-code/data-separation)) + +#+immobile-space +(with-test (:name :immobile-space-addr-p) + ;; Upper bound should be exclusive + (assert (not (sb-kernel:immobile-space-addr-p + (+ sb-vm:fixedobj-space-start + sb-vm:fixedobj-space-size + sb-vm:varyobj-space-size))))) -- 2.11.4.GIT