Enable preaging of code objects when --optimize-for-size.

test/cctest/test-heap.cc

 // Copyright 2012 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 1043 matching lines @@
     CompileRun(source);
   }
 
   // Check function is compiled.
   Object* func_value = Isolate::Current()->context()->global_object()->
       GetProperty(*foo_name)->ToObjectChecked();
   CHECK(func_value->IsJSFunction());
   Handle<JSFunction> function(JSFunction::cast(func_value));
   CHECK(function->shared()->is_compiled());
 
-  // The code will survive at least two GCs.
-  HEAP->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);
+  // The code will survive at least one GC (it will be pre-aged so may not
+  // survive further).

[Hannes Payer (out of office), 2013/09/16 14:31:45]

Since we have the mode now which is turned on on mobile but turned off on
ia32/x64, does this test still work as intended on both platforms (since before
we called the GC two times)?

Would it make sense to leave the test untouched and set the flag to not pre-age
explicitly and add additional tests for the pre-aging?

Same for the code below...

[rmcilroy, 2013/09/16 15:45:47]

Sounds like a plan. Done.

   HEAP->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);
   CHECK(function->shared()->is_compiled());
 
   // Simulate several GCs that use full marking.
   const int kAgingThreshold = 6;
   for (int i = 0; i < kAgingThreshold; i++) {
     HEAP->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);
   }
 
   // foo should no longer be in the compilation cache
@@ skipping 27 matching lines @@
     CompileRun(source);
   }
 
   // Check function is compiled.
   Object* func_value = Isolate::Current()->context()->global_object()->
       GetProperty(*foo_name)->ToObjectChecked();
   CHECK(func_value->IsJSFunction());
   Handle<JSFunction> function(JSFunction::cast(func_value));
   CHECK(function->shared()->is_compiled());
 
-  // The code will survive at least two GCs.
+  // The code will survive at least one GC (it will be pre-aged so may not
+  // survive further).
+  HEAP->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);
+  CHECK(function->shared()->is_compiled());
+
+  // Execute the function again to ensure it is reset to the young age.
+  { v8::HandleScope scope(CcTest::isolate());
+    CompileRun("foo();");
+  }
+
+  // The code will survive at least two GC now that it is young again.
   HEAP->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);
   HEAP->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);
   CHECK(function->shared()->is_compiled());
 
   // Simulate several GCs that use incremental marking.
   const int kAgingThreshold = 6;
   for (int i = 0; i < kAgingThreshold; i++) {
     SimulateIncrementalMarking();
     HEAP->CollectAllGarbage(Heap::kNoGCFlags);
   }
@@ skipping 116 matching lines @@
     CompileRun(source);
   }
 
   // Check function is compiled.
   Object* func_value = Isolate::Current()->context()->global_object()->
       GetProperty(*foo_name)->ToObjectChecked();
   CHECK(func_value->IsJSFunction());
   Handle<JSFunction> function(JSFunction::cast(func_value));
   CHECK(function->shared()->is_compiled());
 
-  // The code will survive at least two GCs.
-  heap->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);
-  heap->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);
+  // The code will survive at least one GC (it will be pre-aged so may not
+  // survive further).
+  HEAP->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask);
   CHECK(function->shared()->is_compiled());
 
   // Bump the code age so that flushing is triggered.
   const int kAgingThreshold = 6;
   for (int i = 0; i < kAgingThreshold; i++) {
     function->shared()->code()->MakeOlder(static_cast<MarkingParity>(i % 2));
   }
 
   // Simulate incremental marking so that the function is enqueued as
   // code flushing candidate.
@@ skipping 2184 matching lines @@
              "    var a = new Array(n);"
              "    for (var i = 0; i < n; i += 100) a[i] = i;"
              "};"
              "f(10 * 1024 * 1024);");
   IncrementalMarking* marking = HEAP->incremental_marking();
   if (marking->IsStopped()) marking->Start();
   // This big step should be sufficient to mark the whole array.
   marking->Step(100 * MB, IncrementalMarking::NO_GC_VIA_STACK_GUARD);
   ASSERT(marking->IsComplete());
 }