@encharm/cws 4.5.2 → 4.6.0

package/src/headers/26/v8-cpp-heap-external.h

@@ -0,0 +1,56 @@
+// Copyright 2025 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_V8_HEAP_EXTERNAL_H_
+#define INCLUDE_V8_HEAP_EXTERNAL_H_
+
+#include "cppgc/type-traits.h"  // NOLINT(build/include_directory)
+#include "v8-sandbox.h"         // NOLINT(build/include_directory)
+#include "v8-value.h"           // NOLINT(build/include_directory)
+#include "v8config.h"           // NOLINT(build/include_directory)
+
+namespace v8 {
+
+class Isolate;
+
+/**
+ * A JavaScript value that wraps a `cppgc::GarbageCollected<T>` object allocated
+ * on the managed C++ heap (CppHeap). This type of value is mainly used to
+ * associate C++ data structures which aren't exposed to JavaScript with
+ * JavaScript objects.
+ */
+class V8_EXPORT CppHeapExternal : public Data {
+ public:
+  template <typename T>
+  static Local<CppHeapExternal> New(Isolate* isolate, T* value,
+                                    CppHeapPointerTag tag) {
+    static_assert(cppgc::IsGarbageCollectedTypeV<T>,
+                  "Object must be of type GarbageCollected.");
+    return NewImpl(isolate, value, tag);
+  }
+
+  V8_INLINE static CppHeapExternal* Cast(Data* data) {
+#ifdef V8_ENABLE_CHECKS
+    CheckCast(data);
+#endif
+    return static_cast<CppHeapExternal*>(data);
+  }
+
+  template <typename T>
+  T* Value(Isolate* isolate, CppHeapPointerTagRange tag_range) const {
+    static_assert(cppgc::IsGarbageCollectedTypeV<T>,
+                  "Object must be of type GarbageCollected.");
+    return static_cast<T*>(ValueImpl(isolate, tag_range));
+  }
+
+ private:
+  static void CheckCast(v8::Data* obj);
+  static Local<CppHeapExternal> NewImpl(Isolate* isolate, void* value,
+                                        CppHeapPointerTag tag);
+  void* ValueImpl(Isolate*, CppHeapPointerTagRange tag_range) const;
+};
+
+}  // namespace v8
+
+#endif  // INCLUDE_V8_HEAP_EXTERNAL_H_

package/src/headers/26/v8-external-memory-accounter.h

@@ -0,0 +1,60 @@
+// Copyright 2024 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_EXTERNAL_MEMORY_ACCOUNTER_H_
+#define INCLUDE_EXTERNAL_MEMORY_ACCOUNTER_H_
+
+#include <stdint.h>
+
+#include "v8-isolate.h"
+
+namespace v8 {
+
+/**
+ * This class is used to give V8 an indication of the amount of externally
+ * allocated memory that is kept alive by JavaScript objects. V8 uses this to
+ * decide when to perform garbage collections. Registering externally allocated
+ * memory will trigger garbage collections more often than it would otherwise in
+ * an attempt to garbage collect the JavaScript objects that keep the externally
+ * allocated memory alive. Instances of ExternalMemoryAccounter check that the
+ * reported external memory is back to 0 on destruction.
+ */
+class V8_EXPORT ExternalMemoryAccounter {
+ public:
+  /**
+   * Returns the amount of external memory registered for `isolate`.
+   */
+  static int64_t GetTotalAmountOfExternalAllocatedMemoryForTesting(
+      const Isolate* isolate);
+
+  ExternalMemoryAccounter() = default;
+  ~ExternalMemoryAccounter();
+  ExternalMemoryAccounter(ExternalMemoryAccounter&&);
+  ExternalMemoryAccounter& operator=(ExternalMemoryAccounter&&);
+  ExternalMemoryAccounter(const ExternalMemoryAccounter&) = delete;
+  ExternalMemoryAccounter& operator=(const ExternalMemoryAccounter&) = delete;
+
+  /**
+   * Reports an increase of `size` bytes of external memory.
+   */
+  void Increase(Isolate* isolate, size_t size);
+  /**
+   * Reports an update of `delta` bytes of external memory.
+   */
+  void Update(Isolate* isolate, int64_t delta);
+  /**
+   * Reports an decrease of `size` bytes of external memory.
+   */
+  void Decrease(Isolate* isolate, size_t size);
+
+ private:
+#ifdef V8_ENABLE_MEMORY_ACCOUNTING_CHECKS
+  size_t amount_of_external_memory_ = 0;
+  v8::Isolate* isolate_ = nullptr;
+#endif
+};
+
+}  // namespace v8
+
+#endif  // INCLUDE_EXTERNAL_MEMORY_ACCOUNTER_H_