0.9.9.8:
[sbcl.git] / src / runtime / gencgc.c
index d39bf9b..85251a4 100644 (file)
@@ -70,22 +70,6 @@ enum {
  * that don't have pointers to younger generations? */
 boolean enable_page_protection = 1;
 
-/* Should we unmap a page and re-mmap it to have it zero filled? */
-#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(__sun)
-/* comment from cmucl-2.4.8: This can waste a lot of swap on FreeBSD
- * so don't unmap there.
- *
- * The CMU CL comment didn't specify a version, but was probably an
- * old version of FreeBSD (pre-4.0), so this might no longer be true.
- * OTOH, if it is true, this behavior might exist on OpenBSD too, so
- * for now we don't unmap there either. -- WHN 2001-04-07 */
-/* Apparently this flag is required to be 0 for SunOS/x86, as there
- * are reports of heap corruption otherwise. */
-boolean gencgc_unmap_zero = 0;
-#else
-boolean gencgc_unmap_zero = 1;
-#endif
-
 /* the minimum size (in bytes) for a large object*/
 unsigned long large_object_size = 4 * PAGE_BYTES;
 
@@ -139,6 +123,13 @@ boolean gencgc_zero_check_during_free_heap = 0;
  * contained a pagetable entry).
  */
 boolean gencgc_partial_pickup = 0;
+
+/* If defined, free pages are read-protected to ensure that nothing
+ * accesses them.
+ */
+
+/* #define READ_PROTECT_FREE_PAGES */
+
 \f
 /*
  * GC structures and variables
@@ -429,9 +420,63 @@ print_generation_stats(int verbose) /* FIXME: should take FILE argument */
     fpu_restore(fpu_state);
 }
 \f
-/*
- * allocation routines
+
+void fast_bzero(void*, size_t); /* in <arch>-assem.S */
+
+/* Zero the pages from START to END (inclusive), but use mmap/munmap instead
+ * if zeroing it ourselves, i.e. in practice give the memory back to the
+ * OS. Generally done after a large GC.
  */
+void zero_pages_with_mmap(page_index_t start, page_index_t end) {
+    int i;
+    void *addr = (void *) page_address(start), *new_addr;
+    size_t length = PAGE_BYTES*(1+end-start);
+
+    if (start > end)
+      return;
+
+    os_invalidate(addr, length);
+    new_addr = os_validate(addr, length);
+    if (new_addr == NULL || new_addr != addr) {
+        lose("remap_free_pages: page moved, 0x%08x ==> 0x%08x", start, new_addr);
+    }
+
+    for (i = start; i <= end; i++) {
+        page_table[i].need_to_zero = 0;
+    }
+}
+
+/* Zero the pages from START to END (inclusive). Generally done just after
+ * a new region has been allocated.
+ */
+static void
+zero_pages(page_index_t start, page_index_t end) {
+    if (start > end)
+      return;
+
+    fast_bzero(page_address(start), PAGE_BYTES*(1+end-start));
+}
+
+/* Zero the pages from START to END (inclusive), except for those
+ * pages that are known to already zeroed. Mark all pages in the
+ * ranges as non-zeroed.
+ */
+static void
+zero_dirty_pages(page_index_t start, page_index_t end) {
+    page_index_t i;
+
+    for (i = start; i <= end; i++) {
+        if (page_table[i].need_to_zero == 1) {
+            zero_pages(start, end);
+            break;
+        }
+    }
+
+    for (i = start; i <= end; i++) {
+        page_table[i].need_to_zero = 1;
+    }
+}
+
 
 /*
  * To support quick and inline allocation, regions of memory can be
@@ -602,10 +647,26 @@ gc_alloc_new_region(long nbytes, int unboxed, struct alloc_region *alloc_region)
                  * (long) in code like this, so that it is less likely to
                  * break randomly when running on a machine with different
                  * word sizes. -- WHN 19991129 */
-                lose("The new region at %x is not zero.", p);
+                lose("The new region at %x is not zero.\n", p);
             }
         }
     }
