Parallelize marking phase of mark-sweep/compact collection cycle.

src/heap.cc

 // Copyright 2010 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 33 matching lines @@
 #include "v8threads.h"
 #if V8_TARGET_ARCH_ARM && !V8_INTERPRETED_REGEXP
 #include "regexp-macro-assembler.h"
 #include "arm/regexp-macro-assembler-arm.h"
 #endif
 
 
 namespace v8 {
 namespace internal {
 
+Atomic32 RootsPartitioner::partitions_state_[kNumberOfRootsPartitions];
 
 String* Heap::hidden_symbol_;
 Object* Heap::roots_[Heap::kRootListLength];
 
 NewSpace Heap::new_space_;
 OldSpace* Heap::old_pointer_space_ = NULL;
 OldSpace* Heap::old_data_space_ = NULL;
 OldSpace* Heap::code_space_ = NULL;
 MapSpace* Heap::map_space_ = NULL;
 CellSpace* Heap::cell_space_ = NULL;
@@ skipping 3968 matching lines @@
   // empty.  However the next thing we do is create the partial snapshot,
   // filling up the partial snapshot cache with objects it needs as we go.
   SerializerDeserializer::Iterate(v);
   // We don't do a v->Synchronize call here, because in debug mode that will
   // output a flag to the snapshot.  However at this point the serializer and
   // deserializer are deliberately a little unsynchronized (see above) so the
   // checking of the sync flag in the snapshot would fail.
 }
 
 
+void Heap::ClaimAndIterateStrongRootsGroup(ObjectVisitor* v,
+                                           VisitMode mode,
+                                           RootsPartition partition) {
+  if (!RootsPartitioner::Claim(partition)) return;
+
+  switch (partition) {
+    case kStrongRootsList:
+      v->VisitPointers(&roots_[0], &roots_[kStrongRootListLength]);
+      v->VisitPointer(BitCast<Object**>(&hidden_symbol_));
+      break;
+
+    case kBootstrapperRoots:
+      Bootstrapper::Iterate(v);
+      break;
+
+    case kTopRoots:
+      Top::Iterate(v);
+      break;
+
+    case kRelocatableRoots:
+      Relocatable::Iterate(v);
+      break;
+
+#ifdef ENABLE_DEBUGGER_SUPPORT
+    case kDebugRoots:
+      Debug::Iterate(v);
+      break;
+#endif
+
+    case kCompilationCacheRoots:
+      CompilationCache::Iterate(v);
+      break;
+
+    case kHandleScopeRoots:
+      HandleScopeImplementer::Iterate(v);
+      break;
+
+    case kBuiltinsRoots:
+      if (mode != VISIT_ALL_IN_SCAVENGE) Builtins::IterateBuiltins(v);
+      break;
+
+    case kGlobalHandlesRoots:
+      if (mode == VISIT_ONLY_STRONG) {
+        GlobalHandles::IterateStrongRoots(v);
+      } else {
+        GlobalHandles::IterateAllRoots(v);
+      }
+      break;
+
+    case kThreadManagerRoots:
+      ThreadManager::Iterate(v);
+      break;
+
+    case kSerializerDeserializerRoots:
+      SerializerDeserializer::Iterate(v);
+      break;
+
+    default:
+      UNREACHABLE();
+  }
+}
+
+
 // Flag is set when the heap has been configured.  The heap can be repeatedly
 // configured through the API until it is setup.
 static bool heap_configured = false;
 
 // TODO(1236194): Since the heap size is configurable on the command line
 // and through the API, we should gracefully handle the case that the heap
 // size is not big enough to fit all the initial objects.
 bool Heap::ConfigureHeap(int max_semispace_size, int max_old_gen_size) {
   if (HasBeenSetup()) return false;
 
@@ skipping 714 matching lines @@
   return holes_size;
 }
 
 
 GCTracer::GCTracer()
     : start_time_(0.0),
       start_size_(0),
       gc_count_(0),
       full_gc_count_(0),
       is_compacting_(false),
+#ifdef DEBUG
       marked_count_(0),
+#endif
       allocated_since_last_gc_(0),
       spent_in_mutator_(0),
       promoted_objects_size_(0) {
   // These two fields reflect the state of the previous full collection.
   // Set them before they are changed by the collector.
   previous_has_compacted_ = MarkCompactCollector::HasCompacted();
-  previous_marked_count_ = MarkCompactCollector::previous_marked_count();
   if (!FLAG_trace_gc && !FLAG_print_cumulative_gc_stat) return;
   start_time_ = OS::TimeCurrentMillis();
   start_size_ = Heap::SizeOfObjects();
 
   for (int i = 0; i < Scope::kNumberOfScopes; i++) {
     scopes_[i] = 0;
   }
 
   in_free_list_or_wasted_before_gc_ = CountTotalHolesSize();
 
@@ skipping 202 matching lines @@
 void ExternalStringTable::TearDown() {
   new_space_strings_.Free();
   old_space_strings_.Free();
 }
 
 
 List<Object*> ExternalStringTable::new_space_strings_;
 List<Object*> ExternalStringTable::old_space_strings_;
 
 } }  // namespace v8::internal