Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

src: clean up program/isolate/env init logic #9224

Merged
merged 2 commits into from
Oct 24, 2016
Merged

src: clean up program/isolate/env init logic #9224

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
d77e818
src: simplify code, remove NodeInstanceData
bnoordhuis Oct 21, 2016
ceb6023
src: clean up program/isolate/env init logic
bnoordhuis Oct 21, 2016
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 0 additions & 2 deletions src/env.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -30,8 +30,6 @@ void Environment::Start(int argc,
HandleScope handle_scope(isolate());
Context::Scope context_scope(context());

isolate()->SetAutorunMicrotasks(false);

uv_check_init(event_loop(), immediate_check_handle());
uv_unref(reinterpret_cast<uv_handle_t*>(immediate_check_handle()));

Expand Down
194 changes: 88 additions & 106 deletions src/node.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -3341,11 +3341,6 @@ void SetupProcessObject(Environment* env,
#undef READONLY_PROPERTY


static void AtProcessExit() {
uv_tty_reset_mode();
}


void SignalExit(int signo) {
uv_tty_reset_mode();
#ifdef __FreeBSD__
Expand Down Expand Up @@ -3375,11 +3370,6 @@ static void RawDebug(const FunctionCallbackInfo<Value>& args) {
void LoadEnvironment(Environment* env) {
HandleScope handle_scope(env->isolate());

env->isolate()->SetFatalErrorHandler(node::OnFatalError);
env->isolate()->AddMessageListener(OnMessage);

atexit(AtProcessExit);

TryCatch try_catch(env->isolate());

// Disable verbose mode to stop FatalException() handler from trying
Expand Down Expand Up @@ -4374,115 +4364,118 @@ void FreeEnvironment(Environment* env) {
}


// Entry point for new node instances, also called directly for the main
// node instance.
static void StartNodeInstance(void* arg) {
NodeInstanceData* instance_data = static_cast<NodeInstanceData*>(arg);
Isolate::CreateParams params;
ArrayBufferAllocator array_buffer_allocator;
params.array_buffer_allocator = &array_buffer_allocator;
#ifdef NODE_ENABLE_VTUNE_PROFILING
params.code_event_handler = vTune::GetVtuneCodeEventHandler();
#endif
Isolate* isolate = Isolate::New(params);
inline int Start(Isolate* isolate, IsolateData* isolate_data,
int argc, const char* const* argv,
int exec_argc, const char* const* exec_argv) {
HandleScope handle_scope(isolate);
Local<Context> context = Context::New(isolate);
Context::Scope context_scope(context);
Environment env(isolate_data, context);
env.Start(argc, argv, exec_argc, exec_argv, v8_is_profiling);

{
Mutex::ScopedLock scoped_lock(node_isolate_mutex);
if (instance_data->is_main()) {
CHECK_EQ(node_isolate, nullptr);
node_isolate = isolate;
}
// Start debug agent when argv has --debug
if (use_debug_agent) {
const char* path = argc > 1 ? argv[1] : nullptr;
StartDebug(&env, path, debug_wait_connect);
if (use_inspector && !debugger_running)
return 12; // Signal internal error.
}

if (track_heap_objects) {
isolate->GetHeapProfiler()->StartTrackingHeapObjects(true);
{
Environment::AsyncCallbackScope callback_scope(&env);
LoadEnvironment(&env);
}

env.set_trace_sync_io(trace_sync_io);

// Enable debugger
if (use_debug_agent)
EnableDebug(&env);

{
Locker locker(isolate);
Isolate::Scope isolate_scope(isolate);
HandleScope handle_scope(isolate);
IsolateData isolate_data(isolate, instance_data->event_loop(),
array_buffer_allocator.zero_fill_field());
Local<Context> context = Context::New(isolate);
Context::Scope context_scope(context);
Environment env(&isolate_data, context);
env.Start(instance_data->argc(),
instance_data->argv(),
instance_data->exec_argc(),
instance_data->exec_argv(),
v8_is_profiling);

isolate->SetAbortOnUncaughtExceptionCallback(
ShouldAbortOnUncaughtException);

// Start debug agent when argv has --debug
if (instance_data->use_debug_agent()) {
const char* path = instance_data->argc() > 1
? instance_data->argv()[1]
: nullptr;
StartDebug(&env, path, debug_wait_connect);
if (use_inspector && !debugger_running) {
exit(12);
SealHandleScope seal(isolate);
bool more;
do {
v8_platform.PumpMessageLoop(isolate);
more = uv_run(env.event_loop(), UV_RUN_ONCE);

if (more == false) {
v8_platform.PumpMessageLoop(isolate);
EmitBeforeExit(&env);

// Emit `beforeExit` if the loop became alive either after emitting
// event, or after running some callbacks.
more = uv_loop_alive(env.event_loop());
if (uv_run(env.event_loop(), UV_RUN_NOWAIT) != 0)
more = true;
}
}
} while (more == true);
}

{
Environment::AsyncCallbackScope callback_scope(&env);
LoadEnvironment(&env);
}
env.set_trace_sync_io(false);

env.set_trace_sync_io(trace_sync_io);
const int exit_code = EmitExit(&env);
RunAtExit(&env);

// Enable debugger
if (instance_data->use_debug_agent())
EnableDebug(&env);
WaitForInspectorDisconnect(&env);
#if defined(LEAK_SANITIZER)
__lsan_do_leak_check();
#endif

{
SealHandleScope seal(isolate);
bool more;
do {
v8_platform.PumpMessageLoop(isolate);
more = uv_run(env.event_loop(), UV_RUN_ONCE);
return exit_code;
}

if (more == false) {
v8_platform.PumpMessageLoop(isolate);
EmitBeforeExit(&env);
inline int Start(uv_loop_t* event_loop,
int argc, const char* const* argv,
int exec_argc, const char* const* exec_argv) {
Isolate::CreateParams params;
ArrayBufferAllocator allocator;
params.array_buffer_allocator = &allocator;
#ifdef NODE_ENABLE_VTUNE_PROFILING
params.code_event_handler = vTune::GetVtuneCodeEventHandler();
#endif

// Emit `beforeExit` if the loop became alive either after emitting
// event, or after running some callbacks.
more = uv_loop_alive(env.event_loop());
if (uv_run(env.event_loop(), UV_RUN_NOWAIT) != 0)
more = true;
}
} while (more == true);
}
Isolate* const isolate = Isolate::New(params);
if (isolate == nullptr)
return 12; // Signal internal error.

env.set_trace_sync_io(false);
isolate->AddMessageListener(OnMessage);
isolate->SetAbortOnUncaughtExceptionCallback(ShouldAbortOnUncaughtException);
isolate->SetAutorunMicrotasks(false);
isolate->SetFatalErrorHandler(OnFatalError);

int exit_code = EmitExit(&env);
if (instance_data->is_main())
instance_data->set_exit_code(exit_code);
RunAtExit(&env);
if (track_heap_objects) {
isolate->GetHeapProfiler()->StartTrackingHeapObjects(true);
}

WaitForInspectorDisconnect(&env);
#if defined(LEAK_SANITIZER)
__lsan_do_leak_check();
#endif
{
Mutex::ScopedLock scoped_lock(node_isolate_mutex);
CHECK_EQ(node_isolate, nullptr);
node_isolate = isolate;
}

int exit_code;
{
Locker locker(isolate);
Isolate::Scope isolate_scope(isolate);
HandleScope handle_scope(isolate);
IsolateData isolate_data(isolate, event_loop, allocator.zero_fill_field());
exit_code = Start(isolate, &isolate_data, argc, argv, exec_argc, exec_argv);
}

{
Mutex::ScopedLock scoped_lock(node_isolate_mutex);
if (node_isolate == isolate)
node_isolate = nullptr;
CHECK_EQ(node_isolate, isolate);
node_isolate = nullptr;
}

CHECK_NE(isolate, nullptr);
isolate->Dispose();
isolate = nullptr;

return exit_code;
}

int Start(int argc, char** argv) {
atexit([] () { uv_tty_reset_mode(); });
PlatformInit();

CHECK_GT(argc, 0);
Expand Down Expand Up @@ -4510,19 +4503,8 @@ int Start(int argc, char** argv) {
v8_platform.Initialize(v8_thread_pool_size);
V8::Initialize();
v8_initialized = true;

int exit_code = 1;
{
NodeInstanceData instance_data(NodeInstanceType::MAIN,
uv_default_loop(),
argc,
const_cast<const char**>(argv),
exec_argc,
exec_argv,
use_debug_agent);
StartNodeInstance(&instance_data);
exit_code = instance_data.exit_code();
}
const int exit_code =
Start(uv_default_loop(), argc, argv, exec_argc, exec_argv);
v8_initialized = false;
V8::Dispose();

Expand Down
81 changes: 0 additions & 81 deletions src/node_internals.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -179,87 +179,6 @@ class ArrayBufferAllocator : public v8::ArrayBuffer::Allocator {
// by clearing all callbacks that could handle the error.
void ClearFatalExceptionHandlers(Environment* env);

enum NodeInstanceType { MAIN, WORKER, REMOTE_DEBUG_SERVER };

class NodeInstanceData {
public:
NodeInstanceData(NodeInstanceType node_instance_type,
uv_loop_t* event_loop,
int argc,
const char** argv,
int exec_argc,
const char** exec_argv,
bool use_debug_agent_flag)
: node_instance_type_(node_instance_type),
exit_code_(1),
event_loop_(event_loop),
argc_(argc),
argv_(argv),
exec_argc_(exec_argc),
exec_argv_(exec_argv),
use_debug_agent_flag_(use_debug_agent_flag) {
CHECK_NE(event_loop_, nullptr);
}

uv_loop_t* event_loop() const {
return event_loop_;
}

int exit_code() {
CHECK(is_main());
return exit_code_;
}

void set_exit_code(int exit_code) {
CHECK(is_main());
exit_code_ = exit_code;
}

bool is_main() {
return node_instance_type_ == MAIN;
}

bool is_worker() {
return node_instance_type_ == WORKER;
}

bool is_remote_debug_server() {
return node_instance_type_ == REMOTE_DEBUG_SERVER;
}

int argc() {
return argc_;
}

const char** argv() {
return argv_;
}

int exec_argc() {
return exec_argc_;
}

const char** exec_argv() {
return exec_argv_;
}

bool use_debug_agent() {
return is_main() && use_debug_agent_flag_;
}

private:
const NodeInstanceType node_instance_type_;
int exit_code_;
uv_loop_t* const event_loop_;
const int argc_;
const char** argv_;
const int exec_argc_;
const char** exec_argv_;
const bool use_debug_agent_flag_;

DISALLOW_COPY_AND_ASSIGN(NodeInstanceData);
};

namespace Buffer {
v8::MaybeLocal<v8::Object> Copy(Environment* env, const char* data, size_t len);
v8::MaybeLocal<v8::Object> New(Environment* env, size_t size);
Expand Down