Reduce memory use immediately after boot.

src/store-buffer.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 478 matching lines @@
 
 
 void StoreBuffer::FindPointersToNewSpaceInMapsRegion(
     Address start,
     Address end,
     ObjectSlotCallback slot_callback) {
   Address map_aligned_start = MapStartAlign(start);
   Address map_aligned_end   = MapEndAlign(end);
 
   ASSERT(map_aligned_start == start);
-  ASSERT(map_aligned_end == end);
 
   FindPointersToNewSpaceInMaps(map_aligned_start,
                                map_aligned_end,
                                slot_callback);
 }
 
 
 // This function iterates over all the pointers in a paged space in the heap,
 // looking for pointers into new space.  Within the pages there may be dead
 // objects that have not been overwritten by free spaces or fillers because of
 // lazy sweeping.  These dead objects may not contain pointers to new space.
 // The garbage areas that have been swept properly (these will normally be the
 // large ones) will be marked with free space and filler map words.  In
 // addition any area that has never been used at all for object allocation must
 // be marked with a free space or filler.  Because the free space and filler
 // maps do not move we can always recognize these even after a compaction.
 // Normal objects like FixedArrays and JSObjects should not contain references
 // to these maps.  The special garbage section (see comment in spaces.h) is
 // skipped since it can contain absolutely anything.  Any objects that are
 // allocated during iteration may or may not be visited by the iteration, but
 // they will not be partially visited.
 void StoreBuffer::FindPointersToNewSpaceOnPage(
     PagedSpace* space,
     Page* page,
     RegionCallback region_callback,
     ObjectSlotCallback slot_callback) {
   Address visitable_start = page->ObjectAreaStart();
-  Address end_of_page = page->ObjectAreaEnd();
 
   Address visitable_end = visitable_start;
 
   Object* free_space_map = heap_->free_space_map();
   Object* two_pointer_filler_map = heap_->two_pointer_filler_map();
 
-  while (visitable_end < end_of_page) {
-    Object* o = *reinterpret_cast<Object**>(visitable_end);
-    // Skip fillers but not things that look like fillers in the special
-    // garbage section which can contain anything.
-    if (o == free_space_map ||
-        o == two_pointer_filler_map ||
-        (visitable_end == space->top() && visitable_end != space->limit())) {
-      if (visitable_start != visitable_end) {
-        // After calling this the special garbage section may have moved.
-        (this->*region_callback)(visitable_start,
-                                 visitable_end,
-                                 slot_callback);
-        if (visitable_end >= space->top() && visitable_end < space->limit()) {
-          visitable_end = space->limit();
-          visitable_start = visitable_end;
-          continue;
+  while (true) {  // While the page grows (doesn't normally happen).
+    Address end_of_page = page->ObjectAreaEnd();
+    while (visitable_end < end_of_page) {
+      Object* o = *reinterpret_cast<Object**>(visitable_end);
+      // Skip fillers but not things that look like fillers in the special
+      // garbage section which can contain anything.
+      if (o == free_space_map ||
+          o == two_pointer_filler_map ||
+          (visitable_end == space->top() && visitable_end != space->limit())) {
+        if (visitable_start != visitable_end) {
+          // After calling this the special garbage section may have moved.
+          (this->*region_callback)(visitable_start,
+                                   visitable_end,
+                                   slot_callback);
+          if (visitable_end >= space->top() && visitable_end < space->limit()) {
+            visitable_end = space->limit();
+            visitable_start = visitable_end;
+            continue;
+          }
         }
+        if (visitable_end == space->top() && visitable_end != space->limit()) {
+          visitable_start = visitable_end = space->limit();
+        } else {
+          // At this point we are either at the start of a filler or we are at
+          // the point where the space->top() used to be before the
+          // visit_pointer_region call above.  Either way we can skip the
+          // object at the current spot:  We don't promise to visit objects
+          // allocated during heap traversal, and if space->top() moved then it
+          // must be because an object was allocated at this point.
+          visitable_start =
+              visitable_end + HeapObject::FromAddress(visitable_end)->Size();
+          intptr_t start_integer = reinterpret_cast<intptr_t>(visitable_start);
+          if ((start_integer & (Page::kGrowthUnit - 1)) == 0 &&

[Erik Corry, 2012/01/31 10:44:44]

This 'if' and its contents are new.

+              visitable_start != page->ObjectAreaEnd()) {
+            // Sometimes there is a little free-space object left at what used
+            // to be the end of the page.  Due to object alignment restrictions
+            // (this is primarily an issue for maps on 64 bit) they never
+            // contain pointers.  We skip them because the scanning logic on
+            // pages in FixedSpace spaces does not scan partial objects.
+            visitable_start = page->RoundUpToObjectAlignment(visitable_start);
+          }
+          visitable_end = visitable_start;
+        }
+      } else {
+        ASSERT(o != free_space_map);
+        ASSERT(o != two_pointer_filler_map);
+        ASSERT(visitable_end < space->top() || visitable_end >= space->limit());
+        visitable_end += kPointerSize;
       }
-      if (visitable_end == space->top() && visitable_end != space->limit()) {
-        visitable_start = visitable_end = space->limit();
-      } else {
-        // At this point we are either at the start of a filler or we are at
-        // the point where the space->top() used to be before the
-        // visit_pointer_region call above.  Either way we can skip the
-        // object at the current spot:  We don't promise to visit objects
-        // allocated during heap traversal, and if space->top() moved then it
-        // must be because an object was allocated at this point.
-        visitable_start =
-            visitable_end + HeapObject::FromAddress(visitable_end)->Size();
-        visitable_end = visitable_start;
-      }
-    } else {
-      ASSERT(o != free_space_map);
-      ASSERT(o != two_pointer_filler_map);
-      ASSERT(visitable_end < space->top() || visitable_end >= space->limit());
-      visitable_end += kPointerSize;
     }
+    ASSERT(visitable_end >= end_of_page);
+    // If the page did not grow we are done.
+    if (end_of_page == page->ObjectAreaEnd()) break;
   }
-  ASSERT(visitable_end == end_of_page);
+  ASSERT(visitable_end == page->ObjectAreaEnd());
   if (visitable_start != visitable_end) {
     (this->*region_callback)(visitable_start,
                              visitable_end,
                              slot_callback);
   }
 }
 
 
 void StoreBuffer::IteratePointersInStoreBuffer(
     ObjectSlotCallback slot_callback) {
@@ skipping 127 matching lines @@
   heap_->isolate()->counters()->store_buffer_compactions()->Increment();
   CheckForFullBuffer();
 }
 
 
 void StoreBuffer::CheckForFullBuffer() {
   EnsureSpace(kStoreBufferSize * 2);
 }
 
 } }  // namespace v8::internal