@encharm/cws 4.1.0 → 4.2.0

package/src/headers/13/node_perf.h

@@ -1,181 +0,0 @@
-#ifndef SRC_NODE_PERF_H_
-#define SRC_NODE_PERF_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "node.h"
-#include "node_perf_common.h"
-#include "base_object-inl.h"
-#include "histogram-inl.h"
-
-#include "v8.h"
-#include "uv.h"
-
-#include <string>
-
-namespace node {
-
-class Environment;
-
-namespace performance {
-
-extern const uint64_t timeOrigin;
-
-static inline const char* GetPerformanceMilestoneName(
-    enum PerformanceMilestone milestone) {
-  switch (milestone) {
-#define V(name, label) case NODE_PERFORMANCE_MILESTONE_##name: return label;
-  NODE_PERFORMANCE_MILESTONES(V)
-#undef V
-    default:
-      UNREACHABLE();
-  }
-}
-
-static inline PerformanceMilestone ToPerformanceMilestoneEnum(const char* str) {
-#define V(name, label)                                                        \
-  if (strcmp(str, label) == 0) return NODE_PERFORMANCE_MILESTONE_##name;
-  NODE_PERFORMANCE_MILESTONES(V)
-#undef V
-  return NODE_PERFORMANCE_MILESTONE_INVALID;
-}
-
-static inline PerformanceEntryType ToPerformanceEntryTypeEnum(
-    const char* type) {
-#define V(name, label)                                                        \
-  if (strcmp(type, label) == 0) return NODE_PERFORMANCE_ENTRY_TYPE_##name;
-  NODE_PERFORMANCE_ENTRY_TYPES(V)
-#undef V
-  return NODE_PERFORMANCE_ENTRY_TYPE_INVALID;
-}
-
-class PerformanceEntry {
- public:
-  static void Notify(Environment* env,
-                     PerformanceEntryType type,
-                     v8::Local<v8::Value> object);
-
-  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  PerformanceEntry(Environment* env,
-                   const char* name,
-                   const char* type,
-                   uint64_t startTime,
-                   uint64_t endTime) : env_(env),
-                                       name_(name),
-                                       type_(type),
-                                       startTime_(startTime),
-                                       endTime_(endTime) { }
-
-  virtual ~PerformanceEntry() = default;
-
-  virtual v8::MaybeLocal<v8::Object> ToObject() const;
-
-  Environment* env() const { return env_; }
-
-  const std::string& name() const { return name_; }
-
-  const std::string& type() const { return type_; }
-
-  PerformanceEntryType kind() {
-    return ToPerformanceEntryTypeEnum(type().c_str());
-  }
-
-  double startTime() const { return startTimeNano() / 1e6; }
-
-  double duration() const { return durationNano() / 1e6; }
-
-  uint64_t startTimeNano() const { return startTime_ - timeOrigin; }
-
-  uint64_t durationNano() const { return endTime_ - startTime_; }
-
- private:
-  Environment* env_;
-  const std::string name_;
-  const std::string type_;
-  const uint64_t startTime_;
-  const uint64_t endTime_;
-};
-
-enum PerformanceGCKind {
-  NODE_PERFORMANCE_GC_MAJOR = v8::GCType::kGCTypeMarkSweepCompact,
-  NODE_PERFORMANCE_GC_MINOR = v8::GCType::kGCTypeScavenge,
-  NODE_PERFORMANCE_GC_INCREMENTAL = v8::GCType::kGCTypeIncrementalMarking,
-  NODE_PERFORMANCE_GC_WEAKCB = v8::GCType::kGCTypeProcessWeakCallbacks
-};
-
-enum PerformanceGCFlags {
-  NODE_PERFORMANCE_GC_FLAGS_NO =
-    v8::GCCallbackFlags::kNoGCCallbackFlags,
-  NODE_PERFORMANCE_GC_FLAGS_CONSTRUCT_RETAINED =
-    v8::GCCallbackFlags::kGCCallbackFlagConstructRetainedObjectInfos,
-  NODE_PERFORMANCE_GC_FLAGS_FORCED =
-    v8::GCCallbackFlags::kGCCallbackFlagForced,
-  NODE_PERFORMANCE_GC_FLAGS_SYNCHRONOUS_PHANTOM_PROCESSING =
-    v8::GCCallbackFlags::kGCCallbackFlagSynchronousPhantomCallbackProcessing,
-  NODE_PERFORMANCE_GC_FLAGS_ALL_AVAILABLE_GARBAGE =
-    v8::GCCallbackFlags::kGCCallbackFlagCollectAllAvailableGarbage,
-  NODE_PERFORMANCE_GC_FLAGS_ALL_EXTERNAL_MEMORY =
-    v8::GCCallbackFlags::kGCCallbackFlagCollectAllExternalMemory,
-  NODE_PERFORMANCE_GC_FLAGS_SCHEDULE_IDLE =
-    v8::GCCallbackFlags::kGCCallbackScheduleIdleGarbageCollection
-};
-
-class GCPerformanceEntry : public PerformanceEntry {
- public:
-  GCPerformanceEntry(Environment* env,
-                     PerformanceGCKind gckind,
-                     PerformanceGCFlags gcflags,
-                     uint64_t startTime,
-                     uint64_t endTime) :
-                         PerformanceEntry(env, "gc", "gc", startTime, endTime),
-                         gckind_(gckind),
-                         gcflags_(gcflags) { }
-
-  PerformanceGCKind gckind() const { return gckind_; }
-  PerformanceGCFlags gcflags() const { return gcflags_; }
-
- private:
-  PerformanceGCKind gckind_;
-  PerformanceGCFlags gcflags_;
-};
-
-class ELDHistogram : public HandleWrap, public Histogram {
- public:
-  ELDHistogram(Environment* env,
-               v8::Local<v8::Object> wrap,
-               int32_t resolution);
-
-  bool RecordDelta();
-  bool Enable();
-  bool Disable();
-  void ResetState() {
-    Reset();
-    exceeds_ = 0;
-    prev_ = 0;
-  }
-  int64_t Exceeds() const { return exceeds_; }
-
-  void MemoryInfo(MemoryTracker* tracker) const override {
-    tracker->TrackFieldWithSize("histogram", GetMemorySize());
-  }
-
-  SET_MEMORY_INFO_NAME(ELDHistogram)
-  SET_SELF_SIZE(ELDHistogram)
-
- private:
-  static void DelayIntervalCallback(uv_timer_t* req);
-
-  bool enabled_ = false;
-  int32_t resolution_ = 0;
-  int64_t exceeds_ = 0;
-  uint64_t prev_ = 0;
-  uv_timer_t timer_;
-};
-
-}  // namespace performance
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_NODE_PERF_H_

package/src/headers/13/node_perf_common.h

@@ -1,97 +0,0 @@
-#ifndef SRC_NODE_PERF_COMMON_H_
-#define SRC_NODE_PERF_COMMON_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "node.h"
-#include "uv.h"
-#include "v8.h"
-
-#include <algorithm>
-#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 uint64_t performance_v8_start;
-
-#define NODE_PERFORMANCE_MILESTONES(V)                                        \
-  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(NODE, "node")                                                             \
-  V(MARK, "mark")                                                             \
-  V(MEASURE, "measure")                                                       \
-  V(GC, "gc")                                                                 \
-  V(FUNCTION, "function")                                                     \
-  V(HTTP2, "http2")                                                           \
-  V(HTTP, "http")
-
-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:
-  explicit PerformanceState(v8::Isolate* isolate) :
-    root(
-      isolate,
-      sizeof(performance_state_internal)),
-    milestones(
-      isolate,
-      offsetof(performance_state_internal, milestones),
-      NODE_PERFORMANCE_MILESTONE_INVALID,
-      root),
-    observers(
-      isolate,
-      offsetof(performance_state_internal, observers),
-      NODE_PERFORMANCE_ENTRY_TYPE_INVALID,
-      root) {
-    for (size_t i = 0; i < milestones.Length(); i++)
-      milestones[i] = -1.;
-  }
-
-  AliasedUint8Array root;
-  AliasedFloat64Array milestones;
-  AliasedUint32Array observers;
-
-  uint64_t performance_last_gc_start_mark = 0;
-
-  void Mark(enum PerformanceMilestone milestone,
-            uint64_t ts = PERFORMANCE_NOW());
-
- private:
-  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/13/node_platform.h

@@ -1,190 +0,0 @@
-#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 "tracing/agent.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 v8::TaskRunner,
-    public std::enable_shared_from_this<PerIsolatePlatformData> {
- public:
-  PerIsolatePlatformData(v8::Isolate* isolate, uv_loop_t* loop);
-  ~PerIsolatePlatformData() 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,
-               node::tracing::TracingController* tracing_controller);
-  ~NodePlatform() override = default;
-
-  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;
-  void CallOnForegroundThread(v8::Isolate* isolate, v8::Task* task) override {
-    UNREACHABLE();
-  }
-  void CallDelayedOnForegroundThread(v8::Isolate* isolate,
-                                     v8::Task* task,
-                                     double delay_in_seconds) override {
-    UNREACHABLE();
-  }
-  bool IdleTasksEnabled(v8::Isolate* isolate) override;
-  double MonotonicallyIncreasingTime() override;
-  double CurrentClockTimeMillis() override;
-  node::tracing::TracingController* GetTracingController() override;
-  bool FlushForegroundTasks(v8::Isolate* isolate) override;
-
-  void RegisterIsolate(v8::Isolate* isolate, uv_loop_t* loop) 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;
-
- private:
-  std::shared_ptr<PerIsolatePlatformData> ForIsolate(v8::Isolate* isolate);
-
-  Mutex per_isolate_mutex_;
-  std::unordered_map<v8::Isolate*,
-                     std::shared_ptr<PerIsolatePlatformData>> per_isolate_;
-
-  node::tracing::TracingController* tracing_controller_;
-  std::shared_ptr<WorkerThreadsTaskRunner> worker_thread_task_runner_;
-};
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_NODE_PLATFORM_H_

package/src/headers/13/node_process.h

@@ -1,41 +0,0 @@
-#ifndef SRC_NODE_PROCESS_H_
-#define SRC_NODE_PROCESS_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "v8.h"
-
-namespace node {
-
-v8::MaybeLocal<v8::Object> CreateEnvVarProxy(v8::Local<v8::Context> context,
-                                             v8::Isolate* isolate,
-                                             v8::Local<v8::Object> 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);
-
-v8::Maybe<bool> ProcessEmitWarning(Environment* env, const char* fmt, ...);
-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(Environment* env);
-void PatchProcessObject(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-}  // namespace node
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-#endif  // SRC_NODE_PROCESS_H_