Where Online Learning is simpler!

The C and C++ Include Header Files

/usr/include/nodejs/src/node_worker.h


$ cat -n /usr/include/nodejs/src/node_worker.h

     1	#ifndef SRC_NODE_WORKER_H_
     2	#define SRC_NODE_WORKER_H_
     3	
     4	#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
     5	
     6	#include <optional>
     7	#include <unordered_map>
     8	#include "node_messaging.h"
     9	#include "uv.h"
    10	
    11	namespace node {
    12	
    13	struct SnapshotData;
    14	namespace worker {
    15	
    16	class WorkerThreadData;
    17	
    18	enum ResourceLimits {
    19	  kMaxYoungGenerationSizeMb,
    20	  kMaxOldGenerationSizeMb,
    21	  kCodeRangeSizeMb,
    22	  kStackSizeMb,
    23	  kTotalResourceLimitCount
    24	};
    25	
    26	// A worker thread, as represented in its parent thread.
    27	class Worker : public AsyncWrap {
    28	 public:
    29	  Worker(Environment* env,
    30	         v8::Local<v8::Object> wrap,
    31	         const std::string& url,
    32	         const std::string& name,
    33	         std::shared_ptr<PerIsolateOptions> per_isolate_opts,
    34	         std::vector<std::string>&& exec_argv,
    35	         std::shared_ptr<KVStore> env_vars,
    36	         const SnapshotData* snapshot_data);
    37	  ~Worker() override;
    38	
    39	  // Run the worker. This is only called from the worker thread.
    40	  void Run();
    41	
    42	  // Forcibly exit the thread with a specified exit code. This may be called
    43	  // from any thread. `error_code` and `error_message` can be used to create
    44	  // a custom `'error'` event before emitting `'exit'`.
    45	  void Exit(int code,
    46	            const char* error_code = nullptr,
    47	            const char* error_message = nullptr);
    48	
    49	  // Wait for the worker thread to stop (in a blocking manner).
    50	  void JoinThread();
    51	
    52	  template <typename Fn>
    53	  inline bool RequestInterrupt(Fn&& cb);
    54	
    55	  SET_NO_MEMORY_INFO()
    56	  SET_MEMORY_INFO_NAME(Worker)
    57	  SET_SELF_SIZE(Worker)
    58	  bool IsNotIndicativeOfMemoryLeakAtExit() const override;
    59	
    60	  bool is_stopped() const;
    61	  const SnapshotData* snapshot_data() const { return snapshot_data_; }
    62	
    63	  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
    64	  static void CloneParentEnvVars(
    65	      const v8::FunctionCallbackInfo<v8::Value>& args);
    66	  static void SetEnvVars(const v8::FunctionCallbackInfo<v8::Value>& args);
    67	  static void StartThread(const v8::FunctionCallbackInfo<v8::Value>& args);
    68	  static void StopThread(const v8::FunctionCallbackInfo<v8::Value>& args);
    69	  static void HasRef(const v8::FunctionCallbackInfo<v8::Value>& args);
    70	  static void Ref(const v8::FunctionCallbackInfo<v8::Value>& args);
    71	  static void Unref(const v8::FunctionCallbackInfo<v8::Value>& args);
    72	  static void GetResourceLimits(
    73	      const v8::FunctionCallbackInfo<v8::Value>& args);
    74	  v8::Local<v8::Float64Array> GetResourceLimits(v8::Isolate* isolate) const;
    75	  static void TakeHeapSnapshot(const v8::FunctionCallbackInfo<v8::Value>& args);
    76	  static void LoopIdleTime(const v8::FunctionCallbackInfo<v8::Value>& args);
    77	  static void LoopStartTime(const v8::FunctionCallbackInfo<v8::Value>& args);
    78	
    79	 private:
    80	  bool CreateEnvMessagePort(Environment* env);
    81	  static size_t NearHeapLimit(void* data, size_t current_heap_limit,
    82	                              size_t initial_heap_limit);
    83	
    84	  std::shared_ptr<PerIsolateOptions> per_isolate_opts_;
    85	  std::vector<std::string> exec_argv_;
    86	  std::vector<std::string> argv_;
    87	
    88	  MultiIsolatePlatform* platform_;
    89	  v8::Isolate* isolate_ = nullptr;
    90	  std::optional<uv_thread_t> tid_;  // Set while the thread is running
    91	
    92	  std::unique_ptr<InspectorParentHandle> inspector_parent_handle_;
    93	
    94	  // This mutex protects access to all variables listed below it.
    95	  mutable Mutex mutex_;
    96	
    97	  const char* custom_error_ = nullptr;
    98	  std::string custom_error_str_;
    99	  int exit_code_ = 0;
   100	  ThreadId thread_id_;
   101	  uintptr_t stack_base_ = 0;
   102	  // Optional name used for debugging in inspector and trace events.
   103	  std::string name_;
   104	
   105	  // Custom resource constraints:
   106	  double resource_limits_[kTotalResourceLimitCount];
   107	  void UpdateResourceConstraints(v8::ResourceConstraints* constraints);
   108	
   109	  // Full size of the thread's stack.
   110	  size_t stack_size_ = 4 * 1024 * 1024;
   111	  // Stack buffer size that is not available to the JS engine.
   112	  static constexpr size_t kStackBufferSize = 192 * 1024;
   113	
   114	  std::unique_ptr<MessagePortData> child_port_data_;
   115	  std::shared_ptr<KVStore> env_vars_;
   116	
   117	  // A raw flag that is used by creator and worker threads to
   118	  // sync up on pre-mature termination of worker  - while in the
   119	  // warmup phase.  Once the worker is fully warmed up, use the
   120	  // async handle of the worker's Environment for the same purpose.
   121	  bool stopped_ = true;
   122	
   123	  bool has_ref_ = true;
   124	  uint64_t environment_flags_ = EnvironmentFlags::kNoFlags;
   125	
   126	  // The real Environment of the worker object. It has a lesser
   127	  // lifespan than the worker object itself - comes to life
   128	  // when the worker thread creates a new Environment, and gets
   129	  // destroyed alongwith the worker thread.
   130	  Environment* env_ = nullptr;
   131	
   132	  const SnapshotData* snapshot_data_ = nullptr;
   133	  friend class WorkerThreadData;
   134	};
   135	
   136	template <typename Fn>
   137	bool Worker::RequestInterrupt(Fn&& cb) {
   138	  Mutex::ScopedLock lock(mutex_);
   139	  if (env_ == nullptr) return false;
   140	  env_->RequestInterrupt(std::move(cb));
   141	  return true;
   142	}
   143	
   144	}  // namespace worker
   145	}  // namespace node
   146	
   147	#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
   148	
   149	
   150	#endif  // SRC_NODE_WORKER_H_