+
+#ifdef READ_PROTECT_FREE_PAGES
+    os_protect(page_address(first_page),
+               PAGE_BYTES*(1+last_page-first_page),
+               OS_VM_PROT_ALL);
+#endif
+
+    /* If the first page was only partial, don't check whether it's
+     * zeroed (it won't be) and don't zero it (since the parts that
+     * we're interested in are guaranteed to be zeroed).
+     */
+    if (page_table[first_page].bytes_used) {
+        first_page++;
+    }
+
+    zero_dirty_pages(first_page, last_page);
 }
 
 /* If the record_new_objects flag is 2 then all new regions created
@@ -952,7 +1013,15 @@ gc_alloc_large(long nbytes, int unboxed, struct alloc_region *alloc_region)
     }
     thread_mutex_unlock(&free_pages_lock);
 
-    return((void *)(page_address(first_page)+orig_first_page_bytes_used));
+#ifdef READ_PROTECT_FREE_PAGES
+    os_protect(page_address(first_page),
+               PAGE_BYTES*(1+last_page-first_page),
+               OS_VM_PROT_ALL);
+#endif
+
+    zero_dirty_pages(first_page, last_page);
+
+    return page_address(first_page);
 }
 
 static page_index_t gencgc_alloc_start_page = -1;
@@ -1004,7 +1073,7 @@ gc_find_freeish_pages(page_index_t *restart_page_ptr, long nbytes, int unboxed)
                     "Argh! gc_find_free_space failed (first_page), nbytes=%ld.\n",
                     nbytes);
             print_generation_stats(1);
-            lose(NULL);
+            lose("\n");
         }
 
         gc_assert(page_table[first_page].write_protected == 0);
@@ -1035,7 +1104,7 @@ gc_find_freeish_pages(page_index_t *restart_page_ptr, long nbytes, int unboxed)
                 "Argh! gc_find_freeish_pages failed (restart_page), nbytes=%ld.\n",
                 nbytes);
         print_generation_stats(1);
-        lose(NULL);
+        lose("\n");
     }
     *restart_page_ptr=first_page;
 
@@ -1768,12 +1837,12 @@ scav_vector(lispobj *where, lispobj object)
     /* Scavenge element 0, which may be a hash-table structure. */
     scavenge(where+2, 1);
     if (!is_lisp_pointer(where[2])) {
-        lose("no pointer at %x in hash table", where[2]);
+        lose("no pointer at %x in hash table\n", where[2]);
     }
     hash_table = (struct hash_table *)native_pointer(where[2]);
     /*FSHOW((stderr,"/hash_table = %x\n", hash_table));*/
     if (widetag_of(hash_table->header) != INSTANCE_HEADER_WIDETAG) {
-        lose("hash table not instance (%x at %x)",
+        lose("hash table not instance (%x at %x)\n",
              hash_table->header,
              hash_table);
     }
@@ -1782,13 +1851,13 @@ scav_vector(lispobj *where, lispobj object)
      * the hash table code reserves for marking empty slots. */
     scavenge(where+3, 1);
     if (!is_lisp_pointer(where[3])) {
-        lose("not empty-hash-table-slot symbol pointer: %x", where[3]);
+        lose("not empty-hash-table-slot symbol pointer: %x\n", where[3]);
     }
     empty_symbol = where[3];
     /* fprintf(stderr,"* empty_symbol = %x\n", empty_symbol);*/
     if (widetag_of(*(lispobj *)native_pointer(empty_symbol)) !=
         SYMBOL_HEADER_WIDETAG) {
-        lose("not a symbol where empty-hash-table-slot symbol expected: %x",
+        lose("not a symbol where empty-hash-table-slot symbol expected: %x\n",
              *(lispobj *)native_pointer(empty_symbol));
     }
 
@@ -1799,7 +1868,7 @@ scav_vector(lispobj *where, lispobj object)
 
     /* Cross-check the kv_vector. */
     if (where != (lispobj *)native_pointer(hash_table->table)) {
-        lose("hash_table table!=this table %x", hash_table->table);
+        lose("hash_table table!=this table %x\n", hash_table->table);
     }
 
     /* WEAK-P */
@@ -1818,7 +1887,7 @@ scav_vector(lispobj *where, lispobj object)
             length = fixnum_value(((lispobj *)native_pointer(index_vector_obj))[1]);
             /*FSHOW((stderr, "/length = %d\n", length));*/
         } else {
-            lose("invalid index_vector %x", index_vector_obj);
+            lose("invalid index_vector %x\n", index_vector_obj);
         }
     }
 
