Flush code faster when doing emergency GCs.

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 3056 matching lines @@
   // where there are 2 pages left instead of 1, then we should increase the
   // size of the first page a little in SizeOfFirstPage in spaces.cc.  The
   // first page should be small in order to reduce memory used when the VM
   // boots, but if the 20 small arrays don't fit on the first page then that's
   // an indication that it is too small.
   heap->CollectAllAvailableGarbage("triggered really hard");
   CHECK_EQ(1, old_pointer_space->CountTotalPages());
 }
 
 
+// Tests the FlushEagerly class from heap.h
+TEST(ReleaseUnoptimizedCode) {
+  i::FLAG_trace_gc = true;
+  // The optimizer can allocate stuff, messing up the test.
+  i::FLAG_crankshaft = false;
+  if (i::FLAG_always_opt) return;
+
+  CcTest::InitializeVM();
+  Isolate* isolate = CcTest::i_isolate();
+  Heap* heap = isolate->heap();
+  v8::HandleScope scope(CcTest::isolate());
+
+  PagedSpace* code_space = heap->code_space();
+  CompileRun(
+      "var a = [];"
+      "var sum = 0;"
+      "for (var j = 0; j < 1e4; j++) {"
+      "  var fn = new Function("
+      "      'var k; var o = {}; for (k in o) { } return ' + j + ';');"
+      "  sum += fn();"
+      "}");
+  heap->CollectAllGarbage(Heap::kNoGCFlags, "triggered for preparation");
+  CHECK_GE(code_space->CountTotalPages(), 5);
+  // We trigger an emergency GC, but only one round, because that should be
+  // enough to flush out the code.
+  heap->CollectAllAvailableGarbage("triggered really hard", 1);
+  CHECK_LE(code_space->CountTotalPages(), 2);
+}
+
+
+// Tests the FlushEagerly class from heap.h on regexp code.
+TEST(ReleaseRegexpCode) {
+  i::FLAG_trace_gc = true;
+  // The optimizer can allocate stuff, messing up the test.
+  i::FLAG_crankshaft = false;
+  if (i::FLAG_always_opt) return;
+
+  CcTest::InitializeVM();
+  Isolate* isolate = CcTest::i_isolate();
+  Heap* heap = isolate->heap();
+  v8::HandleScope scope(CcTest::isolate());
+
+  PagedSpace* code_space = heap->code_space();
+  CompileRun(
+      "var a = [];"
+      "for (var j = 0; j < 2e4; j++) {"
+      "  var re = RegExp(j + '?');"
+      "  a.push(re);"
+      "  re.test('foo');"
+      "}");
+  heap->CollectAllGarbage(Heap::kNoGCFlags, "triggered for preparation");
+  CHECK_GT(code_space->CountTotalPages(), 5);
+  // We trigger an emergency GC, but only one round, because that should be
+  // enough to flush out the code.
+  heap->CollectAllAvailableGarbage("triggered really hard", 1);
+  CHECK_LE(code_space->CountTotalPages(), 2);
+}
+
+
 TEST(Regress2237) {
   i::FLAG_stress_compaction = false;
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   Factory* factory = isolate->factory();
   v8::HandleScope scope(CcTest::isolate());
   Handle<String> slice(CcTest::heap()->empty_string());
 
   {
     // Generate a parent that lives in new-space.
@@ skipping 272 matching lines @@
     v8::Handle<v8::String> source_string =
         v8::String::NewExternal(isolate, resource);
     i_isolate->heap()->CollectAllAvailableGarbage();
     v8::Script::Compile(source_string)->Run();
     CHECK(!resource->IsDisposed());
   }
   // i_isolate->heap()->CollectAllAvailableGarbage();
   CHECK(!resource->IsDisposed());
 
   CompileRun(accessor);
-  i_isolate->heap()->CollectAllAvailableGarbage();
+  i_isolate->heap()->CollectAllAvailableGarbage(
+      "force release of external source in one round", 1);
 
   // External source has been released.
   CHECK(resource->IsDisposed());
   delete resource;
 }
 
 
 UNINITIALIZED_TEST(ReleaseStackTraceData) {
   if (i::FLAG_always_opt) {
     // TODO(ulan): Remove this once the memory leak via code_next_link is fixed.
@@ skipping 739 matching lines @@
   {
     HandleScope scope(heap->isolate());
     Handle<JSFunction> mortal = OptimizeDummyFunction("mortal");
     Handle<JSFunction> immortal = OptimizeDummyFunction("immortal");
     CHECK_EQ(immortal->code()->next_code_link(), mortal->code());
     code_chain_length_before = GetCodeChainLength(immortal->code());
     // Keep the immortal code and let the mortal code die.
     code = scope.CloseAndEscape(Handle<Code>(immortal->code()));
     CompileRun("mortal = null; immortal = null;");
   }
-  heap->CollectAllAvailableGarbage();
+  heap->CollectAllAvailableGarbage("kill mortal code", 1);
   // Now mortal code should be dead.
   code_chain_length_after = GetCodeChainLength(*code);
   CHECK_EQ(code_chain_length_before - 1, code_chain_length_after);
 }
 
 
 static Handle<Code> DummyOptimizedCode(Isolate* isolate) {
   i::byte buffer[i::Assembler::kMinimalBufferSize];
   MacroAssembler masm(isolate, buffer, sizeof(buffer));
   CodeDesc desc;
@@ skipping 22 matching lines @@
   Handle<Object> old_head(context->get(Context::OPTIMIZED_CODE_LIST), isolate);
   {
     HandleScope scope(heap->isolate());
     Handle<Code> immortal = DummyOptimizedCode(isolate);
     Handle<Code> mortal = DummyOptimizedCode(isolate);
     mortal->set_next_code_link(*old_head);
     immortal->set_next_code_link(*mortal);
     context->set(Context::OPTIMIZED_CODE_LIST, *immortal);
     new_head = scope.CloseAndEscape(immortal);
   }
-  heap->CollectAllAvailableGarbage();
+  heap->CollectAllAvailableGarbage("kill mortal code", 1);
   // Now mortal code should be dead.
   CHECK_EQ(*old_head, new_head->next_code_link());
 }
 
 
 static bool weak_ic_cleared = false;
 
 static void ClearWeakIC(const v8::WeakCallbackData<v8::Object, void>& data) {
   printf("clear weak is called\n");
   weak_ic_cleared = true;
@@ skipping 121 matching lines @@
     weak_cell2 = inner_scope.CloseAndEscape(factory->NewWeakCell(survivor));
   }
   CHECK(weak_cell1->value()->IsFixedArray());
   CHECK_EQ(*survivor, weak_cell2->value());
   heap->CollectGarbage(NEW_SPACE);
   CHECK(weak_cell1->value()->IsFixedArray());
   CHECK_EQ(*survivor, weak_cell2->value());
   heap->CollectGarbage(NEW_SPACE);
   CHECK(weak_cell1->value()->IsFixedArray());
   CHECK_EQ(*survivor, weak_cell2->value());
-  heap->CollectAllAvailableGarbage();
+  heap->CollectAllAvailableGarbage("kill weak cell", 1);
   CHECK(weak_cell1->cleared());
   CHECK_EQ(*survivor, weak_cell2->value());
 }
 
 
 TEST(WeakCellsWithIncrementalMarking) {
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   v8::internal::Heap* heap = CcTest::heap();
   v8::internal::Factory* factory = isolate->factory();
@@ skipping 288 matching lines @@
 #ifdef DEBUG
 TEST(PathTracer) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
 
   v8::Local<v8::Value> result = CompileRun("'abc'");
   Handle<Object> o = v8::Utils::OpenHandle(*result);
   CcTest::i_isolate()->heap()->TracePathToObject(*o);
 }
 #endif  // DEBUG