libv8-node 15.14.0.1-x86_64-linux-musl → 16.10.0.0-x86_64-linux-musl

data/vendor/v8/include/cppgc/heap-statistics.h

@@ -0,0 +1,120 @@
+// Copyright 2021 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 INCLUDE_CPPGC_HEAP_STATISTICS_H_
+#define INCLUDE_CPPGC_HEAP_STATISTICS_H_
+
+#include <cstddef>
+#include <cstdint>
+#include <string>
+#include <vector>
+
+namespace cppgc {
+
+/**
+ * `HeapStatistics` contains memory consumption and utilization statistics for a
+ * cppgc heap.
+ */
+struct HeapStatistics final {
+  /**
+   * Specifies the detail level of the heap statistics. Brief statistics contain
+   * only the top-level allocated and used memory statistics for the entire
+   * heap. Detailed statistics also contain a break down per space and page, as
+   * well as freelist statistics and object type histograms. Note that used
+   * memory reported by brief statistics and detailed statistics might differ
+   * slightly.
+   */
+  enum DetailLevel : uint8_t {
+    kBrief,
+    kDetailed,
+  };
+
+  /**
+   * Object statistics for a single type.
+   */
+  struct ObjectStatsEntry {
+    /**
+     * Number of allocated bytes.
+     */
+    size_t allocated_bytes;
+    /**
+     * Number of allocated objects.
+     */
+    size_t object_count;
+  };
+
+  /**
+   * Page granularity statistics. For each page the statistics record the
+   * allocated memory size and overall used memory size for the page.
+   */
+  struct PageStatistics {
+    /** Overall committed amount of memory for the page. */
+    size_t committed_size_bytes = 0;
+    /** Resident amount of memory held by the page. */
+    size_t resident_size_bytes = 0;
+    /** Amount of memory actually used on the page. */
+    size_t used_size_bytes = 0;
+    /** Statistics for object allocated on the page. Filled only when
+     * NameProvider::HideInternalNames() is false. */
+    std::vector<ObjectStatsEntry> object_statistics;
+  };
+
+  /**
+   * Statistics of the freelist (used only in non-large object spaces). For
+   * each bucket in the freelist the statistics record the bucket size, the
+   * number of freelist entries in the bucket, and the overall allocated memory
+   * consumed by these freelist entries.
+   */
+  struct FreeListStatistics {
+    /** bucket sizes in the freelist. */
+    std::vector<size_t> bucket_size;
+    /** number of freelist entries per bucket. */
+    std::vector<size_t> free_count;
+    /** memory size consumed by freelist entries per size. */
+    std::vector<size_t> free_size;
+  };
+
+  /**
+   * Space granularity statistics. For each space the statistics record the
+   * space name, the amount of allocated memory and overall used memory for the
+   * space. The statistics also contain statistics for each of the space's
+   * pages, its freelist and the objects allocated on the space.
+   */
+  struct SpaceStatistics {
+    /** The space name */
+    std::string name;
+    /** Overall committed amount of memory for the heap. */
+    size_t committed_size_bytes = 0;
+    /** Resident amount of memory held by the heap. */
+    size_t resident_size_bytes = 0;
+    /** Amount of memory actually used on the space. */
+    size_t used_size_bytes = 0;
+    /** Statistics for each of the pages in the space. */
+    std::vector<PageStatistics> page_stats;
+    /** Statistics for the freelist of the space. */
+    FreeListStatistics free_list_stats;
+  };
+
+  /** Overall committed amount of memory for the heap. */
+  size_t committed_size_bytes = 0;
+  /** Resident amount of memory help by the heap. */
+  size_t resident_size_bytes = 0;
+  /** Amount of memory actually used on the heap. */
+  size_t used_size_bytes = 0;
+  /** Detail level of this HeapStatistics. */
+  DetailLevel detail_level;
+
+  /** Statistics for each of the spaces in the heap. Filled only when
+   * `detail_level` is `DetailLevel::kDetailed`. */
+  std::vector<SpaceStatistics> space_stats;
+
+  /**
+   * Vector of `cppgc::GarbageCollected` type names.
+   */
+  std::vector<std::string> type_names;
+};
+
+}  // namespace cppgc
+
+#endif  // INCLUDE_CPPGC_HEAP_STATISTICS_H_

data/vendor/v8/include/cppgc/heap.h

@@ -5,6 +5,8 @@
 #ifndef INCLUDE_CPPGC_HEAP_H_
 #define INCLUDE_CPPGC_HEAP_H_
 
+#include <cstddef>
+#include <cstdint>
 #include <memory>
 #include <vector>
 