@@ -1834,7 +1903,7 @@ scav_vector(lispobj *where, lispobj object)
             next_vector_length = fixnum_value(((lispobj *)native_pointer(next_vector_obj))[1]);
             /*FSHOW((stderr, "/next_vector_length = %d\n", next_vector_length));*/
         } else {
-            lose("invalid next_vector %x", next_vector_obj);
+            lose("invalid next_vector %x\n", next_vector_obj);
         }
     }
 
@@ -2754,15 +2823,15 @@ scavenge_generations(generation_index_t from, generation_index_t to)
                         num_wp += update_page_write_prot(j);
                     }
                 }
+                if ((gencgc_verbose > 1) && (num_wp != 0)) {
+                    FSHOW((stderr,
+                           "/write protected %d pages within generation %d\n",
+                           num_wp, generation));
+                }
             }
             i = last_page;
         }
     }
-    if ((gencgc_verbose > 1) && (num_wp != 0)) {
-        FSHOW((stderr,
-               "/write protected %d pages within generation %d\n",
-               num_wp, generation));
-    }
 
 #if SC_GEN_CK
     /* Check that none of the write_protected pages in this generation
@@ -2778,7 +2847,7 @@ scavenge_generations(generation_index_t from, generation_index_t to)
                     page_table[i].bytes_used,
                     page_table[i].first_object_offset,
                     page_table[i].dont_move));
-            lose("write to protected page %d in scavenge_generation()", i);
+            lose("write to protected page %d in scavenge_generation()\n", i);
         }
     }
 #endif
@@ -2994,7 +3063,7 @@ scavenge_newspace_generation(generation_index_t generation)
             && (page_table[i].gen == generation)
             && (page_table[i].write_protected_cleared != 0)
             && (page_table[i].dont_move == 0)) {
-            lose("write protected page %d written to in scavenge_newspace_generation\ngeneration=%d dont_move=%d",
+            lose("write protected page %d written to in scavenge_newspace_generation\ngeneration=%d dont_move=%d\n",
                  i, generation, page_table[i].dont_move);
         }
     }
@@ -3080,31 +3149,12 @@ free_oldspace(void)
                && (page_table[last_page].bytes_used != 0)
                && (page_table[last_page].gen == from_space));
 
-        /* Zero pages from first_page to (last_page-1).
-         *
-         * FIXME: Why not use os_zero(..) function instead of
-         * hand-coding this again? (Check other gencgc_unmap_zero
-         * stuff too. */
-        if (gencgc_unmap_zero) {
-            void *page_start, *addr;
-
-            page_start = (void *)page_address(first_page);
-
-            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) {
-                lose("free_oldspace: page moved, 0x%08x ==> 0x%08x",page_start,
-                     addr);
-            }
-        } else {
-            long *page_start;
-
-            page_start = (long *)page_address(first_page);
-            memset(page_start, 0,PAGE_BYTES*(last_page-first_page));
-        }
-
+#ifdef READ_PROTECT_FREE_PAGES
+        os_protect(page_address(first_page),
+                   PAGE_BYTES*(last_page-first_page),
+                   OS_VM_PROT_NONE);
+#endif
         first_page = last_page;
-
     } while (first_page < last_free_page);
 
     bytes_allocated -= bytes_freed;
@@ -3170,15 +3220,15 @@ verify_space(lispobj *start, size_t words)
                  * page. XX Could check the offset too. */
                 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);
