@encharm/cws 4.5.2 → 4.6.0

package/src/headers/26/timer_wrap.h

@@ -0,0 +1,87 @@
+#ifndef SRC_TIMER_WRAP_H_
+#define SRC_TIMER_WRAP_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "memory_tracker.h"
+#include "env.h"
+#include "uv.h"
+
+#include <functional>
+
+namespace node {
+
+// Utility class that makes working with libuv timers a bit easier.
+class TimerWrap final : public MemoryRetainer {
+ public:
+  using TimerCb = std::function<void()>;
+
+  template <typename... Args>
+  explicit inline TimerWrap(Environment* env, Args&&... args);
+
+  TimerWrap(const TimerWrap&) = delete;
+
+  inline Environment* env() const { return env_; }
+
+  // Stop calling the timer callback.
+  void Stop();
+  // Render the timer unusable and delete this object.
+  void Close();
+
+  // Starts / Restarts the Timer
+  void Update(uint64_t interval, uint64_t repeat = 0);
+
+  void Ref();
+  void Unref();
+
+  SET_NO_MEMORY_INFO()
+  SET_MEMORY_INFO_NAME(TimerWrap)
+  SET_SELF_SIZE(TimerWrap)
+
+ private:
+  static void TimerClosedCb(uv_handle_t* handle);
+  static void OnTimeout(uv_timer_t* timer);
+  ~TimerWrap() = default;
+
+  Environment* env_;
+  TimerCb fn_;
+  uv_timer_t timer_;
+
+  friend std::unique_ptr<TimerWrap>::deleter_type;
+};
+
+class TimerWrapHandle : public MemoryRetainer  {
+ public:
+  template <typename... Args>
+  explicit inline TimerWrapHandle(Environment* env, Args&&... args);
+
+  TimerWrapHandle(const TimerWrapHandle&) = delete;
+
+  ~TimerWrapHandle() { Close(); }
+
+  void Update(uint64_t interval, uint64_t repeat = 0);
+
+  inline operator bool() const { return timer_ != nullptr; }
+
+  void Ref();
+  void Unref();
+
+  void Stop();
+  void Close();
+
+  void MemoryInfo(node::MemoryTracker* tracker) const override;
+
+  SET_MEMORY_INFO_NAME(TimerWrapHandle)
+  SET_SELF_SIZE(TimerWrapHandle)
+
+ private:
+  static void CleanupHook(void* data);
+
+  TimerWrap* timer_;
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_TIMER_WRAP_H_

package/src/headers/26/timers.h

@@ -0,0 +1,70 @@
+#ifndef SRC_TIMERS_H_
+#define SRC_TIMERS_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <cinttypes>
+#include "node_snapshotable.h"
+
+namespace node {
+class ExternalReferenceRegistry;
+
+namespace timers {
+class BindingData : public SnapshotableObject {
+ public:
+  BindingData(Realm* env, v8::Local<v8::Object> obj);
+
+  using InternalFieldInfo = InternalFieldInfoBase;
+
+  SET_BINDING_ID(timers_binding_data)
+  SERIALIZABLE_OBJECT_METHODS()
+
+  SET_NO_MEMORY_INFO()
+  SET_SELF_SIZE(BindingData)
+  SET_MEMORY_INFO_NAME(BindingData)
+
+  static void SetupTimers(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  static void SlowGetLibuvNow(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static double FastGetLibuvNow(v8::Local<v8::Value> receiver);
+  static double GetLibuvNowImpl(BindingData* data);
+
+  static void SlowScheduleTimer(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void FastScheduleTimer(v8::Local<v8::Object> receiver,
+                                int64_t duration);
+  static void ScheduleTimerImpl(BindingData* data, int64_t duration);
+
+  static void SlowToggleTimerRef(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void FastToggleTimerRef(v8::Local<v8::Object> receiver, bool ref);
+  static void ToggleTimerRefImpl(BindingData* data, bool ref);
+
+  static void SlowToggleImmediateRef(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void FastToggleImmediateRef(v8::Local<v8::Object> receiver, bool ref);
+  static void ToggleImmediateRefImpl(BindingData* data, bool ref);
+
+  static void CreatePerIsolateProperties(IsolateData* isolate_data,
+                                         v8::Local<v8::ObjectTemplate> target);
+  static void CreatePerContextProperties(v8::Local<v8::Object> target,
+                                         v8::Local<v8::Value> unused,
+                                         v8::Local<v8::Context> context,
+                                         void* priv);
+  static void RegisterTimerExternalReferences(
+      ExternalReferenceRegistry* registry);
+
+ private:
+  static v8::CFunction fast_get_libuv_now_;
+  static v8::CFunction fast_schedule_timer_;
+  static v8::CFunction fast_toggle_timer_ref_;
+  static v8::CFunction fast_toggle_immediate_ref_;
+};
+
+}  // namespace timers
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_TIMERS_H_

package/src/headers/26/tracing/agent.h

@@ -0,0 +1,125 @@
+#ifndef SRC_TRACING_AGENT_H_
+#define SRC_TRACING_AGENT_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+// This defines a compatible agent interface for both the legacy V8
+// tracing and the Perfetto tracing. The interface is designed to be
+// used by the rest of the Node.js codebase that only generates
+// trace events with the trace macros, or interacts with the tracing
+// system.
+//
+// To generate trace events by API, or consume the tracing data, the
+// caller should directly refer to the derived trace agent interfaces.
+//
+// This file should not include either `libplatform/v8-tracing.h` or
+// `perfetto.h`.
+
+#include "v8-platform.h"
+
+#include <memory>
+#include <set>
+#include <string>
+
+namespace node {
+namespace tracing {
+
+class Agent;
+class AgentWriterHandle;
+
+class Agent {
+ public:
+  virtual ~Agent() = default;
+
+  virtual v8::TracingController* GetTracingController() = 0;
+
+  // Returns a comma-separated list of enabled categories.
+  virtual std::string GetEnabledCategories() const = 0;
+
+  // Called by V8Platform to start/stop file-based tracing.
+  virtual void StartTracing(const std::string& categories) = 0;
+  virtual void StopTracing() = 0;
+
+  virtual AgentWriterHandle* GetDefaultWriterHandle() = 0;
+
+  virtual void AddTraceStateObserver(
+      v8::TracingController::TraceStateObserver* observer) {}
+  virtual void RemoveTraceStateObserver(
+      v8::TracingController::TraceStateObserver* observer) {}
+
+  struct Deleter {
+    void operator()(Agent* agent);
+  };
+  static std::unique_ptr<Agent, Deleter> CreateDefault();
+  static Agent* GetInstance();
+
+ private:
+  virtual void Disconnect(int client) = 0;
+
+  virtual void Enable(int id, const std::set<std::string>& categories) = 0;
+  virtual void Disable(int id, const std::set<std::string>& categories) = 0;
+
+  friend class AgentWriterHandle;
+};
+
+class AgentWriterHandle {
+ public:
+  inline AgentWriterHandle() = default;
+  inline ~AgentWriterHandle() { reset(); }
+
+  inline AgentWriterHandle(AgentWriterHandle&& other);
+  inline AgentWriterHandle& operator=(AgentWriterHandle&& other);
+  inline bool empty() const { return agent_ == nullptr; }
+  inline void reset();
+
+  inline void Enable(const std::set<std::string>& categories);
+  inline void Disable(const std::set<std::string>& categories);
+
+  inline Agent* agent() { return agent_; }
+
+  AgentWriterHandle(const AgentWriterHandle& other) = delete;
+  AgentWriterHandle& operator=(const AgentWriterHandle& other) = delete;
+
+ private:
+  inline AgentWriterHandle(Agent* agent, int id) : agent_(agent), id_(id) {}
+
+  Agent* agent_ = nullptr;
+  int id_ = 0;
+
+  friend class Agent;
+  friend class LegacyTracingAgent;
+  friend class PerfettoTracingAgent;
+};
+
+void AgentWriterHandle::reset() {
+  if (agent_ != nullptr)
+    agent_->Disconnect(id_);
+  agent_ = nullptr;
+}
+
+AgentWriterHandle& AgentWriterHandle::operator=(AgentWriterHandle&& other) {
+  reset();
+  agent_ = other.agent_;
+  id_ = other.id_;
+  other.agent_ = nullptr;
+  return *this;
+}
+
+AgentWriterHandle::AgentWriterHandle(AgentWriterHandle&& other) {
+  *this = std::move(other);
+}
+
+void AgentWriterHandle::Enable(const std::set<std::string>& categories) {
+  if (agent_ != nullptr) agent_->Enable(id_, categories);
+}
+
+void AgentWriterHandle::Disable(const std::set<std::string>& categories) {
+  if (agent_ != nullptr) agent_->Disable(id_, categories);
+}
+
+}  // namespace tracing
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_TRACING_AGENT_H_

package/src/headers/26/tracing/agent_legacy.h

@@ -0,0 +1,146 @@
+#ifndef SRC_TRACING_AGENT_LEGACY_H_
+#define SRC_TRACING_AGENT_LEGACY_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+// This is an implementation of the legacy V8 tracing agent
+// defined in `libplatform/v8-tracing.h`.
+
+#ifdef V8_USE_PERFETTO
+#error Perfetto is enabled.
+#endif
+
+#include "libplatform/v8-tracing.h"
+#include "node_mutex.h"
+#include "tracing/agent.h"
+#include "util.h"
+#include "uv.h"
+
+#include <list>
+#include <set>
+#include <string>
+#include <unordered_map>
+
+namespace node {
+namespace tracing {
+
+using v8::platform::tracing::TraceConfig;
+using v8::platform::tracing::TraceObject;
+
+class AsyncTraceWriter {
+ public:
+  virtual ~AsyncTraceWriter() = default;
+  virtual void AppendTraceEvent(TraceObject* trace_event) = 0;
+  virtual void Flush(bool blocking) = 0;
+  virtual void InitializeOnThread(uv_loop_t* loop) {}
+};
+
+class TracingController : public v8::platform::tracing::TracingController {
+ public:
+  TracingController() : v8::platform::tracing::TracingController() {}
+
+  int64_t CurrentTimestampMicroseconds() override { return uv_hrtime() / 1000; }
+  void AddMetadataEvent(
+      const unsigned char* category_group_enabled,
+      const char* name,
+      int num_args,
+      const char** arg_names,
+      const unsigned char* arg_types,
+      const uint64_t* arg_values,
+      std::unique_ptr<v8::ConvertableToTraceFormat>* convertable_values,
+      unsigned int flags);
+};
+
+class NodeTraceStateObserver
+    : public v8::TracingController::TraceStateObserver {
+ public:
+  void OnTraceEnabled() override;
+  void OnTraceDisabled() override { UNREACHABLE(); }
+
+  explicit NodeTraceStateObserver(v8::TracingController* controller)
+      : controller_(controller) {}
+  ~NodeTraceStateObserver() override = default;
+
+ private:
+  v8::TracingController* controller_;
+};
+
+class LegacyTracingAgent final : public Agent {
+ public:
+  enum UseDefaultCategoryMode {
+    kUseDefaultCategories,
+    kIgnoreDefaultCategories
+  };
+
+  LegacyTracingAgent();
+  ~LegacyTracingAgent() override;
+
+  TracingController* GetTracingController() override {
+    TracingController* controller = tracing_controller_.get();
+    CHECK_NOT_NULL(controller);
+    return controller;
+  }
+
+  AgentWriterHandle AddClient(const std::set<std::string>& categories,
+                              std::unique_ptr<AsyncTraceWriter> writer,
+                              enum UseDefaultCategoryMode mode);
+  std::string GetEnabledCategories() const override;
+  void AppendTraceEvent(TraceObject* trace_event);
+  void AddMetadataEvent(std::unique_ptr<TraceObject> event);
+  void Flush(bool blocking);
+  TraceConfig* CreateTraceConfig() const;
+
+  void StartTracing(const std::string& categories) override;
+  void StopTracing() override;
+  AgentWriterHandle* GetDefaultWriterHandle() override;
+
+  void AddTraceStateObserver(
+      v8::TracingController::TraceStateObserver* observer) override {
+    tracing_controller_->AddTraceStateObserver(observer);
+  }
+  void RemoveTraceStateObserver(
+      v8::TracingController::TraceStateObserver* observer) override {
+    tracing_controller_->RemoveTraceStateObserver(observer);
+  }
+
+ private:
+  static constexpr int kDefaultHandleId = -1;
+
+  void Disconnect(int client) override;
+
+  void Enable(int id, const std::set<std::string>& categories) override;
+  void Disable(int id, const std::set<std::string>& categories) override;
+
+  void InitializeWritersOnThread();
+  void Start();
+  void Stop();
+
+  uv_thread_t thread_;
+  uv_loop_t tracing_loop_;
+
+  bool started_ = false;
+  class ScopedSuspendTracing;
+
+  int next_writer_id_ = 1;
+  std::unordered_map<int, std::multiset<std::string>> categories_;
+  std::unordered_map<int, std::unique_ptr<AsyncTraceWriter>> writers_;
+  std::unique_ptr<TracingController> tracing_controller_;
+
+  Mutex initialize_writer_mutex_;
+  ConditionVariable initialize_writer_condvar_;
+  uv_async_t initialize_writer_async_;
+  std::set<AsyncTraceWriter*> to_be_initialized_;
+
+  Mutex metadata_events_mutex_;
+  std::list<std::unique_ptr<TraceObject>> metadata_events_;
+
+  AgentWriterHandle tracing_file_writer_;
+  std::unique_ptr<NodeTraceStateObserver> trace_state_observer_;
+};
+
+}  // namespace tracing
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_TRACING_AGENT_LEGACY_H_

package/src/headers/26/tracing/agent_perfetto.h

@@ -0,0 +1,145 @@
+#ifndef SRC_TRACING_AGENT_PERFETTO_H_
+#define SRC_TRACING_AGENT_PERFETTO_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "node_mutex.h"
+#include "tracing/agent.h"
+#include "tracing/trace_event_perfetto.h"
+#include "util.h"
+#include "uv.h"
+#include "v8-platform.h"
+
+#include <list>
+#include <set>
+#include <string>
+#include <unordered_map>
+
+namespace node::tracing {
+
+// Consumes trace data produced by a PerfettoSessionReader. All methods run on
+// the agent's dedicated background tracing thread (the loop passed to
+// InitializeOnThread), never on the application's main thread or Perfetto's
+// internal thread, so implementations may block (e.g. do synchronous I/O).
+class TraceWriter {
+ public:
+  virtual ~TraceWriter() = default;
+  // 'chunk' is guaranteed to contain 1 or more full trace packets, which
+  // can be decoded using trace.proto. No partial or truncated packets are
+  // exposed.
+  virtual void AppendTraceChunk(std::vector<char> chunk) = 0;
+  virtual void Flush(bool blocking) = 0;
+  virtual void InitializeOnThread(uv_loop_t* loop) {}
+};
+
+// Owns one Perfetto tracing session and pumps its trace data out to a
+// TraceWriter using the consumer ReadTrace() API, reading on a fixed period.
+//
+// Threading: two threads are involved.
+//   - Perfetto's internal thread invokes ReadTraceCallback. It only copies the
+//     borrowed chunk into pending_chunks_ (under chunks_mutex_) and signals
+//     read_async_; it never touches the writer or the file.
+//   - The agent's dedicated tracing loop thread runs everything else. A
+//     repeating timer (read_timer_) starts a read every kReadPeriodMs, and
+//     OnReadAsync drains pending_chunks_ into the writer there. This is why the
+//     writer can safely block on synchronous I/O (see TraceWriter).
+// read_in_progress_ prevents a timer tick from starting a new read while a
+// previous ReadTrace() cycle is still delivering chunks.
+class PerfettoSessionReader final {
+ public:
+  struct Deleter {
+    void operator()(PerfettoSessionReader* ptr) const noexcept;
+  };
+  using Ptr = std::unique_ptr<PerfettoSessionReader, Deleter>;
+  static Ptr Create(perfetto::TraceConfig config,
+                    std::unique_ptr<TraceWriter> writer) {
+    return Ptr(new PerfettoSessionReader(config, std::move(writer)));
+  }
+
+  void ChangeTraceConfig(perfetto::TraceConfig config);
+
+  void InitializeOnThread(uv_loop_t* loop);
+
+ private:
+  explicit PerfettoSessionReader(perfetto::TraceConfig config,
+                                 std::unique_ptr<TraceWriter> writer);
+  ~PerfettoSessionReader();
+  void ReadTraceCallback(perfetto::TracingSession::ReadTraceCallbackArgs args);
+  void SessionStopCallback();
+  void Read();
+
+  static void OnReadAsync(uv_async_t* async);
+  static void OnReadTimer(uv_timer_t* timer);
+  static void OnHandleClose(uv_handle_t* handle);
+
+  uv_loop_t* tracing_loop_;
+  uv_async_t read_async_;
+  uv_timer_t read_timer_;
+  int handles_pending_close_ = 0;
+  std::atomic<bool> stop_requested_ = false;
+  std::atomic<bool> read_in_progress_ = false;
+
+  Mutex chunks_mutex_;
+  std::list<std::vector<char>> pending_chunks_;
+  std::unique_ptr<perfetto::TracingSession> tracing_session_ = nullptr;
+
+  std::unique_ptr<TraceWriter> writer_;
+};
+
+class PerfettoTracingAgent final : public Agent {
+ public:
+  enum UseDefaultCategoryMode {
+    kUseDefaultCategories,
+    kIgnoreDefaultCategories
+  };
+
+  PerfettoTracingAgent();
+  ~PerfettoTracingAgent() override;
+
+  v8::TracingController* GetTracingController() override { return nullptr; }
+
+  AgentWriterHandle AddClient(const std::set<std::string>& categories,
+                              std::unique_ptr<TraceWriter> writer,
+                              enum UseDefaultCategoryMode mode);
+  std::string GetEnabledCategories() const override;
+
+  void StartTracing(const std::string& categories) override;
+  void StopTracing() override;
+  AgentWriterHandle* GetDefaultWriterHandle() override;
+
+ private:
+  static constexpr int kDefaultHandleId = -1;
+
+  void Disconnect(int client) override;
+
+  void Enable(int id, const std::set<std::string>& categories) override;
+  void Disable(int id, const std::set<std::string>& categories) override;
+
+  void InitializeWritersOnThread();
+  void Start();
+
+  perfetto::TraceConfig CreateTraceConfig(
+      std::multiset<std::string> categories) const;
+
+  uv_thread_t thread_;
+  uv_loop_t tracing_loop_;
+
+  bool started_ = false;
+
+  int next_writer_id_ = 1;
+  std::unordered_map<int, std::multiset<std::string>> categories_;
+  std::unordered_map<int, PerfettoSessionReader::Ptr> writers_;
+
+  Mutex initialize_writer_mutex_;
+  ConditionVariable initialize_writer_condvar_;
+  uv_async_t initialize_writer_async_;
+  std::set<PerfettoSessionReader*> to_be_initialized_;
+
+  std::optional<AgentWriterHandle> tracing_file_writer_;
+};
+
+}  // namespace node::tracing
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_TRACING_AGENT_PERFETTO_H_

package/src/headers/26/tracing/node_trace_buffer.h

@@ -0,0 +1,91 @@
+#ifndef SRC_TRACING_NODE_TRACE_BUFFER_H_
+#define SRC_TRACING_NODE_TRACE_BUFFER_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "libplatform/v8-tracing.h"
+#include "node_mutex.h"
+#include "tracing/agent_legacy.h"
+
+#include <atomic>
+
+namespace node {
+namespace tracing {
+
+using v8::platform::tracing::TraceBuffer;
+using v8::platform::tracing::TraceBufferChunk;
+using v8::platform::tracing::TraceObject;
+
+// forward declaration
+class NodeTraceBuffer;
+
+class InternalTraceBuffer {
+ public:
+  InternalTraceBuffer(size_t max_chunks,
+                      uint32_t id,
+                      LegacyTracingAgent* agent);
+
+  TraceObject* AddTraceEvent(uint64_t* handle);
+  TraceObject* GetEventByHandle(uint64_t handle);
+  void Flush(bool blocking);
+  bool IsFull() const {
+    return total_chunks_ == max_chunks_ && chunks_[total_chunks_ - 1]->IsFull();
+  }
+  bool IsFlushing() const {
+    return flushing_;
+  }
+
+ private:
+  uint64_t MakeHandle(size_t chunk_index, uint32_t chunk_seq,
+                      size_t event_index) const;
+  void ExtractHandle(uint64_t handle, uint32_t* buffer_id, size_t* chunk_index,
+                     uint32_t* chunk_seq, size_t* event_index) const;
+  size_t Capacity() const { return max_chunks_ * TraceBufferChunk::kChunkSize; }
+
+  Mutex mutex_;
+  bool flushing_;
+  size_t max_chunks_;
+  LegacyTracingAgent* agent_;
+  std::vector<std::unique_ptr<TraceBufferChunk>> chunks_;
+  size_t total_chunks_ = 0;
+  uint32_t current_chunk_seq_ = 1;
+  uint32_t id_;
+};
+
+class NodeTraceBuffer : public TraceBuffer {
+ public:
+  NodeTraceBuffer(size_t max_chunks,
+                  LegacyTracingAgent* agent,
+                  uv_loop_t* tracing_loop);
+  ~NodeTraceBuffer() override;
+
+  TraceObject* AddTraceEvent(uint64_t* handle) override;
+  TraceObject* GetEventByHandle(uint64_t handle) override;
+  bool Flush() override;
+
+  static const size_t kBufferChunks = 1024;
+
+ private:
+  bool TryLoadAvailableBuffer();
+  static void NonBlockingFlushSignalCb(uv_async_t* signal);
+  static void ExitSignalCb(uv_async_t* signal);
+
+  uv_loop_t* tracing_loop_;
+  uv_async_t flush_signal_;
+  uv_async_t exit_signal_;
+  bool exited_ = false;
+  // Used exclusively for exit logic.
+  Mutex exit_mutex_;
+  // Used to wait until async handles have been closed.
+  ConditionVariable exit_cond_;
+  std::atomic<InternalTraceBuffer*> current_buf_;
+  InternalTraceBuffer buffer1_;
+  InternalTraceBuffer buffer2_;
+};
+
+}  // namespace tracing
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_TRACING_NODE_TRACE_BUFFER_H_