@encharm/cws 4.3.0 → 4.4.1

package/src/headers/20/node_perf_common.h

@@ -0,0 +1,98 @@
+#ifndef SRC_NODE_PERF_COMMON_H_
+#define SRC_NODE_PERF_COMMON_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "aliased_buffer.h"
+#include "node.h"
+#include "uv.h"
+#include "v8.h"
+
+#include <algorithm>
+#include <iostream>
+#include <map>
+#include <string>
+
+namespace node {
+namespace performance {
+
+#define PERFORMANCE_NOW() uv_hrtime()
+
+// These occur before the environment is created. Cache them
+// here and add them to the milestones when the env is init'd.
+extern const uint64_t performance_process_start;
+extern const double performance_process_start_timestamp;
+extern uint64_t performance_v8_start;
+
+#define NODE_PERFORMANCE_MILESTONES(V)                                         \
+  V(TIME_ORIGIN, "timeOrigin")                                                 \
+  V(ENVIRONMENT, "environment")                                                \
+  V(NODE_START, "nodeStart")                                                   \
+  V(V8_START, "v8Start")                                                       \
+  V(LOOP_START, "loopStart")                                                   \
+  V(LOOP_EXIT, "loopExit")                                                     \
+  V(BOOTSTRAP_COMPLETE, "bootstrapComplete")
+
+#define NODE_PERFORMANCE_ENTRY_TYPES(V)                                       \
+  V(GC, "gc")                                                                 \
+  V(HTTP, "http")                                                             \
+  V(HTTP2, "http2")                                                           \
+  V(NET, "net")                                                               \
+  V(DNS, "dns")
+
+enum PerformanceMilestone {
+#define V(name, _) NODE_PERFORMANCE_MILESTONE_##name,
+  NODE_PERFORMANCE_MILESTONES(V)
+#undef V
+  NODE_PERFORMANCE_MILESTONE_INVALID
+};
+
+enum PerformanceEntryType {
+#define V(name, _) NODE_PERFORMANCE_ENTRY_TYPE_##name,
+  NODE_PERFORMANCE_ENTRY_TYPES(V)
+#undef V
+  NODE_PERFORMANCE_ENTRY_TYPE_INVALID
+};
+
+class PerformanceState {
+ public:
+  struct SerializeInfo {
+    AliasedBufferIndex root;
+    AliasedBufferIndex milestones;
+    AliasedBufferIndex observers;
+  };
+
+  explicit PerformanceState(v8::Isolate* isolate,
+                            uint64_t time_origin,
+                            const SerializeInfo* info);
+  SerializeInfo Serialize(v8::Local<v8::Context> context,
+                          v8::SnapshotCreator* creator);
+  void Deserialize(v8::Local<v8::Context> context, uint64_t time_origin);
+  friend std::ostream& operator<<(std::ostream& o, const SerializeInfo& i);
+
+  AliasedUint8Array root;
+  AliasedFloat64Array milestones;
+  AliasedUint32Array observers;
+
+  uint64_t performance_last_gc_start_mark = 0;
+  uint16_t current_gc_type = 0;
+
+  void Mark(enum PerformanceMilestone milestone,
+            uint64_t ts = PERFORMANCE_NOW());
+
+ private:
+  void Initialize(uint64_t time_origin);
+  void ResetMilestones();
+  struct performance_state_internal {
+    // doubles first so that they are always sizeof(double)-aligned
+    double milestones[NODE_PERFORMANCE_MILESTONE_INVALID];
+    uint32_t observers[NODE_PERFORMANCE_ENTRY_TYPE_INVALID];
+  };
+};
+
+}  // namespace performance
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_PERF_COMMON_H_

package/src/headers/20/node_platform.h

@@ -0,0 +1,195 @@
+#ifndef SRC_NODE_PLATFORM_H_
+#define SRC_NODE_PLATFORM_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <queue>
+#include <unordered_map>
+#include <vector>
+#include <functional>
+
+#include "libplatform/libplatform.h"
+#include "node.h"
+#include "node_mutex.h"
+#include "uv.h"
+
+namespace node {
+
+class NodePlatform;
+class IsolateData;
+class PerIsolatePlatformData;
+
+template <class T>
+class TaskQueue {
+ public:
+  TaskQueue();
+  ~TaskQueue() = default;
+
+  void Push(std::unique_ptr<T> task);
+  std::unique_ptr<T> Pop();
+  std::unique_ptr<T> BlockingPop();
+  std::queue<std::unique_ptr<T>> PopAll();
+  void NotifyOfCompletion();
+  void BlockingDrain();
+  void Stop();
+
+ private:
+  Mutex lock_;
+  ConditionVariable tasks_available_;
+  ConditionVariable tasks_drained_;
+  int outstanding_tasks_;
+  bool stopped_;
+  std::queue<std::unique_ptr<T>> task_queue_;
+};
+
+struct DelayedTask {
+  std::unique_ptr<v8::Task> task;
+  uv_timer_t timer;
+  double timeout;
+  std::shared_ptr<PerIsolatePlatformData> platform_data;
+};
+
+// This acts as the foreground task runner for a given Isolate.
+class PerIsolatePlatformData :
+    public IsolatePlatformDelegate,
+    public v8::TaskRunner,
+    public std::enable_shared_from_this<PerIsolatePlatformData> {
+ public:
+  PerIsolatePlatformData(v8::Isolate* isolate, uv_loop_t* loop);
+  ~PerIsolatePlatformData() override;
+
+  std::shared_ptr<v8::TaskRunner> GetForegroundTaskRunner() override;
+  void PostTask(std::unique_ptr<v8::Task> task) override;
+  void PostIdleTask(std::unique_ptr<v8::IdleTask> task) override;
+  void PostDelayedTask(std::unique_ptr<v8::Task> task,
+                       double delay_in_seconds) override;
+  bool IdleTasksEnabled() override { return false; }
+
+  // Non-nestable tasks are treated like regular tasks.
+  bool NonNestableTasksEnabled() const override { return true; }
+  bool NonNestableDelayedTasksEnabled() const override { return true; }
+  void PostNonNestableTask(std::unique_ptr<v8::Task> task) override;
+  void PostNonNestableDelayedTask(std::unique_ptr<v8::Task> task,
+                                  double delay_in_seconds) override;
+
+  void AddShutdownCallback(void (*callback)(void*), void* data);
+  void Shutdown();
+
+  // Returns true if work was dispatched or executed. New tasks that are
+  // posted during flushing of the queue are postponed until the next
+  // flushing.
+  bool FlushForegroundTasksInternal();
+
+  const uv_loop_t* event_loop() const { return loop_; }
+
+ private:
+  void DeleteFromScheduledTasks(DelayedTask* task);
+  void DecreaseHandleCount();
+
+  static void FlushTasks(uv_async_t* handle);
+  void RunForegroundTask(std::unique_ptr<v8::Task> task);
+  static void RunForegroundTask(uv_timer_t* timer);
+
+  struct ShutdownCallback {
+    void (*cb)(void*);
+    void* data;
+  };
+  typedef std::vector<ShutdownCallback> ShutdownCbList;
+  ShutdownCbList shutdown_callbacks_;
+  // shared_ptr to self to keep this object alive during shutdown.
+  std::shared_ptr<PerIsolatePlatformData> self_reference_;
+  uint32_t uv_handle_count_ = 1;  // 1 = flush_tasks_
+
+  v8::Isolate* const isolate_;
+  uv_loop_t* const loop_;
+  uv_async_t* flush_tasks_ = nullptr;
+  TaskQueue<v8::Task> foreground_tasks_;
+  TaskQueue<DelayedTask> foreground_delayed_tasks_;
+
+  // Use a custom deleter because libuv needs to close the handle first.
+  typedef std::unique_ptr<DelayedTask, void(*)(DelayedTask*)>
+      DelayedTaskPointer;
+  std::vector<DelayedTaskPointer> scheduled_delayed_tasks_;
+};
+
+// This acts as the single worker thread task runner for all Isolates.
+class WorkerThreadsTaskRunner {
+ public:
+  explicit WorkerThreadsTaskRunner(int thread_pool_size);
+
+  void PostTask(std::unique_ptr<v8::Task> task);
+  void PostDelayedTask(std::unique_ptr<v8::Task> task,
+                       double delay_in_seconds);
+
+  void BlockingDrain();
+  void Shutdown();
+
+  int NumberOfWorkerThreads() const;
+
+ private:
+  TaskQueue<v8::Task> pending_worker_tasks_;
+
+  class DelayedTaskScheduler;
+  std::unique_ptr<DelayedTaskScheduler> delayed_task_scheduler_;
+
+  std::vector<std::unique_ptr<uv_thread_t>> threads_;
+};
+
+class NodePlatform : public MultiIsolatePlatform {
+ public:
+  NodePlatform(int thread_pool_size,
+               v8::TracingController* tracing_controller,
+               v8::PageAllocator* page_allocator = nullptr);
+  ~NodePlatform() override;
+
+  void DrainTasks(v8::Isolate* isolate) override;
+  void Shutdown();
+
+  // v8::Platform implementation.
+  int NumberOfWorkerThreads() override;
+  void CallOnWorkerThread(std::unique_ptr<v8::Task> task) override;
+  void CallDelayedOnWorkerThread(std::unique_ptr<v8::Task> task,
+                                 double delay_in_seconds) override;
+  bool IdleTasksEnabled(v8::Isolate* isolate) override;
+  double MonotonicallyIncreasingTime() override;
+  double CurrentClockTimeMillis() override;
+  v8::TracingController* GetTracingController() override;
+  bool FlushForegroundTasks(v8::Isolate* isolate) override;
+  std::unique_ptr<v8::JobHandle> CreateJob(
+      v8::TaskPriority priority,
+      std::unique_ptr<v8::JobTask> job_task) override;
+
+  void RegisterIsolate(v8::Isolate* isolate, uv_loop_t* loop) override;
+  void RegisterIsolate(v8::Isolate* isolate,
+                       IsolatePlatformDelegate* delegate) override;
+
+  void UnregisterIsolate(v8::Isolate* isolate) override;
+  void AddIsolateFinishedCallback(v8::Isolate* isolate,
+                                  void (*callback)(void*), void* data) override;
+
+  std::shared_ptr<v8::TaskRunner> GetForegroundTaskRunner(
+      v8::Isolate* isolate) override;
+
+  Platform::StackTracePrinter GetStackTracePrinter() override;
+  v8::PageAllocator* GetPageAllocator() override;
+
+ private:
+  IsolatePlatformDelegate* ForIsolate(v8::Isolate* isolate);
+  std::shared_ptr<PerIsolatePlatformData> ForNodeIsolate(v8::Isolate* isolate);
+
+  Mutex per_isolate_mutex_;
+  using DelegatePair = std::pair<
+    IsolatePlatformDelegate*, std::shared_ptr<PerIsolatePlatformData>>;
+  std::unordered_map<v8::Isolate*, DelegatePair> per_isolate_;
+
+  v8::TracingController* tracing_controller_;
+  v8::PageAllocator* page_allocator_;
+  std::shared_ptr<WorkerThreadsTaskRunner> worker_thread_task_runner_;
+  bool has_shut_down_ = false;
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_PLATFORM_H_

package/src/headers/20/node_process-inl.h

@@ -0,0 +1,26 @@
+#ifndef SRC_NODE_PROCESS_INL_H_
+#define SRC_NODE_PROCESS_INL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "node_process.h"
+#include "v8.h"
+#include "debug_utils-inl.h"
+
+namespace node {
+
+// Call process.emitWarning(str), fmt is a snprintf() format string
+template <typename... Args>
+inline v8::Maybe<bool> ProcessEmitWarning(Environment* env,
+                                          const char* fmt,
+                                          Args&&... args) {
+  std::string warning = SPrintF(fmt, std::forward<Args>(args)...);
+
+  return ProcessEmitWarningGeneric(env, warning.c_str());
+}
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_PROCESS_INL_H_

package/src/headers/20/node_process.h

@@ -0,0 +1,99 @@
+#ifndef SRC_NODE_PROCESS_H_
+#define SRC_NODE_PROCESS_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "node_snapshotable.h"
+#include "v8-fast-api-calls.h"
+#include "v8.h"
+
+namespace node {
+
+class Environment;
+class IsolateData;
+class MemoryTracker;
+class ExternalReferenceRegistry;
+class Realm;
+
+void CreateEnvProxyTemplate(v8::Isolate* isolate, IsolateData* isolate_data);
+
+// Most of the time, it's best to use `console.error` to write
+// to the process.stderr stream.  However, in some cases, such as
+// when debugging the stream.Writable class or the process.nextTick
+// function, it is useful to bypass JavaScript entirely.
+void RawDebug(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+v8::MaybeLocal<v8::Value> ProcessEmit(Environment* env,
+                                      const char* event,
+                                      v8::Local<v8::Value> message);
+
+v8::Maybe<bool> ProcessEmitWarningGeneric(Environment* env,
+                                          const char* warning,
+                                          const char* type = nullptr,
+                                          const char* code = nullptr);
+
+template <typename... Args>
+inline v8::Maybe<bool> ProcessEmitWarning(Environment* env,
+                                          const char* fmt,
+                                          Args&&... args);
+v8::Maybe<bool> ProcessEmitExperimentalWarning(Environment* env,
+                                              const char* warning);
+v8::Maybe<bool> ProcessEmitDeprecationWarning(Environment* env,
+                                              const char* warning,
+                                              const char* deprecation_code);
+
+v8::MaybeLocal<v8::Object> CreateProcessObject(Realm* env);
+void PatchProcessObject(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+namespace process {
+class BindingData : public SnapshotableObject {
+ public:
+  static void AddMethods(v8::Isolate* isolate,
+                         v8::Local<v8::ObjectTemplate> target);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+  using InternalFieldInfo = InternalFieldInfoBase;
+
+  SERIALIZABLE_OBJECT_METHODS()
+  SET_BINDING_ID(process_binding_data)
+
+  BindingData(Realm* realm, v8::Local<v8::Object> object);
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(BindingData)
+  SET_SELF_SIZE(BindingData)
+
+  static BindingData* FromV8Value(v8::Local<v8::Value> receiver);
+  static void NumberImpl(BindingData* receiver);
+
+  static void FastNumber(v8::Local<v8::Value> receiver) {
+    NumberImpl(FromV8Value(receiver));
+  }
+
+  static void SlowNumber(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  static void BigIntImpl(BindingData* receiver);
+
+  static void FastBigInt(v8::Local<v8::Value> receiver) {
+    BigIntImpl(FromV8Value(receiver));
+  }
+
+  static void SlowBigInt(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+ private:
+  static constexpr size_t kBufferSize =
+      std::max(sizeof(uint64_t), sizeof(uint32_t) * 3);
+  v8::Global<v8::ArrayBuffer> array_buffer_;
+  std::shared_ptr<v8::BackingStore> backing_store_;
+
+  // These need to be static so that we have their addresses available to
+  // register as external references in the snapshot at environment creation
+  // time.
+  static v8::CFunction fast_number_;
+  static v8::CFunction fast_bigint_;
+};
+
+}  // namespace process
+}  // namespace node
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#endif  // SRC_NODE_PROCESS_H_

package/src/headers/20/node_realm-inl.h

@@ -0,0 +1,139 @@
+#ifndef SRC_NODE_REALM_INL_H_
+#define SRC_NODE_REALM_INL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "cleanup_queue-inl.h"
+#include "node_realm.h"
+
+namespace node {
+
+inline Realm* Realm::GetCurrent(v8::Isolate* isolate) {
+  if (UNLIKELY(!isolate->InContext())) return nullptr;
+  v8::HandleScope handle_scope(isolate);
+  return GetCurrent(isolate->GetCurrentContext());
+}
+
+inline Realm* Realm::GetCurrent(v8::Local<v8::Context> context) {
+  if (UNLIKELY(!ContextEmbedderTag::IsNodeContext(context))) return nullptr;
+  return static_cast<Realm*>(
+      context->GetAlignedPointerFromEmbedderData(ContextEmbedderIndex::kRealm));
+}
+
+inline Realm* Realm::GetCurrent(
+    const v8::FunctionCallbackInfo<v8::Value>& info) {
+  return GetCurrent(info.GetIsolate()->GetCurrentContext());
+}
+
+template <typename T>
+inline Realm* Realm::GetCurrent(const v8::PropertyCallbackInfo<T>& info) {
+  return GetCurrent(info.GetIsolate()->GetCurrentContext());
+}
+
+inline IsolateData* Realm::isolate_data() const {
+  return env_->isolate_data();
+}
+
+inline Environment* Realm::env() const {
+  return env_;
+}
+
+inline v8::Isolate* Realm::isolate() const {
+  return isolate_;
+}
+
+inline Realm::Kind Realm::kind() const {
+  return kind_;
+}
+
+inline bool Realm::has_run_bootstrapping_code() const {
+  return has_run_bootstrapping_code_;
+}
+
+// static
+template <typename T, typename U>
+inline T* Realm::GetBindingData(const v8::PropertyCallbackInfo<U>& info) {
+  return GetBindingData<T>(info.GetIsolate()->GetCurrentContext());
+}
+
+// static
+template <typename T>
+inline T* Realm::GetBindingData(
+    const v8::FunctionCallbackInfo<v8::Value>& info) {
+  return GetBindingData<T>(info.GetIsolate()->GetCurrentContext());
+}
+
+// static
+template <typename T>
+inline T* Realm::GetBindingData(v8::Local<v8::Context> context) {
+  Realm* realm = GetCurrent(context);
+  return realm->GetBindingData<T>();
+}
+
+template <typename T>
+inline T* Realm::GetBindingData() {
+  constexpr size_t binding_index = static_cast<size_t>(T::binding_type_int);
+  static_assert(binding_index < std::tuple_size_v<BindingDataStore>);
+  auto ptr = binding_data_store_[binding_index];
+  if (UNLIKELY(!ptr)) return nullptr;
+  T* result = static_cast<T*>(ptr.get());
+  DCHECK_NOT_NULL(result);
+  return result;
+}
+
+template <typename T, typename... Args>
+inline T* Realm::AddBindingData(v8::Local<v8::Object> target, Args&&... args) {
+  // This won't compile if T is not a BaseObject subclass.
+  static_assert(std::is_base_of_v<BaseObject, T>);
+  // The binding data must be weak so that it won't keep the realm reachable
+  // from strong GC roots indefinitely. The wrapper object of binding data
+  // should be referenced from JavaScript, thus the binding data should be
+  // reachable throughout the lifetime of the realm.
+  BaseObjectWeakPtr<T> item =
+      MakeWeakBaseObject<T>(this, target, std::forward<Args>(args)...);
+  constexpr size_t binding_index = static_cast<size_t>(T::binding_type_int);
+  static_assert(binding_index < std::tuple_size_v<BindingDataStore>);
+  // Each slot is expected to be assigned only once.
+  CHECK(!binding_data_store_[binding_index]);
+  binding_data_store_[binding_index] = item;
+  return item.get();
+}
+
+inline BindingDataStore* Realm::binding_data_store() {
+  return &binding_data_store_;
+}
+
+template <typename T>
+void Realm::ForEachBaseObject(T&& iterator) const {
+  cleanup_queue_.ForEachBaseObject(std::forward<T>(iterator));
+}
+
+void Realm::modify_base_object_count(int64_t delta) {
+  base_object_count_ += delta;
+}
+
+int64_t Realm::base_object_created_after_bootstrap() const {
+  return base_object_count_ - base_object_created_by_bootstrap_;
+}
+
+int64_t Realm::base_object_count() const {
+  return base_object_count_;
+}
+
+void Realm::AddCleanupHook(CleanupQueue::Callback fn, void* arg) {
+  cleanup_queue_.Add(fn, arg);
+}
+
+void Realm::RemoveCleanupHook(CleanupQueue::Callback fn, void* arg) {
+  cleanup_queue_.Remove(fn, arg);
+}
+
+bool Realm::HasCleanupHooks() const {
+  return !cleanup_queue_.empty();
+}
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_REALM_INL_H_