Revert of Revert of Pass GC flags to incremental marker and start incremental marking with

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 2111 matching lines @@
         "function mkbar () { return new (new Function(\"\")) (); }"
         "function f (x) { return (x instanceof foo); }"
         "function g () { f(mkbar()); }"
         "f(new foo()); f(new foo());"
         "%OptimizeFunctionOnNextCall(f);"
         "f(new foo()); g();");
   }
 
   IncrementalMarking* marking = CcTest::heap()->incremental_marking();
   marking->Abort();
-  marking->Start();
+  marking->Start(Heap::kNoGCFlags);
 
   Handle<JSFunction> f =
       v8::Utils::OpenHandle(
           *v8::Handle<v8::Function>::Cast(
               CcTest::global()->Get(v8_str("f"))));
 
   CHECK(f->IsOptimized());
 
   while (!Marking::IsBlack(Marking::MarkBitFrom(f->code())) &&
          !marking->IsStopped()) {
@@ skipping 105 matching lines @@
         "f();");
   }
   Handle<JSFunction> f =
       v8::Utils::OpenHandle(
           *v8::Handle<v8::Function>::Cast(
               CcTest::global()->Get(v8_str("f"))));
   CHECK(f->IsOptimized());
 
   IncrementalMarking* marking = CcTest::heap()->incremental_marking();
   marking->Abort();
-  marking->Start();
+  marking->Start(Heap::kNoGCFlags);
   // The following calls will increment CcTest::heap()->global_ic_age().
   CcTest::isolate()->ContextDisposedNotification();
   SimulateIncrementalMarking(CcTest::heap());
   CcTest::heap()->CollectAllGarbage();
   CHECK_EQ(CcTest::heap()->global_ic_age(), f->shared()->ic_age());
   CHECK_EQ(0, f->shared()->opt_count());
   CHECK_EQ(0, f->shared()->code()->profiler_ticks());
 }
 
 
@@ skipping 37 matching lines @@
   CHECK_EQ(0, f->shared()->code()->profiler_ticks());
 }
 
 
 TEST(IdleNotificationFinishMarking) {
   i::FLAG_allow_natives_syntax = true;
   CcTest::InitializeVM();
   SimulateFullSpace(CcTest::heap()->old_space());
   IncrementalMarking* marking = CcTest::heap()->incremental_marking();
   marking->Abort();
-  marking->Start();
+  marking->Start(Heap::kNoGCFlags);
 
   CHECK_EQ(CcTest::heap()->gc_count(), 0);
 
   // TODO(hpayer): We cannot write proper unit test right now for heap.
   // The ideal test would call kMaxIdleMarkingDelayCounter to test the
   // marking delay counter.
 
   // Perform a huge incremental marking step but don't complete marking.
   intptr_t bytes_processed = 0;
   do {
@@ skipping 1789 matching lines @@
 
 TEST(IncrementalMarkingStepMakesBigProgressWithLargeObjects) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   CompileRun("function f(n) {"
              "    var a = new Array(n);"
              "    for (var i = 0; i < n; i += 100) a[i] = i;"
              "};"
              "f(10 * 1024 * 1024);");
   IncrementalMarking* marking = CcTest::heap()->incremental_marking();
-  if (marking->IsStopped()) marking->Start();
+  if (marking->IsStopped()) marking->Start(Heap::kNoGCFlags);
   // This big step should be sufficient to mark the whole array.
   marking->Step(100 * MB, IncrementalMarking::NO_GC_VIA_STACK_GUARD);
   DCHECK(marking->IsComplete() ||
          marking->IsReadyToOverApproximateWeakClosure());
 }
 
 
 TEST(DisableInlineAllocation) {
   i::FLAG_allow_natives_syntax = true;
   CcTest::InitializeVM();
@@ skipping 707 matching lines @@
   Handle<FixedArray> survivor = factory->NewFixedArray(1, NOT_TENURED);
   Handle<WeakCell> weak_cells[N];
 
   for (int i = 0; i < N; i++) {
     HandleScope inner_scope(isolate);
     Handle<HeapObject> value =
         i == 0 ? survivor : factory->NewFixedArray(1, NOT_TENURED);
     Handle<WeakCell> weak_cell = factory->NewWeakCell(value);
     CHECK(weak_cell->value()->IsFixedArray());
     IncrementalMarking* marking = heap->incremental_marking();
-    if (marking->IsStopped()) marking->Start();
+    if (marking->IsStopped()) marking->Start(Heap::kNoGCFlags);
     marking->Step(128, IncrementalMarking::NO_GC_VIA_STACK_GUARD);
     heap->CollectGarbage(NEW_SPACE);
     CHECK(weak_cell->value()->IsFixedArray());
     weak_cells[i] = inner_scope.CloseAndEscape(weak_cell);
   }
   heap->CollectAllGarbage();
   CHECK_EQ(*survivor, weak_cells[0]->value());
   for (int i = 1; i < N; i++) {
     CHECK(weak_cells[i]->cleared());
   }
@@ skipping 247 matching lines @@
   // Ensure that the object allocated where we need it.
   Page* page = Page::FromAddress(o->address());
   CHECK_EQ(desired_offset, page->Offset(o->address()));
 
   // Now we have an object right at the end of the page.
 
   // Enable incremental marking to trigger actions in Heap::AdjustLiveBytes()
   // that would cause crash.
   IncrementalMarking* marking = CcTest::heap()->incremental_marking();
   marking->Abort();
-  marking->Start();
+  marking->Start(Heap::kNoGCFlags);
   CHECK(marking->IsMarking());
 
   // Now everything is set up for crashing in JSObject::MigrateFastToFast()
   // when it calls heap->AdjustLiveBytes(...).
   JSObject::MigrateToMap(o, map2);
 }
 
 
 TEST(Regress3631) {
   i::FLAG_expose_gc = true;
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Heap* heap = isolate->heap();
   IncrementalMarking* marking = CcTest::heap()->incremental_marking();
   v8::Local<v8::Value> result = CompileRun(
       "var weak_map = new WeakMap();"
       "var future_keys = [];"
       "for (var i = 0; i < 50; i++) {"
       "  var key = {'k' : i + 0.1};"
       "  weak_map.set(key, 1);"
       "  future_keys.push({'x' : i + 0.2});"
       "}"
       "weak_map");
   if (marking->IsStopped()) {
-    marking->Start();
+    marking->Start(Heap::kNoGCFlags);
   }
   // Incrementally mark the backing store.
   Handle<JSObject> obj =
       v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(result));
   Handle<JSWeakCollection> weak_map(reinterpret_cast<JSWeakCollection*>(*obj));
   while (!Marking::IsBlack(
              Marking::MarkBitFrom(HeapObject::cast(weak_map->table()))) &&
          !marking->IsStopped()) {
     marking->Step(MB, IncrementalMarking::NO_GC_VIA_STACK_GUARD);
   }
@@ skipping 392 matching lines @@
   size_t counter2 = 2000;
   tracer->SampleNewSpaceAllocation(time2, counter2);
   size_t bytes = tracer->NewSpaceAllocatedBytesInLast(1000);
   CHECK_EQ(0, bytes);
   int time3 = 1000;
   size_t counter3 = 30000;
   tracer->SampleNewSpaceAllocation(time3, counter3);
   bytes = tracer->NewSpaceAllocatedBytesInLast(100);
   CHECK_EQ((counter3 - counter1) * 100 / (time3 - time1), bytes);
 }