[heap] Parallel newspace evacuation, semispace copy, and compaction \o/

src/heap/heap.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_HEAP_HEAP_H_
 #define V8_HEAP_HEAP_H_
 
 #include <cmath>
 #include <map>
 
@@ skipping 910 matching lines @@
   void PrintShortHeapStatistics();
 
   inline HeapState gc_state() { return gc_state_; }
 
   inline bool IsInGCPostProcessing() { return gc_post_processing_depth_ > 0; }
 
   // If an object has an AllocationMemento trailing it, return it, otherwise
   // return NULL;
   inline AllocationMemento* FindAllocationMemento(HeapObject* object);
 
+  inline AllocationMemento* FindAllocationMementoCandidate(HeapObject* object);
+
   // Returns false if not able to reserve.
   bool ReserveSpace(Reservation* reservations);
 
   //
   // Support for the API.
   //
 
   void CreateApiObjects();
 
   // Implements the corresponding V8 API function.
@@ skipping 459 matching lines @@
   // Returns the available bytes in space w/o growing.
   // Heap doesn't guarantee that it can allocate an object that requires
   // all available bytes. Check MaxHeapObjectSize() instead.
   intptr_t Available();
 
   // Returns of size of all objects residing in the heap.
   intptr_t SizeOfObjects();
 
   void UpdateSurvivalStatistics(int start_new_space_size);
 
-  inline void IncrementPromotedObjectsSize(int object_size) {
+  inline void IncrementPromotedObjectsSize(intptr_t object_size) {
     DCHECK_GE(object_size, 0);
-    promoted_objects_size_ += object_size;
+    promoted_objects_size_.Increment(object_size);
   }
-  inline intptr_t promoted_objects_size() { return promoted_objects_size_; }
 
-  inline void IncrementSemiSpaceCopiedObjectSize(int object_size) {
+  inline intptr_t promoted_objects_size() {
+    return promoted_objects_size_.Value();
+  }
+
+  inline void IncrementSemiSpaceCopiedObjectSize(intptr_t object_size) {
     DCHECK_GE(object_size, 0);
-    semi_space_copied_object_size_ += object_size;
+    semi_space_copied_object_size_.Increment(object_size);
   }
+
   inline intptr_t semi_space_copied_object_size() {
-    return semi_space_copied_object_size_;
+    return semi_space_copied_object_size_.Value();
   }
 
   inline intptr_t SurvivedNewSpaceObjectSize() {
-    return promoted_objects_size_ + semi_space_copied_object_size_;
+    return promoted_objects_size() + semi_space_copied_object_size();
   }
 
   inline void IncrementNodesDiedInNewSpace() { nodes_died_in_new_space_++; }
 
   inline void IncrementNodesCopiedInNewSpace() { nodes_copied_in_new_space_++; }
 
   inline void IncrementNodesPromoted() { nodes_promoted_++; }
 
-  inline void IncrementYoungSurvivorsCounter(int survived) {
+  inline void IncrementYoungSurvivorsCounter(intptr_t survived) {
     DCHECK(survived >= 0);
-    survived_last_scavenge_ = survived;
-    survived_since_last_expansion_ += survived;
+    survived_last_scavenge_.SetValue(survived);
+    survived_since_last_expansion_.Increment(survived);
+  }
+
+  intptr_t survived_last_scavenge() { return survived_last_scavenge_.Value(); }
+
+  intptr_t survived_since_last_expansion() {
+    return survived_since_last_expansion_.Value();
   }
 
   inline intptr_t PromotedTotalSize() {
     int64_t total = PromotedSpaceSizeOfObjects() + PromotedExternalMemorySize();
     if (total > std::numeric_limits<intptr_t>::max()) {
       // TODO(erikcorry): Use uintptr_t everywhere we do heap size calculations.
       return std::numeric_limits<intptr_t>::max();
     }
     if (total < 0) return 0;
     return static_cast<intptr_t>(total);
@@ skipping 726 matching lines @@
   int initial_semispace_size_;
   int target_semispace_size_;
   intptr_t max_old_generation_size_;
   intptr_t initial_old_generation_size_;
   bool old_generation_size_configured_;
   intptr_t max_executable_size_;
   intptr_t maximum_committed_;
 
   // For keeping track of how much data has survived
   // scavenge since last new space expansion.
-  int survived_since_last_expansion_;
+  AtomicNumber<intptr_t> survived_since_last_expansion_;
 
   // ... and since the last scavenge.
-  int survived_last_scavenge_;
+  AtomicNumber<intptr_t> survived_last_scavenge_;
 
   // This is not the depth of nested AlwaysAllocateScope's but rather a single
   // count, as scopes can be acquired from multiple tasks (read: threads).
   AtomicNumber<size_t> always_allocate_scope_count_;
 
   // For keeping track of context disposals.
   int contexts_disposed_;
 
   // The length of the retained_maps array at the time of context disposal.
   // This separates maps in the retained_maps array that were created before
@@ skipping 77 matching lines @@
   List<GCCallbackPair> gc_prologue_callbacks_;
 
   // Total RegExp code ever generated
   double total_regexp_code_generated_;
 
   int deferred_counters_[v8::Isolate::kUseCounterFeatureCount];
 
   GCTracer* tracer_;
 
   int high_survival_rate_period_length_;
-  intptr_t promoted_objects_size_;
+  AtomicNumber<intptr_t> promoted_objects_size_;
   double promotion_ratio_;
   double promotion_rate_;
-  intptr_t semi_space_copied_object_size_;
+  AtomicNumber<intptr_t> semi_space_copied_object_size_;
   intptr_t previous_semi_space_copied_object_size_;
   double semi_space_copied_rate_;
   int nodes_died_in_new_space_;
   int nodes_copied_in_new_space_;
   int nodes_promoted_;
 
   // This is the pretenuring trigger for allocation sites that are in maybe
   // tenure state. When we switched to the maximum new space size we deoptimize
   // the code that belongs to the allocation site and derive the lifetime
   // of the allocation site.
@@ skipping 426 matching lines @@
  public:
   virtual ~WeakObjectRetainer() {}
 
   // Return whether this object should be retained. If NULL is returned the
   // object has no references. Otherwise the address of the retained object
   // should be returned as in some GC situations the object has been moved.
   virtual Object* RetainAs(Object* object) = 0;
 };
 
 
+class TimedScope {
+ public:
+  TimedScope(Heap* heap, double* result)
+      : heap_(heap),
+        start_(heap->MonotonicallyIncreasingTimeInMs()),
+        result_(result) {}
+
+  ~TimedScope() {
+    *result_ = heap_->MonotonicallyIncreasingTimeInMs() - start_;
+  }
+
+ private:
+  Heap* heap_;
+  double start_;
+  double* result_;
+};
+
+
 #ifdef DEBUG
 // Helper class for tracing paths to a search target Object from all roots.
 // The TracePathFrom() method can be used to trace paths from a specific
 // object to the search target object.
 class PathTracer : public ObjectVisitor {
  public:
   enum WhatToFind {
     FIND_ALL,   // Will find all matches.
     FIND_FIRST  // Will stop the search after first match.
   };
@@ skipping 41 matching lines @@
   DisallowHeapAllocation no_allocation;  // i.e. no gc allowed.
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(PathTracer);
 };
 #endif  // DEBUG
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_HEAP_HEAP_H_