+                    lose ("Ptr %x @ %x sees free page.\n", thing, start);
                 /* Check that it doesn't point to a forwarding pointer! */
                 if (*((lispobj *)native_pointer(thing)) == 0x01) {
-                    lose("Ptr %x @ %x sees forwarding ptr.", thing, start);
+                    lose("Ptr %x @ %x sees forwarding ptr.\n", thing, start);
                 }
                 /* Check that its not in the RO space as it would then be a
                  * pointer from the RO to the dynamic space. */
                 if (is_in_readonly_space) {
-                    lose("ptr to dynamic space %x from RO space %x",
+                    lose("ptr to dynamic space %x from RO space %x\n",
                          thing, start);
                 }
                 /* Does it point to a plausible object? This check slows
@@ -3192,14 +3242,14 @@ verify_space(lispobj *start, size_t words)
                  * dynamically. */
                 /*
                 if (!possibly_valid_dynamic_space_pointer((lispobj *)thing)) {
-                    lose("ptr %x to invalid object %x", thing, start);
+                    lose("ptr %x to invalid object %x\n", thing, start);
                 }
                 */
             } else {
                 /* Verify that it points to another valid space. */
                 if (!to_readonly_space && !to_static_space
                     && (thing != (unsigned long)&undefined_tramp)) {
-                    lose("Ptr %x @ %x sees junk.", thing, start);
+                    lose("Ptr %x @ %x sees junk.\n", thing, start);
                 }
             }
         } else {
@@ -3457,7 +3507,7 @@ verify_zero_fill(void)
             long i;
             for (i = 0; i < size; i++) {
                 if (start_addr[i] != 0) {
-                    lose("free page not zero at %x", start_addr + i);
+                    lose("free page not zero at %x\n", start_addr + i);
                 }
             }
         } else {
@@ -3469,7 +3519,7 @@ verify_zero_fill(void)
                 long i;
                 for (i = 0; i < size; i++) {
                     if (start_addr[i] != 0) {
-                        lose("free region not zero at %x", start_addr + i);
+                        lose("free region not zero at %x\n", start_addr + i);
                     }
                 }
             }
@@ -3747,7 +3797,7 @@ garbage_collect_generation(generation_index_t generation, int raise)
         bytes_allocated = bytes_allocated - old_bytes_allocated;
 
         if (bytes_allocated != 0) {
-            lose("Rescan of new_space allocated %d more bytes.",
+            lose("Rescan of new_space allocated %d more bytes.\n",
                  bytes_allocated);
         }
     }
@@ -3816,6 +3866,32 @@ update_dynamic_space_free_pointer(void)
     return 0; /* dummy value: return something ... */
 }
 
+static void
+remap_free_pages (page_index_t from, page_index_t to)
+{
+    page_index_t first_page, last_page;
+
+    for (first_page = from; first_page <= to; first_page++) {
+        if (page_table[first_page].allocated != FREE_PAGE_FLAG ||
+            page_table[first_page].need_to_zero == 0) {
+            continue;
+        }
+
+        last_page = first_page + 1;
+        while (page_table[last_page].allocated == FREE_PAGE_FLAG &&
+               last_page < to &&
+               page_table[last_page].need_to_zero == 1) {
+            last_page++;
+        }
+
+        zero_pages_with_mmap(first_page, last_page-1);
+
+        first_page = last_page;
+    }
+}
+
+generation_index_t small_generation_limit = 1;
+
 /* GC all generations newer than last_gen, raising the objects in each
  * to the next older generation - we finish when all generations below
  * last_gen are empty.  Then if last_gen is due for a GC, or if
@@ -3824,13 +3900,15 @@ update_dynamic_space_free_pointer(void)
  *
  * We stop collecting at gencgc_oldest_gen_to_gc, even if this is less than
  * last_gen (oh, and note that by default it is NUM_GENERATIONS-1) */
