Skip to content

Commit 58cec4e

Browse files
bnoordhuisbnoordhuis
committed
src: move env init logic into Environment class
PR-URL: #7090 Reviewed-By: James M Snell <[email protected]> Reviewed-By: Trevor Norris <[email protected]>
1 parent 138c7af commit 58cec4e

File tree

5 files changed

+107
-120
lines changed

5 files changed

+107
-120
lines changed

‎src/env-inl.h

-17
Original file line numberDiff line numberDiff line change
@@ -260,23 +260,6 @@ inline uv_idle_t* Environment::immediate_idle_handle() {
260260
return &immediate_idle_handle_;
261261
}
262262

263-
inline Environment* Environment::from_idle_prepare_handle(
264-
uv_prepare_t* handle) {
265-
return ContainerOf(&Environment::idle_prepare_handle_, handle);
266-
}
267-
268-
inline uv_prepare_t* Environment::idle_prepare_handle() {
269-
return &idle_prepare_handle_;
270-
}
271-
272-
inline Environment* Environment::from_idle_check_handle(uv_check_t* handle) {
273-
return ContainerOf(&Environment::idle_check_handle_, handle);
274-
}
275-
276-
inline uv_check_t* Environment::idle_check_handle() {
277-
return &idle_check_handle_;
278-
}
279-
280263
inline void Environment::RegisterHandleCleanup(uv_handle_t* handle,
281264
HandleCleanupCb cb,
282265
void *arg) {

‎src/env.cc

+90
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,8 @@
11
#include "env.h"
22
#include "env-inl.h"
3+
#include "async-wrap.h"
34
#include "v8.h"
5+
#include "v8-profiler.h"
46

57
#if defined(_MSC_VER)
68
#define getpid GetCurrentProcessId
@@ -12,13 +14,101 @@
1214

1315
namespace node {
1416

17+
using v8::Context;
18+
using v8::FunctionTemplate;
1519
using v8::HandleScope;
1620
using v8::Local;
1721
using v8::Message;
1822
using v8::StackFrame;
1923
using v8::StackTrace;
2024
using v8::Value;
2125

26+
void Environment::Start(int argc,
27+
const char* const* argv,
28+
int exec_argc,
29+
const char* const* exec_argv,
30+
bool start_profiler_idle_notifier) {
31+
HandleScope handle_scope(isolate());
32+
Context::Scope context_scope(context());
33+
34+
isolate()->SetAutorunMicrotasks(false);
35+
36+
uv_check_init(event_loop(), immediate_check_handle());
37+
uv_unref(reinterpret_cast<uv_handle_t*>(immediate_check_handle()));
38+
39+
uv_idle_init(event_loop(), immediate_idle_handle());
40+
41+
// Inform V8's CPU profiler when we're idle. The profiler is sampling-based
42+
// but not all samples are created equal; mark the wall clock time spent in
43+
// epoll_wait() and friends so profiling tools can filter it out. The samples
44+
// still end up in v8.log but with state=IDLE rather than state=EXTERNAL.
45+
// TODO(bnoordhuis) Depends on a libuv implementation detail that we should
46+
// probably fortify in the API contract, namely that the last started prepare
47+
// or check watcher runs first. It's not 100% foolproof; if an add-on starts
48+
// a prepare or check watcher after us, any samples attributed to its callback
49+
// will be recorded with state=IDLE.
50+
uv_prepare_init(event_loop(), &idle_prepare_handle_);
51+
uv_check_init(event_loop(), &idle_check_handle_);
52+
uv_unref(reinterpret_cast<uv_handle_t*>(&idle_prepare_handle_));
53+
uv_unref(reinterpret_cast<uv_handle_t*>(&idle_check_handle_));
54+
55+
auto close_and_finish = [](Environment* env, uv_handle_t* handle, void* arg) {
56+
handle->data = env;
57+
58+
uv_close(handle, [](uv_handle_t* handle) {
59+
static_cast<Environment*>(handle->data)->FinishHandleCleanup(handle);
60+
});
61+
};
62+
63+
RegisterHandleCleanup(
64+
reinterpret_cast<uv_handle_t*>(immediate_check_handle()),
65+
close_and_finish,
66+
nullptr);
67+
RegisterHandleCleanup(
68+
reinterpret_cast<uv_handle_t*>(immediate_idle_handle()),
69+
close_and_finish,
70+
nullptr);
71+
RegisterHandleCleanup(
72+
reinterpret_cast<uv_handle_t*>(&idle_prepare_handle_),
73+
close_and_finish,
74+
nullptr);
75+
RegisterHandleCleanup(
76+
reinterpret_cast<uv_handle_t*>(&idle_check_handle_),
77+
close_and_finish,
78+
nullptr);
79+
80+
if (start_profiler_idle_notifier) {
81+
StartProfilerIdleNotifier();
82+
}
83+
84+
auto process_template = FunctionTemplate::New(isolate());
85+
process_template->SetClassName(FIXED_ONE_BYTE_STRING(isolate(), "process"));
86+
87+
auto process_object =
88+
process_template->GetFunction()->NewInstance(context()).ToLocalChecked();
89+
set_process_object(process_object);
90+
91+
SetupProcessObject(this, argc, argv, exec_argc, exec_argv);
92+
LoadAsyncWrapperInfo(this);
93+
}
94+
95+
void Environment::StartProfilerIdleNotifier() {
96+
uv_prepare_start(&idle_prepare_handle_, [](uv_prepare_t* handle) {
97+
Environment* env = ContainerOf(&Environment::idle_prepare_handle_, handle);
98+
env->isolate()->GetCpuProfiler()->SetIdle(true);
99+
});
100+
101+
uv_check_start(&idle_check_handle_, [](uv_check_t* handle) {
102+
Environment* env = ContainerOf(&Environment::idle_check_handle_, handle);
103+
env->isolate()->GetCpuProfiler()->SetIdle(false);
104+
});
105+
}
106+
107+
void Environment::StopProfilerIdleNotifier() {
108+
uv_prepare_stop(&idle_prepare_handle_);
109+
uv_check_stop(&idle_check_handle_);
110+
}
111+
22112
void Environment::PrintSyncTrace() const {
23113
if (!trace_sync_io_)
24114
return;

‎src/env.h

+8-6
Original file line numberDiff line numberDiff line change
@@ -449,11 +449,19 @@ class Environment {
449449
// See CreateEnvironment() in src/node.cc.
450450
static inline Environment* New(IsolateData* isolate_data,
451451
v8::Local<v8::Context> context);
452+
void Start(int argc,
453+
const char* const* argv,
454+
int exec_argc,
455+
const char* const* exec_argv,
456+
bool start_profiler_idle_notifier);
452457
inline void CleanupHandles();
453458
inline void Dispose();
454459

455460
void AssignToContext(v8::Local<v8::Context> context);
456461

462+
void StartProfilerIdleNotifier();
463+
void StopProfilerIdleNotifier();
464+
457465
inline v8::Isolate* isolate() const;
458466
inline uv_loop_t* event_loop() const;
459467
inline bool async_wrap_callbacks_enabled() const;
@@ -464,12 +472,6 @@ class Environment {
464472
inline uv_check_t* immediate_check_handle();
465473
inline uv_idle_t* immediate_idle_handle();
466474

467-
static inline Environment* from_idle_prepare_handle(uv_prepare_t* handle);
468-
inline uv_prepare_t* idle_prepare_handle();
469-
470-
static inline Environment* from_idle_check_handle(uv_check_t* handle);
471-
inline uv_check_t* idle_check_handle();
472-
473475
// Register clean-up cb to be called on env->Dispose()
474476
inline void RegisterHandleCleanup(uv_handle_t* handle,
475477
HandleCleanupCb cb,

‎src/node.cc

+3-97
Original file line numberDiff line numberDiff line change
@@ -101,7 +101,6 @@ using v8::Exception;
101101
using v8::Float64Array;
102102
using v8::Function;
103103
using v8::FunctionCallbackInfo;
104-
using v8::FunctionTemplate;
105104
using v8::HandleScope;
106105
using v8::HeapStatistics;
107106
using v8::Integer;
@@ -2864,39 +2863,15 @@ static void NeedImmediateCallbackSetter(
28642863
}
28652864

28662865

2867-
void SetIdle(uv_prepare_t* handle) {
2868-
Environment* env = Environment::from_idle_prepare_handle(handle);
2869-
env->isolate()->GetCpuProfiler()->SetIdle(true);
2870-
}
2871-
2872-
2873-
void ClearIdle(uv_check_t* handle) {
2874-
Environment* env = Environment::from_idle_check_handle(handle);
2875-
env->isolate()->GetCpuProfiler()->SetIdle(false);
2876-
}
2877-
2878-
2879-
void StartProfilerIdleNotifier(Environment* env) {
2880-
uv_prepare_start(env->idle_prepare_handle(), SetIdle);
2881-
uv_check_start(env->idle_check_handle(), ClearIdle);
2882-
}
2883-
2884-
2885-
void StopProfilerIdleNotifier(Environment* env) {
2886-
uv_prepare_stop(env->idle_prepare_handle());
2887-
uv_check_stop(env->idle_check_handle());
2888-
}
2889-
2890-
28912866
void StartProfilerIdleNotifier(const FunctionCallbackInfo<Value>& args) {
28922867
Environment* env = Environment::GetCurrent(args);
2893-
StartProfilerIdleNotifier(env);
2868+
env->StartProfilerIdleNotifier();
28942869
}
28952870

28962871

28972872
void StopProfilerIdleNotifier(const FunctionCallbackInfo<Value>& args) {
28982873
Environment* env = Environment::GetCurrent(args);
2899-
StopProfilerIdleNotifier(env);
2874+
env->StopProfilerIdleNotifier();
29002875
}
29012876

29022877

@@ -4262,20 +4237,6 @@ int EmitExit(Environment* env) {
42624237
}
42634238

42644239

4265-
static void HandleCloseCb(uv_handle_t* handle) {
4266-
Environment* env = reinterpret_cast<Environment*>(handle->data);
4267-
env->FinishHandleCleanup(handle);
4268-
}
4269-
4270-
4271-
static void HandleCleanup(Environment* env,
4272-
uv_handle_t* handle,
4273-
void* arg) {
4274-
handle->data = env;
4275-
uv_close(handle, HandleCloseCb);
4276-
}
4277-
4278-
42794240
IsolateData* CreateIsolateData(Isolate* isolate, uv_loop_t* loop) {
42804241
return new IsolateData(isolate, loop);
42814242
}
@@ -4294,64 +4255,9 @@ Environment* CreateEnvironment(IsolateData* isolate_data,
42944255
const char* const* exec_argv) {
42954256
Isolate* isolate = context->GetIsolate();
42964257
HandleScope handle_scope(isolate);
4297-
42984258
Context::Scope context_scope(context);
42994259
Environment* env = Environment::New(isolate_data, context);
4300-
4301-
isolate->SetAutorunMicrotasks(false);
4302-
4303-
uv_check_init(env->event_loop(), env->immediate_check_handle());
4304-
uv_unref(
4305-
reinterpret_cast<uv_handle_t*>(env->immediate_check_handle()));
4306-
4307-
uv_idle_init(env->event_loop(), env->immediate_idle_handle());
4308-
4309-
// Inform V8's CPU profiler when we're idle. The profiler is sampling-based
4310-
// but not all samples are created equal; mark the wall clock time spent in
4311-
// epoll_wait() and friends so profiling tools can filter it out. The samples
4312-
// still end up in v8.log but with state=IDLE rather than state=EXTERNAL.
4313-
// TODO(bnoordhuis) Depends on a libuv implementation detail that we should
4314-
// probably fortify in the API contract, namely that the last started prepare
4315-
// or check watcher runs first. It's not 100% foolproof; if an add-on starts
4316-
// a prepare or check watcher after us, any samples attributed to its callback
4317-
// will be recorded with state=IDLE.
4318-
uv_prepare_init(env->event_loop(), env->idle_prepare_handle());
4319-
uv_check_init(env->event_loop(), env->idle_check_handle());
4320-
uv_unref(reinterpret_cast<uv_handle_t*>(env->idle_prepare_handle()));
4321-
uv_unref(reinterpret_cast<uv_handle_t*>(env->idle_check_handle()));
4322-
4323-
// Register handle cleanups
4324-
env->RegisterHandleCleanup(
4325-
reinterpret_cast<uv_handle_t*>(env->immediate_check_handle()),
4326-
HandleCleanup,
4327-
nullptr);
4328-
env->RegisterHandleCleanup(
4329-
reinterpret_cast<uv_handle_t*>(env->immediate_idle_handle()),
4330-
HandleCleanup,
4331-
nullptr);
4332-
env->RegisterHandleCleanup(
4333-
reinterpret_cast<uv_handle_t*>(env->idle_prepare_handle()),
4334-
HandleCleanup,
4335-
nullptr);
4336-
env->RegisterHandleCleanup(
4337-
reinterpret_cast<uv_handle_t*>(env->idle_check_handle()),
4338-
HandleCleanup,
4339-
nullptr);
4340-
4341-
if (v8_is_profiling) {
4342-
StartProfilerIdleNotifier(env);
4343-
}
4344-
4345-
Local<FunctionTemplate> process_template = FunctionTemplate::New(isolate);
4346-
process_template->SetClassName(FIXED_ONE_BYTE_STRING(isolate, "process"));
4347-
4348-
Local<Object> process_object =
4349-
process_template->GetFunction()->NewInstance(context).ToLocalChecked();
4350-
env->set_process_object(process_object);
4351-
4352-
SetupProcessObject(env, argc, argv, exec_argc, exec_argv);
4353-
LoadAsyncWrapperInfo(env);
4354-
4260+
env->Start(argc, argv, exec_argc, exec_argv, v8_is_profiling);
43554261
return env;
43564262
}
43574263

‎src/node_internals.h

+6
Original file line numberDiff line numberDiff line change
@@ -145,6 +145,12 @@ NO_RETURN void FatalError(const char* location, const char* message);
145145

146146
v8::Local<v8::Value> BuildStatsObject(Environment* env, const uv_stat_t* s);
147147

148+
void SetupProcessObject(Environment* env,
149+
int argc,
150+
const char* const* argv,
151+
int exec_argc,
152+
const char* const* exec_argv);
153+
148154
enum Endianness {
149155
kLittleEndian, // _Not_ LITTLE_ENDIAN, clashes with endian.h.
150156
kBigEndian

0 commit comments

Comments
 (0)