Fix new space shrinking to compute correct capacity.

src/spaces.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 906 matching lines @@
   chunk_size_ = 0;
 }
 
 
 void NewSpace::Flip() {
   SemiSpace::Swap(&from_space_, &to_space_);
 }
 
 
 void NewSpace::Grow() {
+  // Double the semispace size but only up to maximum capacity.
   ASSERT(Capacity() < MaximumCapacity());
-  if (to_space_.Grow()) {
+  ASSERT(static_cast<size_t>(Page::kPageSize) > OS::AllocateAlignment());

[Vyacheslav Egorov (Chromium), 2011/09/20 14:26:40]

I don't think we really need this assert here. There are checks in routines that
deal with virtual memory.

[Michael Starzinger, 2011/09/20 15:29:03]

Done.

+  int new_capacity = Min(MaximumCapacity(), 2 * static_cast<int>(Capacity()));

[Vyacheslav Egorov (Chromium), 2011/09/20 14:26:40]

We should ensure that MaxCapacity & Capacity is _always_ kPageSize aligned. 

That would clean the code (e.g. Rounding would not be needed here).

And I really would expect that capacities are always aligned as we are managing
new space with kPageSize granularity.

[Michael Starzinger, 2011/09/20 15:29:03]

Done. I just checked that it is only modified in a way that keeps it aligned to
kPageSize. The assertion which checks that is exactly the one being triggered
(in SemiSpace::ShrinkTo and SemiSpace::GrowTo).

+  int rounded_new_capacity = RoundUp(new_capacity, Page::kPageSize);
+  if (to_space_.GrowTo(rounded_new_capacity)) {
     // Only grow from space if we managed to grow to-space.
-    if (!from_space_.Grow()) {
+    if (!from_space_.GrowTo(rounded_new_capacity)) {
       // If we managed to grow to-space but couldn't grow from-space,
       // attempt to shrink to-space.
       if (!to_space_.ShrinkTo(from_space_.Capacity())) {
         // We are in an inconsistent state because we could not
         // commit/uncommit memory from new space.
         V8::FatalProcessOutOfMemory("Failed to grow new space.");
       }
     }
   }
   ASSERT_SEMISPACE_ALLOCATION_INFO(allocation_info_, to_space_);
 }
 
 
 void NewSpace::Shrink() {
+  ASSERT(static_cast<size_t>(Page::kPageSize) > OS::AllocateAlignment());

[Vyacheslav Egorov (Chromium), 2011/09/20 14:26:40]

I don't think we really need this assert here. There are checks in routines that
deal with virtual memory. 

[Michael Starzinger, 2011/09/20 15:29:03]

Done.

   int new_capacity = Max(InitialCapacity(), 2 * SizeAsInt());
-  int rounded_new_capacity =
-      RoundUp(new_capacity, static_cast<int>(OS::AllocateAlignment()));
+  int rounded_new_capacity = RoundUp(new_capacity, Page::kPageSize);
   if (rounded_new_capacity < Capacity() &&
       to_space_.ShrinkTo(rounded_new_capacity))  {
     // Only shrink from-space if we managed to shrink to-space.
     from_space_.Reset();
     if (!from_space_.ShrinkTo(rounded_new_capacity)) {
       // If we managed to shrink to-space but couldn't shrink from
       // space, attempt to grow to-space again.
       if (!to_space_.GrowTo(from_space_.Capacity())) {
         // We are in an inconsistent state because we could not
         // commit/uncommit memory from new space.
@@ skipping 179 matching lines @@
     return false;
   }
   anchor()->set_next_page(anchor());
   anchor()->set_prev_page(anchor());
 
   committed_ = false;
   return true;
 }
 
 
-bool SemiSpace::Grow() {
-  // Double the semispace size but only up to maximum capacity.
-  ASSERT(static_cast<size_t>(Page::kPageSize) > OS::AllocateAlignment());
-  int new_capacity = Min(maximum_capacity_,
-      RoundUp(capacity_ * 2, static_cast<int>(Page::kPageSize)));
-  return GrowTo(new_capacity);
-}
-
-
 bool SemiSpace::GrowTo(int new_capacity) {
   ASSERT((new_capacity & Page::kPageAlignmentMask) == 0);
   ASSERT(new_capacity <= maximum_capacity_);
   ASSERT(new_capacity > capacity_);
   int pages_before = capacity_ / Page::kPageSize;
   int pages_after = new_capacity / Page::kPageSize;
 
   Address end = start_ + maximum_capacity_;
   Address start = end - new_capacity;
   size_t delta = new_capacity - capacity_;
@@ skipping 1361 matching lines @@
     object->ShortPrint();
     PrintF("\n");
   }
   printf(" --------------------------------------\n");
   printf(" Marked: %x, LiveCount: %x\n", mark_size, LiveBytes());
 }
 
 #endif  // DEBUG
 
 } }  // namespace v8::internal