Fix new space shrinking to reset from-space.

test/cctest/test-heap.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 
 #include <stdlib.h>
 
 #include "v8.h"
 
 #include "execution.h"
 #include "factory.h"
 #include "macro-assembler.h"
 #include "global-handles.h"
@@ skipping 1203 matching lines @@
     intptr_t delta = size_of_objects_2 - size_of_objects_1;
     PrintF("Heap::SizeOfObjects: %" V8_PTR_PREFIX "d, "
            "Iterator: %" V8_PTR_PREFIX "d, "
            "delta: %" V8_PTR_PREFIX "d\n",
            size_of_objects_1, size_of_objects_2, delta);
     CHECK_GT(size_of_objects_2 / 20, delta);
   }
 }
 
 
+TEST(GrowAndShrinkNewSpace) {
+  InitializeVM();
+  v8::HandleScope scope;
+  NewSpace* new_space = HEAP->new_space();
+
+  // Explicitly growing should double the space capacity.
+  int old_capacity, new_capacity;
+  old_capacity = new_space->Capacity();
+  new_space->Grow();
+  new_capacity = new_space->Capacity();
+  ASSERT_EQ(2 * old_capacity, new_capacity);
+
+  // Fill up new space to the point that it exceeds old capacity.
+  while (new_space->SizeAsInt() <= old_capacity) {
+    Handle<FixedArray> filler = FACTORY->NewFixedArray(1000, NOT_TENURED);
+    ASSERT(HEAP->InNewSpace(*FACTORY->NewFixedArray(1000, NOT_TENURED)));
+  }
+
+  // Explicitly shrinking should not affect space capacity.
+  old_capacity = new_space->Capacity();
+  new_space->Shrink();
+  new_capacity = new_space->Capacity();
+  ASSERT_EQ(old_capacity, new_capacity);
+
+  // Perform scavenge to empty the new space.
+  HEAP->CollectGarbage(NEW_SPACE);
+  ASSERT_LE(new_space->SizeAsInt(), old_capacity);
+
+  // Explicitly shrinking should halve the space capacity.
+  old_capacity = new_space->Capacity();
+  new_space->Shrink();
+  new_capacity = new_space->Capacity();
+  ASSERT_EQ(old_capacity, 2 * new_capacity);
+
+  // Consecutive shrinking should not affect space capacity.
+  old_capacity = new_space->Capacity();
+  new_space->Shrink();
+  new_space->Shrink();
+  new_space->Shrink();
+  new_capacity = new_space->Capacity();
+  ASSERT_EQ(old_capacity, new_capacity);
+}
+
+
 class HeapIteratorTestHelper {
  public:
   HeapIteratorTestHelper(Object* a, Object* b)
       : a_(a), b_(b), a_found_(false), b_found_(false) {}
   bool a_found() { return a_found_; }
   bool b_found() { return b_found_; }
   void IterateHeap() {
     HeapIterator iterator;
     for (HeapObject* obj = iterator.next();
          obj != NULL;
          obj = iterator.next()) {
       if (obj == a_)
         a_found_ = true;
       else if (obj == b_)
         b_found_ = true;
     }
   }
  private:
   Object* a_;
   Object* b_;
   bool a_found_;
   bool b_found_;
 };