-
 void
 collect_garbage(generation_index_t last_gen)
 {
     generation_index_t gen = 0, i;
     int raise;
     int gen_to_wp;
+    /* The largest value of last_free_page seen since the time
+     * remap_free_pages was called. */
+    static page_index_t high_water_mark = 0;
 
     FSHOW((stderr, "/entering collect_garbage(%d)\n", last_gen));
 
@@ -3921,7 +3999,7 @@ collect_garbage(generation_index_t last_gen)
         /* Check that they are all empty. */
         for (i = 0; i < gen_to_wp; i++) {
             if (generations[i].bytes_allocated)
-                lose("trying to write-protect gen. %d when gen. %d nonempty",
+                lose("trying to write-protect gen. %d when gen. %d nonempty\n",
                      gen_to_wp, i);
         }
         write_protect_generation_pages(gen_to_wp);
@@ -3932,11 +4010,25 @@ collect_garbage(generation_index_t last_gen)
     gc_assert((boxed_region.free_pointer - boxed_region.start_addr) == 0);
     gc_alloc_generation = 0;
 
+    /* Save the high-water mark before updating last_free_page */
+    if (last_free_page > high_water_mark)
+        high_water_mark = last_free_page;
     update_dynamic_space_free_pointer();
     auto_gc_trigger = bytes_allocated + bytes_consed_between_gcs;
     if(gencgc_verbose)
         fprintf(stderr,"Next gc when %ld bytes have been consed\n",
                 auto_gc_trigger);
+
+    /* If we did a big GC (arbitrarily defined as gen > 1), release memory
+     * back to the OS.
+     */
+    if (gen > small_generation_limit) {
+        if (last_free_page > high_water_mark)
+            high_water_mark = last_free_page;
+        remap_free_pages(0, high_water_mark);
+        high_water_mark = 0;
+    }
+
     SHOW("returning from collect_garbage");
 }
 
@@ -3966,6 +4058,7 @@ gc_free_heap(void)
             page_table[page].allocated = FREE_PAGE_FLAG;
             page_table[page].bytes_used = 0;
 
+#ifndef LISP_FEATURE_WIN32 /* Pages already zeroed on win32? Not sure about this change. */
             /* Zero the page. */
             page_start = (void *)page_address(page);
 
@@ -3976,10 +4069,13 @@ gc_free_heap(void)
             os_invalidate(page_start,PAGE_BYTES);
             addr = os_validate(page_start,PAGE_BYTES);
             if (addr == NULL || addr != page_start) {
-                lose("gc_free_heap: page moved, 0x%08x ==> 0x%08x",
+                lose("gc_free_heap: page moved, 0x%08x ==> 0x%08x\n",
                      page_start,
                      addr);
             }
+#else
+            page_table[page].write_protected = 0;
+#endif
         } else if (gencgc_zero_check_during_free_heap) {
             /* Double-check that the page is zero filled. */
             long *page_start;
@@ -3989,7 +4085,7 @@ gc_free_heap(void)
             page_start = (long *)page_address(page);
             for (i=0; i<1024; i++) {
                 if (page_start[i] != 0) {
-                    lose("free region not zero at %x", page_start + i);
+                    lose("free region not zero at %x\n", page_start + i);
                 }
             }
         }
@@ -4101,6 +4197,7 @@ gencgc_pickup_dynamic(void)
         page_table[page].write_protected = 0;
         page_table[page].write_protected_cleared = 0;
         page_table[page].dont_move = 0;
+        page_table[page].need_to_zero = 1;
 
         if (!gencgc_partial_pickup) {
             first=gc_search_space(prev,(ptr+2)-prev,ptr);
@@ -4256,7 +4353,7 @@ gencgc_handle_wp_violation(void* fault_addr)
              * does this test after the first one has already set wp=0
              */
             if(page_table[page_index].write_protected_cleared != 1)
-                lose("fault in heap page not marked as write-protected");
+                lose("fault in heap page not marked as write-protected\n");
         }
         /* Don't worry, we can handle it. */
         return 1;
@@ -4290,6 +4387,23 @@ gc_set_region_empty(struct alloc_region *region)
     region->end_addr = page_address(0);
 }
 
+static void
+zero_all_free_pages()
+{
+    page_index_t i;
+
+    for (i = 0; i < last_free_page; i++) {
+        if (page_table[i].allocated == FREE_PAGE_FLAG) {
+#ifdef READ_PROTECT_FREE_PAGES
+            os_protect(page_address(i),
+                       PAGE_BYTES,
+                       OS_VM_PROT_ALL);
+#endif
+            zero_pages(i, i);
+        }
+    }
+}
+
 /* Things to do before doing a final GC before saving a core (without
  * purify).
  *
@@ -4344,10 +4458,12 @@ gc_and_save(char *filename)
     gencgc_alloc_start_page = -1;
     collect_garbage(HIGHEST_NORMAL_GENERATION+1);
 
+    /* The dumper doesn't know that pages need to be zeroed before use. */
+    zero_all_free_pages();
     save_to_filehandle(file, filename, SymbolValue(RESTART_LISP_FUNCTION,0));
     /* Oops. Save still managed to fail. Since we've mangled the stack
      * beyond hope, there's not much we can do.
      * (beyond FUNCALLing RESTART_LISP_FUNCTION, but I suspect that's
      * going to be rather unsatisfactory too... */
-    lose("Attempt to save core after non-conservative GC failed.");
+    lose("Attempt to save core after non-conservative GC failed.\n");
 }