[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 911 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 1796 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 {

[Hannes Payer (out of office), 2016/01/18 11:46:33]

That sounds like a general util class.

[Michael Lippautz, 2016/01/19 14:56:52]

Done.

+ 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_