Line data    Source code

       1             : // Copyright 2016 the V8 project authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : 
       5             : #ifndef V8_HEAP_EMBEDDER_TRACING_H_
       6             : #define V8_HEAP_EMBEDDER_TRACING_H_
       7             : 
       8             : #include "include/v8.h"
       9             : #include "src/flags.h"
      10             : #include "src/globals.h"
      11             : 
      12             : namespace v8 {
      13             : namespace internal {
      14             : 
      15             : class Heap;
      16             : class JSObject;
      17             : 
      18             : class V8_EXPORT_PRIVATE LocalEmbedderHeapTracer final {
      19             :  public:
      20             :   using WrapperInfo = std::pair<void*, void*>;
      21             :   using WrapperCache = std::vector<WrapperInfo>;
      22             : 
      23             :   class V8_EXPORT_PRIVATE ProcessingScope {
      24             :    public:
      25             :     explicit ProcessingScope(LocalEmbedderHeapTracer* tracer);
      26             :     ~ProcessingScope();
      27             : 
      28             :     void TracePossibleWrapper(JSObject js_object);
      29             : 
      30             :     void AddWrapperInfoForTesting(WrapperInfo info);
      31             : 
      32             :    private:
      33             :     static constexpr size_t kWrapperCacheSize = 1000;
      34             : 
      35             :     void FlushWrapperCacheIfFull();
      36             : 
      37             :     LocalEmbedderHeapTracer* const tracer_;
      38             :     WrapperCache wrapper_cache_;
      39             :   };
      40             : 
      41       62457 :   explicit LocalEmbedderHeapTracer(Isolate* isolate) : isolate_(isolate) {}
      42             : 
      43       62442 :   ~LocalEmbedderHeapTracer() {
      44       62442 :     if (remote_tracer_) remote_tracer_->isolate_ = nullptr;
      45             :   }
      46             : 
      47      456089 :   bool InUse() const { return remote_tracer_ != nullptr; }
      48             :   EmbedderHeapTracer* remote_tracer() const { return remote_tracer_; }
      49             : 
      50             :   void SetRemoteTracer(EmbedderHeapTracer* tracer);
      51             :   void TracePrologue();
      52             :   void TraceEpilogue();
      53             :   void EnterFinalPause();
      54             :   bool Trace(double deadline);
      55             :   bool IsRemoteTracingDone();
      56             : 
      57             :   bool IsRootForNonTracingGC(const v8::TracedGlobal<v8::Value>& handle) {
      58          15 :     return !InUse() || remote_tracer_->IsRootForNonTracingGC(handle);
      59             :   }
      60             : 
      61             :   void NotifyV8MarkingWorklistWasEmpty() {
      62          20 :     num_v8_marking_worklist_was_empty_++;
      63             :   }
      64             : 
      65     1061874 :   bool ShouldFinalizeIncrementalMarking() {
      66             :     static const size_t kMaxIncrementalFixpointRounds = 3;
      67     2123778 :     return !FLAG_incremental_marking_wrappers || !InUse() ||
      68     1061964 :            (IsRemoteTracingDone() && embedder_worklist_empty_) ||
      69     1061904 :            num_v8_marking_worklist_was_empty_ > kMaxIncrementalFixpointRounds;
      70             :   }
      71             : 
      72             :   void SetEmbedderStackStateForNextFinalization(
      73             :       EmbedderHeapTracer::EmbedderStackState stack_state);
      74             : 
      75             :   void SetEmbedderWorklistEmpty(bool is_empty) {
      76           0 :     embedder_worklist_empty_ = is_empty;
      77             :   }
      78             : 
      79             :  private:
      80             :   Isolate* const isolate_;
      81             :   EmbedderHeapTracer* remote_tracer_ = nullptr;
      82             : 
      83             :   size_t num_v8_marking_worklist_was_empty_ = 0;
      84             :   EmbedderHeapTracer::EmbedderStackState embedder_stack_state_ =
      85             :       EmbedderHeapTracer::kUnknown;
      86             :   // Indicates whether the embedder worklist was observed empty on the main
      87             :   // thread. This is opportunistic as concurrent marking tasks may hold local
      88             :   // segments of potential embedder fields to move to the main thread.
      89             :   bool embedder_worklist_empty_ = false;
      90             : 
      91             :   friend class EmbedderStackStateScope;
      92             : };
      93             : 
      94             : class V8_EXPORT_PRIVATE EmbedderStackStateScope final {
      95             :  public:
      96             :   EmbedderStackStateScope(LocalEmbedderHeapTracer* local_tracer,
      97             :                           EmbedderHeapTracer::EmbedderStackState stack_state)
      98             :       : local_tracer_(local_tracer),
      99      123570 :         old_stack_state_(local_tracer_->embedder_stack_state_) {
     100      123570 :     local_tracer_->embedder_stack_state_ = stack_state;
     101             :   }
     102             : 
     103             :   ~EmbedderStackStateScope() {
     104      123571 :     local_tracer_->embedder_stack_state_ = old_stack_state_;
     105             :   }
     106             : 
     107             :  private:
     108             :   LocalEmbedderHeapTracer* const local_tracer_;
     109             :   const EmbedderHeapTracer::EmbedderStackState old_stack_state_;
     110             : };
     111             : 
     112             : }  // namespace internal
     113             : }  // namespace v8
     114             : 
     115             : #endif  // V8_HEAP_EMBEDDER_TRACING_H_