@@ -29,6 +31,11 @@ namespace internal {
 class Heap;
 }  // namespace internal
 
+/**
+ * Used for additional heap APIs.
+ */
+class HeapHandle;
+
 class V8_EXPORT Heap {
  public:
   /**
@@ -51,6 +58,41 @@ class V8_EXPORT Heap {
     kNoConservativeStackScan,
   };
 
+  /**
+   * Specifies supported marking types
+   */
+  enum class MarkingType : uint8_t {
+    /**
+     * Atomic stop-the-world marking. This option does not require any write
+     * barriers but is the most intrusive in terms of jank.
+     */
+    kAtomic,
+    /**
+     * Incremental marking, i.e. interleave marking is the rest of the
+     * application on the same thread.
+     */
+    kIncremental,
+    /**
+     * Incremental and concurrent marking.
+     */
+    kIncrementalAndConcurrent
+  };
+
+  /**
+   * Specifies supported sweeping types
+   */
+  enum class SweepingType : uint8_t {
+    /**
+     * Atomic stop-the-world sweeping. All of sweeping is performed at once.
+     */
+    kAtomic,
+    /**
+     * Incremental and concurrent sweeping. Sweeping is split and interleaved
+     * with the rest of the application.
+     */
+    kIncrementalAndConcurrent
+  };
+
   /**
    * Constraints for a Heap setup.
    */
@@ -66,33 +108,43 @@ class V8_EXPORT Heap {
 
   /**
    * Options specifying Heap properties (e.g. custom spaces) when initializing a
-   * heap through Heap::Create().
+   * heap through `Heap::Create()`.
    */
   struct HeapOptions {
     /**
      * Creates reasonable defaults for instantiating a Heap.
      *
-     * \returns the HeapOptions that can be passed to Heap::Create().
+     * \returns the HeapOptions that can be passed to `Heap::Create()`.
      */
     static HeapOptions Default() { return {}; }
 
     /**
      * Custom spaces added to heap are required to have indices forming a
-     * numbered sequence starting at 0, i.e., their kSpaceIndex must correspond
-     * to the index they reside in the vector.
+     * numbered sequence starting at 0, i.e., their `kSpaceIndex` must
+     * correspond to the index they reside in the vector.
      */
     std::vector<std::unique_ptr<CustomSpaceBase>> custom_spaces;
 
     /**
-     * Specifies whether conserative stack scan is supported. When conservative
+     * Specifies whether conservative stack scan is supported. When conservative
      * stack scan is not supported, the collector may try to invoke
      * garbage collections using non-nestable task, which are guaranteed to have
      * no interesting stack, through the provided Platform. If such tasks are
      * not supported by the Platform, the embedder must take care of invoking
-     * the GC through ForceGarbageCollectionSlow().
+     * the GC through `ForceGarbageCollectionSlow()`.
      */
     StackSupport stack_support = StackSupport::kSupportsConservativeStackScan;
 
+    /**
+     * Specifies which types of marking are supported by the heap.
+     */
+    MarkingType marking_support = MarkingType::kIncrementalAndConcurrent;
+
+    /**
+     * Specifies which types of sweeping are supported by the heap.
+     */
+    SweepingType sweeping_support = SweepingType::kIncrementalAndConcurrent;
+
     /**
      * Resource constraints specifying various properties that the internal
      * GC scheduler follows.
@@ -126,8 +178,18 @@ class V8_EXPORT Heap {
       const char* source, const char* reason,
       StackState stack_state = StackState::kMayContainHeapPointers);
 
+  /**
+   * \returns the opaque handle for allocating objects using
+   * `MakeGarbageCollected()`.
+   */
   AllocationHandle& GetAllocationHandle();
 
+  /**
+   * \returns the opaque heap handle which may be used to refer to this heap in
+   *   other APIs. Valid as long as the underlying `Heap` is alive.
+   */
+  HeapHandle& GetHeapHandle();
+
  private:
   Heap() = default;
 

data/vendor/v8/include/cppgc/internal/api-constants.h

@@ -5,8 +5,8 @@
 #ifndef INCLUDE_CPPGC_INTERNAL_API_CONSTANTS_H_
 #define INCLUDE_CPPGC_INTERNAL_API_CONSTANTS_H_
 
-#include <stddef.h>
-#include <stdint.h>
+#include <cstddef>
+#include <cstdint>
 
 #include "v8config.h"  // NOLINT(build/include_directory)
 
@@ -28,7 +28,7 @@ constexpr size_t kGB = kMB * 1024;
 static constexpr size_t kFullyConstructedBitFieldOffsetFromPayload =
     2 * sizeof(uint16_t);
 // Mask for in-construction bit.
-static constexpr size_t kFullyConstructedBitMask = size_t{1};
+static constexpr uint16_t kFullyConstructedBitMask = uint16_t{1};
 
 static constexpr size_t kPageSize = size_t{1} << 17;
 

data/vendor/v8/include/cppgc/internal/caged-heap-local-data.h

@@ -10,6 +10,7 @@
 #include "cppgc/internal/api-constants.h"
 #include "cppgc/internal/logging.h"
 #include "cppgc/platform.h"
+#include "v8config.h"  // NOLINT(build/include_directory)
 
 namespace cppgc {
 namespace internal {
@@ -54,7 +55,7 @@ static_assert(sizeof(AgeTable) == 1 * api_constants::kMB,
 struct CagedHeapLocalData final {
   explicit CagedHeapLocalData(HeapBase* heap_base) : heap_base(heap_base) {}
 
-  bool is_marking_in_progress = false;
+  bool is_incremental_marking_in_progress = false;
   HeapBase* heap_base = nullptr;
 #if defined(CPPGC_YOUNG_GENERATION)
   AgeTable age_table;

data/vendor/v8/include/cppgc/internal/compiler-specific.h

@@ -21,13 +21,13 @@ namespace cppgc {
 
 // [[no_unique_address]] comes in C++20 but supported in clang with -std >=
 // c++11.
-#if CPPGC_HAS_CPP_ATTRIBUTE(no_unique_address)  // NOLINTNEXTLINE
+#if CPPGC_HAS_CPP_ATTRIBUTE(no_unique_address)
 #define CPPGC_NO_UNIQUE_ADDRESS [[no_unique_address]]
 #else
 #define CPPGC_NO_UNIQUE_ADDRESS
 #endif
 
-#if CPPGC_HAS_ATTRIBUTE(unused)  // NOLINTNEXTLINE
+#if CPPGC_HAS_ATTRIBUTE(unused)
 #define CPPGC_UNUSED __attribute__((unused))
 #else
 #define CPPGC_UNUSED

data/vendor/v8/include/cppgc/internal/gc-info.h

@@ -5,9 +5,12 @@
 #ifndef INCLUDE_CPPGC_INTERNAL_GC_INFO_H_
 #define INCLUDE_CPPGC_INTERNAL_GC_INFO_H_
 
-#include <stdint.h>
+#include <atomic>
+#include <cstdint>
+#include <type_traits>
 
 #include "cppgc/internal/finalizer-trait.h"
+#include "cppgc/internal/name-trait.h"
 #include "cppgc/trace-trait.h"
 #include "v8config.h"  // NOLINT(build/include_directory)
 
@@ -16,26 +19,54 @@ namespace internal {
 
 using GCInfoIndex = uint16_t;
 
-class V8_EXPORT RegisteredGCInfoIndex final {
- public:
-  RegisteredGCInfoIndex(FinalizationCallback finalization_callback,
-                        TraceCallback trace_callback, bool has_v_table);
-  GCInfoIndex GetIndex() const { return index_; }
+// Acquires a new GC info object and returns the index. In addition, also
+// updates `registered_index` atomically.
+V8_EXPORT GCInfoIndex
+EnsureGCInfoIndex(std::atomic<GCInfoIndex>& registered_index,
+                  FinalizationCallback, TraceCallback, NameCallback, bool);
 
- private:
-  const GCInfoIndex index_;
+// Fold types based on finalizer behavior. Note that finalizer characteristics
+// align with trace behavior, i.e., destructors are virtual when trace methods
+// are and vice versa.
+template <typename T, typename ParentMostGarbageCollectedType>
+struct GCInfoFolding {
+  static constexpr bool kHasVirtualDestructorAtBase =
+      std::has_virtual_destructor<ParentMostGarbageCollectedType>::value;
+  static constexpr bool kBothTypesAreTriviallyDestructible =
+      std::is_trivially_destructible<ParentMostGarbageCollectedType>::value &&
+      std::is_trivially_destructible<T>::value;
+  static constexpr bool kHasCustomFinalizerDispatchAtBase =
+      internal::HasFinalizeGarbageCollectedObject<
+          ParentMostGarbageCollectedType>::value;
+#ifdef CPPGC_SUPPORTS_OBJECT_NAMES
+  static constexpr bool kWantsDetailedObjectNames = true;
+#else   // !CPPGC_SUPPORTS_OBJECT_NAMES
+  static constexpr bool kWantsDetailedObjectNames = false;
+#endif  // !CPPGC_SUPPORTS_OBJECT_NAMES
+
+  // Folding would regresses name resolution when deriving names from C++
+  // class names as it would just folds a name to the base class name.
+  using ResultType = std::conditional_t<(kHasVirtualDestructorAtBase ||
+                                         kBothTypesAreTriviallyDestructible ||
+                                         kHasCustomFinalizerDispatchAtBase) &&
+                                            !kWantsDetailedObjectNames,
+                                        ParentMostGarbageCollectedType, T>;
 };
 
 // Trait determines how the garbage collector treats objects wrt. to traversing,
 // finalization, and naming.
 template <typename T>
-struct GCInfoTrait {
+struct GCInfoTrait final {
   static GCInfoIndex Index() {
     static_assert(sizeof(T), "T must be fully defined");
-    static const RegisteredGCInfoIndex registered_index(
-        FinalizerTrait<T>::kCallback, TraceTrait<T>::Trace,
-        std::is_polymorphic<T>::value);
-    return registered_index.GetIndex();
+    static std::atomic<GCInfoIndex>
+        registered_index;  // Uses zero initialization.
+    const GCInfoIndex index = registered_index.load(std::memory_order_acquire);
+    return index ? index
+                 : EnsureGCInfoIndex(
+                       registered_index, FinalizerTrait<T>::kCallback,
+                       TraceTrait<T>::Trace, NameTrait<T>::GetName,
+                       std::is_polymorphic<T>::value);
   }
 };
 

data/vendor/v8/include/cppgc/internal/name-trait.h

@@ -0,0 +1,111 @@
+// Copyright 2020 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 INCLUDE_CPPGC_INTERNAL_NAME_TRAIT_H_
+#define INCLUDE_CPPGC_INTERNAL_NAME_TRAIT_H_
+
+#include <cstddef>
+
+#include "cppgc/name-provider.h"
+#include "v8config.h"  // NOLINT(build/include_directory)
+
+namespace cppgc {
+namespace internal {
+
+#if CPPGC_SUPPORTS_OBJECT_NAMES && defined(__clang__)
+#define CPPGC_SUPPORTS_COMPILE_TIME_TYPENAME 1
+
+// Provides constexpr c-string storage for a name of fixed |Size| characters.
+// Automatically appends terminating 0 byte.
+template <size_t Size>
+struct NameBuffer {
+  char name[Size + 1]{};
+
+  static constexpr NameBuffer FromCString(const char* str) {
+    NameBuffer result;
+    for (size_t i = 0; i < Size; ++i) result.name[i] = str[i];
+    result.name[Size] = 0;
+    return result;
+  }
+};
+
+template <typename T>
+const char* GetTypename() {
+  static constexpr char kSelfPrefix[] =
+      "const char *cppgc::internal::GetTypename() [T =";
+  static_assert(__builtin_strncmp(__PRETTY_FUNCTION__, kSelfPrefix,
+                                  sizeof(kSelfPrefix) - 1) == 0,
+                "The prefix must match");
+  static constexpr const char* kTypenameStart =
+      __PRETTY_FUNCTION__ + sizeof(kSelfPrefix);
+  static constexpr size_t kTypenameSize =
+      __builtin_strlen(__PRETTY_FUNCTION__) - sizeof(kSelfPrefix) - 1;
+  // NameBuffer is an indirection that is needed to make sure that only a
+  // substring of __PRETTY_FUNCTION__ gets materialized in the binary.
+  static constexpr auto buffer =
+      NameBuffer<kTypenameSize>::FromCString(kTypenameStart);
+  return buffer.name;
+}
+
+#else
+#define CPPGC_SUPPORTS_COMPILE_TIME_TYPENAME 0
+#endif
+
+struct HeapObjectName {
+  const char* value;
+  bool name_was_hidden;
+};
+
+class V8_EXPORT NameTraitBase {
+ protected:
+  static HeapObjectName GetNameFromTypeSignature(const char*);
+};
+
+// Trait that specifies how the garbage collector retrieves the name for a
+// given object.
+template <typename T>
+class NameTrait final : public NameTraitBase {
+ public:
+  static HeapObjectName GetName(const void* obj) {
+    return GetNameFor(static_cast<const T*>(obj));
+  }
+
+ private:
+  static HeapObjectName GetNameFor(const NameProvider* name_provider) {
+    return {name_provider->GetHumanReadableName(), false};
+  }
+
+  static HeapObjectName GetNameFor(...) {
+#if CPPGC_SUPPORTS_COMPILE_TIME_TYPENAME
+    return {GetTypename<T>(), false};
+#elif CPPGC_SUPPORTS_OBJECT_NAMES
+
+#if defined(V8_CC_GNU)
+#define PRETTY_FUNCTION_VALUE __PRETTY_FUNCTION__
+#elif defined(V8_CC_MSVC)
+#define PRETTY_FUNCTION_VALUE __FUNCSIG__
+#else
+#define PRETTY_FUNCTION_VALUE nullptr
+#endif
+
+    static const HeapObjectName leaky_name =
+        GetNameFromTypeSignature(PRETTY_FUNCTION_VALUE);
+    return {leaky_name, false};
+
+#undef PRETTY_FUNCTION_VALUE
+
+#else   // !CPPGC_SUPPORTS_OBJECT_NAMES
+    return {NameProvider::kHiddenName, true};
+#endif  // !CPPGC_SUPPORTS_OBJECT_NAMES
+  }
+};
+
+using NameCallback = HeapObjectName (*)(const void*);
+
+}  // namespace internal
+}  // namespace cppgc
+
+#undef CPPGC_SUPPORTS_COMPILE_TIME_TYPENAME
+
+#endif  // INCLUDE_CPPGC_INTERNAL_NAME_TRAIT_H_

data/vendor/v8/include/cppgc/internal/persistent-node.h

@@ -19,7 +19,9 @@ class Visitor;
 
 namespace internal {
 
-// PersistentNode represesents a variant of two states:
+class CrossThreadPersistentRegion;
+
+// PersistentNode represents a variant of two states:
 // 1) traceable node with a back pointer to the Persistent object;
 // 2) freelist entry.
 class PersistentNode final {
@@ -30,6 +32,7 @@ class PersistentNode final {
   PersistentNode& operator=(const PersistentNode&) = delete;
 
   void InitializeAsUsedNode(void* owner, TraceCallback trace) {
+    CPPGC_DCHECK(trace);
     owner_ = owner;
     trace_ = trace;
   }
@@ -89,24 +92,77 @@ class V8_EXPORT PersistentRegion final {
     }
     PersistentNode* node = free_list_head_;
     free_list_head_ = free_list_head_->FreeListNext();
+    CPPGC_DCHECK(!node->IsUsed());
     node->InitializeAsUsedNode(owner, trace);
+    nodes_in_use_++;
     return node;
   }
 
   void FreeNode(PersistentNode* node) {
+    CPPGC_DCHECK(node);
+    CPPGC_DCHECK(node->IsUsed());
     node->InitializeAsFreeNode(free_list_head_);
     free_list_head_ = node;
+    CPPGC_DCHECK(nodes_in_use_ > 0);
+    nodes_in_use_--;
   }
 
   void Trace(Visitor*);
 
   size_t NodesInUse() const;
 
+  void ClearAllUsedNodes();
+
  private:
   void EnsureNodeSlots();
 
   std::vector<std::unique_ptr<PersistentNodeSlots>> nodes_;
   PersistentNode* free_list_head_ = nullptr;
+  size_t nodes_in_use_ = 0;
+
+  friend class CrossThreadPersistentRegion;
+};
+
+// CrossThreadPersistent uses PersistentRegion but protects it using this lock
+// when needed.
+class V8_EXPORT PersistentRegionLock final {
+ public:
+  PersistentRegionLock();
+  ~PersistentRegionLock();
+
+  static void AssertLocked();
+};
+
+// Variant of PersistentRegion that checks whether the PersistentRegionLock is
+// locked.
+class V8_EXPORT CrossThreadPersistentRegion final {
+ public:
+  CrossThreadPersistentRegion() = default;
+  // Clears Persistent fields to avoid stale pointers after heap teardown.
+  ~CrossThreadPersistentRegion();
+
+  CrossThreadPersistentRegion(const CrossThreadPersistentRegion&) = delete;
+  CrossThreadPersistentRegion& operator=(const CrossThreadPersistentRegion&) =
+      delete;
+
+  V8_INLINE PersistentNode* AllocateNode(void* owner, TraceCallback trace) {
+    PersistentRegionLock::AssertLocked();
+    return persistent_region_.AllocateNode(owner, trace);
+  }
+
+  V8_INLINE void FreeNode(PersistentNode* node) {
+    PersistentRegionLock::AssertLocked();
+    persistent_region_.FreeNode(node);
+  }
+
+  void Trace(Visitor*);
+
+  size_t NodesInUse() const;
+
+  void ClearAllUsedNodes();
+
+ private:
+  PersistentRegion persistent_region_;
 };
 
 }  // namespace internal