mirror of https://github.com/lukechilds/node.git
Browse Source
It was decided that the performance benefits that isolates offer (faster spin-up times for worker processes, faster inter-worker communication, possibly a lower memory footprint) are not actual bottlenecks for most people and do not outweigh the potential stability issues and intrusive changes to the code base that first-class support for isolates requires. Hence, this commit backs out all isolates-related changes. Good bye, isolates. We hardly knew ye.v0.7.4-release
Ben Noordhuis
13 years ago
45 changed files with 413 additions and 2257 deletions
@ -1,109 +0,0 @@ |
|||
|
|||
/*
|
|||
* Copyright (C) Igor Sysoev |
|||
*/ |
|||
|
|||
|
|||
#ifndef _NGX_QUEUE_H_INCLUDED_ |
|||
#define _NGX_QUEUE_H_INCLUDED_ |
|||
|
|||
#ifdef _WIN32 |
|||
# include <stddef.h> |
|||
#endif |
|||
|
|||
typedef struct ngx_queue_s ngx_queue_t; |
|||
|
|||
struct ngx_queue_s { |
|||
ngx_queue_t *prev; |
|||
ngx_queue_t *next; |
|||
}; |
|||
|
|||
|
|||
#define ngx_queue_init(q) \ |
|||
(q)->prev = q; \ |
|||
(q)->next = q |
|||
|
|||
|
|||
#define ngx_queue_empty(h) \ |
|||
(h == (h)->prev) |
|||
|
|||
|
|||
#define ngx_queue_insert_head(h, x) \ |
|||
(x)->next = (h)->next; \ |
|||
(x)->next->prev = x; \ |
|||
(x)->prev = h; \ |
|||
(h)->next = x |
|||
|
|||
|
|||
#define ngx_queue_insert_after ngx_queue_insert_head |
|||
|
|||
|
|||
#define ngx_queue_insert_tail(h, x) \ |
|||
(x)->prev = (h)->prev; \ |
|||
(x)->prev->next = x; \ |
|||
(x)->next = h; \ |
|||
(h)->prev = x |
|||
|
|||
|
|||
#define ngx_queue_head(h) \ |
|||
(h)->next |
|||
|
|||
|
|||
#define ngx_queue_last(h) \ |
|||
(h)->prev |
|||
|
|||
|
|||
#define ngx_queue_sentinel(h) \ |
|||
(h) |
|||
|
|||
|
|||
#define ngx_queue_next(q) \ |
|||
(q)->next |
|||
|
|||
|
|||
#define ngx_queue_prev(q) \ |
|||
(q)->prev |
|||
|
|||
|
|||
#if (NGX_DEBUG) |
|||
|
|||
#define ngx_queue_remove(x) \ |
|||
(x)->next->prev = (x)->prev; \ |
|||
(x)->prev->next = (x)->next; \ |
|||
(x)->prev = NULL; \ |
|||
(x)->next = NULL |
|||
|
|||
#else |
|||
|
|||
#define ngx_queue_remove(x) \ |
|||
(x)->next->prev = (x)->prev; \ |
|||
(x)->prev->next = (x)->next |
|||
|
|||
#endif |
|||
|
|||
|
|||
#define ngx_queue_split(h, q, n) \ |
|||
(n)->prev = (h)->prev; \ |
|||
(n)->prev->next = n; \ |
|||
(n)->next = q; \ |
|||
(h)->prev = (q)->prev; \ |
|||
(h)->prev->next = h; \ |
|||
(q)->prev = n; |
|||
|
|||
|
|||
#define ngx_queue_add(h, n) \ |
|||
(h)->prev->next = (n)->next; \ |
|||
(n)->next->prev = (h)->prev; \ |
|||
(h)->prev = (n)->prev; \ |
|||
(h)->prev->next = h; |
|||
|
|||
|
|||
#define ngx_queue_data(q, type, link) \ |
|||
(type *) ((unsigned char *) q - offsetof(type, link)) |
|||
|
|||
|
|||
#define ngx_queue_foreach(q, h) \ |
|||
for ((q) = ngx_queue_head(h); (q) != (h); (q) = ngx_queue_next(q)) |
|||
|
|||
|
|||
#endif /* _NGX_QUEUE_H_INCLUDED_ */ |
|||
@ -1,815 +0,0 @@ |
|||
// Copyright Joyent, Inc. and other Node contributors.
|
|||
//
|
|||
// Permission is hereby granted, free of charge, to any person obtaining a
|
|||
// copy of this software and associated documentation files (the
|
|||
// "Software"), to deal in the Software without restriction, including
|
|||
// without limitation the rights to use, copy, modify, merge, publish,
|
|||
// distribute, sublicense, and/or sell copies of the Software, and to permit
|
|||
// persons to whom the Software is furnished to do so, subject to the
|
|||
// following conditions:
|
|||
//
|
|||
// The above copyright notice and this permission notice shall be included
|
|||
// in all copies or substantial portions of the Software.
|
|||
//
|
|||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|||
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|||
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
|
|||
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
|||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
|||
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
|||
// USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|||
|
|||
#include <v8.h> |
|||
#include <v8-debug.h> |
|||
#include <node.h> |
|||
#include <node_buffer.h> |
|||
#include <node_isolate.h> |
|||
#include <node_internals.h> |
|||
#include <node_object_wrap.h> |
|||
#include <tcp_wrap.h> |
|||
|
|||
#include <stdlib.h> |
|||
#include <string.h> |
|||
#include <assert.h> |
|||
|
|||
|
|||
#define isolate_debugger_constructor NODE_VAR(isolate_debugger_constructor) |
|||
|
|||
#define ISOLATEMESSAGE_SHARED_STREAM 0x0001 |
|||
|
|||
|
|||
namespace node { |
|||
|
|||
using v8::Arguments; |
|||
using v8::Array; |
|||
using v8::Context; |
|||
using v8::False; |
|||
using v8::Function; |
|||
using v8::FunctionTemplate; |
|||
using v8::Handle; |
|||
using v8::HandleScope; |
|||
using v8::Integer; |
|||
using v8::Local; |
|||
using v8::Null; |
|||
using v8::Object; |
|||
using v8::ObjectTemplate; |
|||
using v8::Persistent; |
|||
using v8::String; |
|||
using v8::True; |
|||
using v8::Undefined; |
|||
using v8::Value; |
|||
using v8::Undefined; |
|||
|
|||
static volatile bool initialized; |
|||
static volatile int id; |
|||
static volatile int isolate_count; |
|||
static ngx_queue_t isolate_list; |
|||
static uv_mutex_t isolate_mutex; |
|||
|
|||
#ifdef NDEBUG |
|||
# define IF_DEBUG(expr) |
|||
#else |
|||
# define IF_DEBUG(expr) expr; |
|||
#endif |
|||
|
|||
template <class T> |
|||
class Queue { |
|||
public: |
|||
Queue() { |
|||
if (uv_mutex_init(&mutex_)) abort(); |
|||
ngx_queue_init(&queue_); |
|||
} |
|||
|
|||
~Queue() { |
|||
IF_DEBUG({ |
|||
uv_mutex_lock(&mutex_); |
|||
assert(ngx_queue_empty(&queue_)); |
|||
uv_mutex_unlock(&mutex_); |
|||
}) |
|||
uv_mutex_destroy(&mutex_); |
|||
} |
|||
|
|||
void Produce(T item) { |
|||
Message* m = new Message; |
|||
m->item_ = item; |
|||
|
|||
uv_mutex_lock(&mutex_); |
|||
ngx_queue_insert_tail(&queue_, &m->queue_); |
|||
uv_mutex_unlock(&mutex_); |
|||
} |
|||
|
|||
bool Consume(T& item) { |
|||
ngx_queue_t* q = NULL; |
|||
|
|||
uv_mutex_lock(&mutex_); |
|||
if (!ngx_queue_empty(&queue_)) { |
|||
q = ngx_queue_head(&queue_); |
|||
ngx_queue_remove(q); |
|||
} |
|||
uv_mutex_unlock(&mutex_); |
|||
|
|||
if (q == NULL) return false; |
|||
|
|||
Message* m = ngx_queue_data(q, Message, queue_); |
|||
item = m->item_; |
|||
delete m; |
|||
|
|||
return true; |
|||
} |
|||
|
|||
private: |
|||
struct Message { |
|||
ngx_queue_t queue_; |
|||
T item_; |
|||
}; |
|||
|
|||
ngx_queue_t queue_; |
|||
uv_mutex_t mutex_; |
|||
}; |
|||
|
|||
|
|||
template <class T> |
|||
class Channel { |
|||
public: |
|||
typedef void (*Callback)(T item, void* arg); |
|||
|
|||
Channel(uv_loop_t* loop, Callback callback, void* arg) { |
|||
callback_ = callback; |
|||
arg_ = arg; |
|||
uv_async_init(loop, &async_, OnMessage); |
|||
uv_unref(loop); |
|||
} |
|||
|
|||
~Channel() { |
|||
uv_ref(async_.loop); |
|||
uv_close(reinterpret_cast<uv_handle_t*>(&async_), NULL); |
|||
} |
|||
|
|||
void Send(T item) { |
|||
queue_.Produce(item); |
|||
uv_async_send(&async_); |
|||
} |
|||
|
|||
private: |
|||
static void OnMessage(uv_async_t* handle, int status) { |
|||
Channel* c = container_of(handle, Channel, async_); |
|||
c->OnMessage(); |
|||
} |
|||
|
|||
void OnMessage() { |
|||
T item; |
|||
while (queue_.Consume(item)) callback_(item, arg_); |
|||
} |
|||
|
|||
void* arg_; |
|||
Callback callback_; |
|||
uv_async_t async_; |
|||
Queue<T> queue_; |
|||
}; |
|||
|
|||
|
|||
struct IsolateMessage { |
|||
int flags; |
|||
struct { |
|||
size_t size_; |
|||
char* buffer_; |
|||
} data_; |
|||
uv_stream_info_t shared_stream_info_; |
|||
|
|||
IsolateMessage(const char* buffer, size_t size, |
|||
uv_stream_info_t* shared_stream_info) { |
|||
flags = 0; |
|||
|
|||
// make a copy for now
|
|||
data_.size_ = size; |
|||
data_.buffer_ = new char[size]; |
|||
memcpy(data_.buffer_, buffer, size); |
|||
|
|||
if (shared_stream_info) { |
|||
flags |= ISOLATEMESSAGE_SHARED_STREAM; |
|||
shared_stream_info_ = *shared_stream_info; |
|||
} |
|||
} |
|||
|
|||
~IsolateMessage() { |
|||
delete[] data_.buffer_; |
|||
} |
|||
|
|||
static void Free(char* data, void* arg) { |
|||
IsolateMessage* msg = static_cast<IsolateMessage*>(arg); |
|||
assert(data == msg->data_.buffer_); |
|||
delete msg; |
|||
} |
|||
}; |
|||
|
|||
|
|||
class IsolateChannel: public Channel<IsolateMessage*> { |
|||
public: |
|||
IsolateChannel(uv_loop_t* loop, Callback callback, void* arg) |
|||
: Channel<IsolateMessage*>(loop, callback, arg) |
|||
{ |
|||
} |
|||
}; |
|||
|
|||
|
|||
Handle<Value> Isolate::Send(const Arguments& args) { |
|||
HandleScope scope; |
|||
|
|||
Isolate* isolate = Isolate::GetCurrent(); |
|||
assert(Buffer::HasInstance(args[0])); |
|||
assert(isolate->send_channel_ != NULL); |
|||
|
|||
Local<Object> obj = args[0]->ToObject(); |
|||
const char* data = Buffer::Data(obj); |
|||
size_t size = Buffer::Length(obj); |
|||
|
|||
IsolateMessage* msg; |
|||
|
|||
if (args[1]->IsObject()) { |
|||
uv_stream_info_t stream_info; |
|||
|
|||
Local<Object> send_stream_obj = args[1]->ToObject(); |
|||
assert(send_stream_obj->InternalFieldCount() > 0); |
|||
StreamWrap* send_stream_wrap = static_cast<StreamWrap*>( |
|||
send_stream_obj->GetPointerFromInternalField(0)); |
|||
uv_stream_t* send_stream = send_stream_wrap->GetStream(); |
|||
int r = uv_export(send_stream, &stream_info); |
|||
assert(r == 0); |
|||
msg = new IsolateMessage(data, size, &stream_info); |
|||
} else { |
|||
msg = new IsolateMessage(data, size, NULL); |
|||
} |
|||
|
|||
isolate->send_channel_->Send(msg); |
|||
|
|||
return Undefined(); |
|||
} |
|||
|
|||
|
|||
Handle<Value> Isolate::Unref(const Arguments& args) { |
|||
HandleScope scope; |
|||
|
|||
Isolate* isolate = Isolate::GetCurrent(); |
|||
uv_unref(isolate->loop_); |
|||
|
|||
return Undefined(); |
|||
} |
|||
|
|||
|
|||
void Isolate::OnMessage(IsolateMessage* msg, void* arg) { |
|||
HandleScope scope; |
|||
|
|||
Isolate* self = static_cast<Isolate*>(arg); |
|||
NODE_ISOLATE_CHECK(self); |
|||
|
|||
Buffer* buf = Buffer::New(msg->data_.buffer_, msg->data_.size_, |
|||
IsolateMessage::Free, msg); |
|||
|
|||
int argc = 1; |
|||
Handle<Value> argv[2] = { |
|||
buf->handle_ |
|||
}; |
|||
|
|||
if (msg->flags & ISOLATEMESSAGE_SHARED_STREAM) { |
|||
// Instantiate the client javascript object and handle.
|
|||
Local<Object> pending_obj = TCPWrap::Instantiate(); |
|||
|
|||
// Unwrap the client javascript object.
|
|||
assert(pending_obj->InternalFieldCount() > 0); |
|||
TCPWrap* pending_wrap = |
|||
static_cast<TCPWrap*>(pending_obj->GetPointerFromInternalField(0)); |
|||
|
|||
int r = uv_import(pending_wrap->GetStream(), &msg->shared_stream_info_); |
|||
assert(r == 0); |
|||
|
|||
argv[1] = pending_obj; |
|||
argc++; |
|||
} |
|||
|
|||
MakeCallback(self->globals_.process, "_onmessage", argc, argv); |
|||
} |
|||
|
|||
|
|||
void Isolate::Initialize() { |
|||
if (initialized) return; |
|||
if (uv_mutex_init(&isolate_mutex)) abort(); |
|||
ngx_queue_init(&isolate_list); |
|||
initialized = true; |
|||
} |
|||
|
|||
|
|||
int Isolate::Count() { |
|||
int count; |
|||
uv_mutex_lock(&isolate_mutex); |
|||
count = isolate_count; |
|||
uv_mutex_unlock(&isolate_mutex); |
|||
return count; |
|||
} |
|||
|
|||
|
|||
Isolate::Isolate() { |
|||
send_channel_ = NULL; // set (and deleted) by the parent isolate
|
|||
recv_channel_ = NULL; |
|||
|
|||
uv_mutex_lock(&isolate_mutex); |
|||
assert(initialized && "node::Isolate::Initialize() hasn't been called"); |
|||
ngx_queue_insert_tail(&isolate_list, &isolate_list_); |
|||
isolate_count++; |
|||
id_ = ++id; |
|||
uv_mutex_unlock(&isolate_mutex); |
|||
|
|||
if (id_ == 1) { |
|||
loop_ = uv_default_loop(); |
|||
} else { |
|||
loop_ = uv_loop_new(); |
|||
// Artificially ref the isolate loop so that the child
|
|||
// isolate stays alive by default. process.exit will
|
|||
// unref the loop (see Isolate::Unref).
|
|||
uv_ref(loop_); |
|||
} |
|||
|
|||
debug_state = kNone; |
|||
debugger_instance = NULL; |
|||
|
|||
ngx_queue_init(&at_exit_callbacks_); |
|||
|
|||
v8_isolate_ = v8::Isolate::New(); |
|||
assert(v8_isolate_->GetData() == NULL); |
|||
v8_isolate_->SetData(this); |
|||
|
|||
globals_init_ = false; |
|||
} |
|||
|
|||
|
|||
Isolate::~Isolate() { |
|||
if (!argv_) return; |
|||
for (size_t i = 0; argv_[i]; ++i) delete[] argv_[i]; |
|||
delete[] argv_; |
|||
} |
|||
|
|||
|
|||
struct globals* Isolate::Globals() { |
|||
return &globals_; |
|||
} |
|||
|
|||
|
|||
void Isolate::AtExit(AtExitCallback callback, void* arg) { |
|||
struct AtExitCallbackInfo* it = new AtExitCallbackInfo; |
|||
|
|||
//NODE_ISOLATE_CHECK(this);
|
|||
|
|||
it->callback_ = callback; |
|||
it->arg_ = arg; |
|||
|
|||
ngx_queue_insert_head(&at_exit_callbacks_, &it->queue_); |
|||
} |
|||
|
|||
|
|||
void Isolate::Enter() { |
|||
v8_isolate_->Enter(); |
|||
|
|||
if (v8_context_.IsEmpty()) { |
|||
v8_context_ = Context::New(); |
|||
} |
|||
v8_context_->Enter(); |
|||
|
|||
if (!globals_init_) { |
|||
globals_init_ = true; |
|||
globals_init(&globals_); |
|||
} |
|||
|
|||
NODE_ISOLATE_CHECK(this); |
|||
} |
|||
|
|||
|
|||
void Isolate::Exit() { |
|||
NODE_ISOLATE_CHECK(this); |
|||
v8_context_->Exit(); |
|||
v8_isolate_->Exit(); |
|||
} |
|||
|
|||
|
|||
void Isolate::Dispose() { |
|||
NODE_ISOLATE_CHECK(this); |
|||
|
|||
while (!ngx_queue_empty(&at_exit_callbacks_)) { |
|||
ngx_queue_t* q = ngx_queue_head(&at_exit_callbacks_); |
|||
ngx_queue_remove(q); |
|||
|
|||
AtExitCallbackInfo* it = ngx_queue_data(q, AtExitCallbackInfo, queue_); |
|||
it->callback_(it->arg_); |
|||
|
|||
delete it; |
|||
} |
|||
|
|||
assert(v8_context_->InContext()); |
|||
v8_context_->Exit(); |
|||
v8_context_.Clear(); |
|||
v8_context_.Dispose(); |
|||
|
|||
v8_isolate_->Exit(); |
|||
v8_isolate_->Dispose(); |
|||
v8_isolate_ = NULL; |
|||
|
|||
uv_mutex_lock(&isolate_mutex); |
|||
isolate_count--; |
|||
ngx_queue_remove(&isolate_list_); |
|||
assert(isolate_count >= 0); |
|||
assert((isolate_count == 0 && ngx_queue_empty(&isolate_list)) |
|||
|| (isolate_count > 0 && !ngx_queue_empty(&isolate_list))); |
|||
uv_mutex_unlock(&isolate_mutex); |
|||
} |
|||
|
|||
|
|||
struct IsolateWrap: public ObjectWrap { |
|||
public: |
|||
IsolateWrap(Isolate* parent_isolate) { |
|||
parent_isolate_ = parent_isolate; |
|||
|
|||
uv_loop_t* parent_loop = parent_isolate->GetLoop(); |
|||
recv_channel_ = new IsolateChannel( |
|||
parent_loop, IsolateWrap::OnMessage, this); |
|||
|
|||
isolate_ = new Isolate; |
|||
send_channel_ = new IsolateChannel( |
|||
isolate_->loop_, Isolate::OnMessage, isolate_); |
|||
|
|||
isolate_->send_channel_ = recv_channel_; |
|||
isolate_->recv_channel_ = send_channel_; |
|||
|
|||
// TODO this could be folded into the regular channel
|
|||
uv_async_init(parent_loop, &child_exit_, AfterChildExit); |
|||
isolate_->AtExit(AtChildExit, this); |
|||
|
|||
HandleScope scope; |
|||
Local<ObjectTemplate> tpl = ObjectTemplate::New(); |
|||
tpl->SetInternalFieldCount(1); |
|||
|
|||
Local<Object> obj = tpl->NewInstance(); |
|||
Wrap(obj); |
|||
Ref(); // unref'd when the child isolate exits
|
|||
|
|||
obj->Set(String::NewSymbol("tid"), |
|||
Integer::New(isolate_->id_)); |
|||
|
|||
obj->Set(String::NewSymbol("send"), |
|||
FunctionTemplate::New(Send)->GetFunction()); |
|||
} |
|||
|
|||
~IsolateWrap() { |
|||
delete isolate_; |
|||
delete recv_channel_; |
|||
delete send_channel_; |
|||
} |
|||
|
|||
Isolate* GetIsolate() { |
|||
return isolate_; |
|||
} |
|||
|
|||
private: |
|||
// runs in the child thread
|
|||
static void AtChildExit(void* arg) { |
|||
IsolateWrap* self = static_cast<IsolateWrap*>(arg); |
|||
uv_async_send(&self->child_exit_); |
|||
} |
|||
|
|||
// runs in the parent thread
|
|||
static void AfterChildExit(uv_async_t* handle, int status) { |
|||
IsolateWrap* self = container_of(handle, IsolateWrap, child_exit_); |
|||
self->OnExit(); |
|||
} |
|||
|
|||
void OnExit() { |
|||
if (uv_thread_join(&isolate_->tid_)) abort(); |
|||
uv_close(reinterpret_cast<uv_handle_t*>(&child_exit_), NULL); |
|||
MakeCallback(handle_, "onexit", 0, NULL); |
|||
Unref(); // child is dead, it's safe to GC the JS object now
|
|||
} |
|||
|
|||
static void OnMessage(IsolateMessage* msg, void* arg) { |
|||
IsolateWrap* self = static_cast<IsolateWrap*>(arg); |
|||
self->OnMessage(msg); |
|||
} |
|||
|
|||
void OnMessage(IsolateMessage* msg) { |
|||
NODE_ISOLATE_CHECK(parent_isolate_); |
|||
HandleScope scope; |
|||
Buffer* buf = Buffer::New( |
|||
msg->data_.buffer_, msg->data_.size_, IsolateMessage::Free, msg); |
|||
|
|||
int argc = 1; |
|||
Handle<Value> argv[2] = { |
|||
buf->handle_ |
|||
}; |
|||
|
|||
if (msg->flags & ISOLATEMESSAGE_SHARED_STREAM) { |
|||
// Instantiate the client javascript object and handle.
|
|||
Local<Object> pending_obj = TCPWrap::Instantiate(); |
|||
|
|||
// Unwrap the client javascript object.
|
|||
assert(pending_obj->InternalFieldCount() > 0); |
|||
TCPWrap* pending_wrap = |
|||
static_cast<TCPWrap*>(pending_obj->GetPointerFromInternalField(0)); |
|||
|
|||
int r = uv_import(pending_wrap->GetStream(), &msg->shared_stream_info_); |
|||
assert(r == 0); |
|||
|
|||
argv[1] = pending_obj; |
|||
argc++; |
|||
} |
|||
|
|||
MakeCallback(handle_, "onmessage", argc, argv); |
|||
} |
|||
|
|||
// TODO merge with Isolate::Send(), it's almost identical
|
|||
static Handle<Value> Send(const Arguments& args) { |
|||
HandleScope scope; |
|||
IsolateWrap* self = Unwrap<IsolateWrap>(args.This()); |
|||
assert(Buffer::HasInstance(args[0])); |
|||
|
|||
Local<Object> obj = args[0]->ToObject(); |
|||
const char* data = Buffer::Data(obj); |
|||
size_t size = Buffer::Length(obj); |
|||
|
|||
IsolateMessage* msg; |
|||
|
|||
if (args[1]->IsObject()) { |
|||
uv_stream_info_t stream_info; |
|||
|
|||
Local<Object> send_stream_obj = args[1]->ToObject(); |
|||
assert(send_stream_obj->InternalFieldCount() > 0); |
|||
StreamWrap* send_stream_wrap = static_cast<StreamWrap*>( |
|||
send_stream_obj->GetPointerFromInternalField(0)); |
|||
uv_stream_t* send_stream = send_stream_wrap->GetStream(); |
|||
int r = uv_export(send_stream, &stream_info); |
|||
assert(r == 0); |
|||
msg = new IsolateMessage(data, size, &stream_info); |
|||
} else { |
|||
msg = new IsolateMessage(data, size, NULL); |
|||
} |
|||
|
|||
self->send_channel_->Send(msg); |
|||
return Undefined(); |
|||
} |
|||
|
|||
DISALLOW_IMPLICIT_CONSTRUCTORS(IsolateWrap); |
|||
Isolate* isolate_; |
|||
Isolate* parent_isolate_; |
|||
IsolateChannel* send_channel_; |
|||
IsolateChannel* recv_channel_; |
|||
uv_async_t child_exit_; // side effect: keeps the parent's event loop alive
|
|||
// until the child exits
|
|||
}; |
|||
|
|||
|
|||
static void RunIsolate(void* arg) { |
|||
Isolate* isolate = static_cast<Isolate*>(arg); |
|||
isolate->Enter(); |
|||
StartThread(isolate, isolate->argc_, isolate->argv_); |
|||
isolate->Dispose(); |
|||
} |
|||
|
|||
|
|||
static Handle<Value> CreateIsolate(const Arguments& args) { |
|||
HandleScope scope; |
|||
|
|||
assert(args[0]->IsArray()); |
|||
|
|||
Local<Array> argv = args[0].As<Array>(); |
|||
assert(argv->Length() >= 2); |
|||
|
|||
Isolate* current_isolate = node::Isolate::GetCurrent(); |
|||
IsolateWrap* wrap = new IsolateWrap(current_isolate); |
|||
Isolate* isolate = wrap->GetIsolate(); |
|||
|
|||
// Copy over arguments into isolate
|
|||
isolate->argc_ = argv->Length(); |
|||
isolate->argv_ = new char*[isolate->argc_ + 1]; |
|||
for (int i = 0; i < isolate->argc_; ++i) { |
|||
String::Utf8Value str(argv->Get(i)); |
|||
size_t size = 1 + strlen(*str); |
|||
isolate->argv_[i] = new char[size]; |
|||
memcpy(isolate->argv_[i], *str, size); |
|||
} |
|||
isolate->argv_[isolate->argc_] = NULL; |
|||
|
|||
// If options object was provided
|
|||
if (args.Length() > 1) { |
|||
Local<Object> options = args[1].As<Object>(); |
|||
Local<Value> opt_debug = options->Get(String::New("debug")); |
|||
Local<Value> opt_debug_brk = options->Get(String::New("debugBrk")); |
|||
|
|||
// Handle .debug = true case
|
|||
if (opt_debug->IsFunction()) { |
|||
isolate->debug_state = opt_debug_brk->IsTrue() ? |
|||
Isolate::kDebugBrk |
|||
: |
|||
Isolate::kDebug; |
|||
isolate->debugger_instance = IsolateDebugger::New(opt_debug); |
|||
} |
|||
} |
|||
|
|||
if (uv_thread_create(&isolate->tid_, RunIsolate, isolate)) |
|||
return Null(); // wrap is collected by the GC
|
|||
else |
|||
return wrap->handle_; |
|||
} |
|||
|
|||
|
|||
static Handle<Value> CountIsolate(const Arguments& args) { |
|||
HandleScope scope; |
|||
return scope.Close(Integer::New(Isolate::Count())); |
|||
} |
|||
|
|||
|
|||
void InitIsolates(Handle<Object> target) { |
|||
HandleScope scope; |
|||
NODE_SET_METHOD(target, "create", CreateIsolate); |
|||
NODE_SET_METHOD(target, "count", CountIsolate); |
|||
|
|||
IsolateDebugger::Initialize(); |
|||
} |
|||
|
|||
|
|||
class IsolateDebuggerMessage { |
|||
public: |
|||
IsolateDebugger* d_; |
|||
uint16_t* value_; |
|||
int len_; |
|||
|
|||
IsolateDebuggerMessage(IsolateDebugger* d, uint16_t* value, int len) { |
|||
d_ = d; |
|||
value_ = new uint16_t[len]; |
|||
len_ = len; |
|||
memcpy(value_, value, len * sizeof(value_[0])); |
|||
} |
|||
|
|||
~IsolateDebuggerMessage() { |
|||
delete[] value_; |
|||
} |
|||
}; |
|||
|
|||
|
|||
void IsolateDebugger::Initialize() { |
|||
HandleScope scope; |
|||
|
|||
Local<FunctionTemplate> t = FunctionTemplate::New(IsolateDebugger::New); |
|||
isolate_debugger_constructor = Persistent<FunctionTemplate>::New(t); |
|||
|
|||
t->InstanceTemplate()->SetInternalFieldCount(1); |
|||
t->SetClassName(String::NewSymbol("IsolateDebugger")); |
|||
|
|||
NODE_SET_PROTOTYPE_METHOD(t, "write", IsolateDebugger::Write); |
|||
} |
|||
|
|||
|
|||
IsolateDebugger::IsolateDebugger(Handle<Value> init) { |
|||
debuggee_ = NULL; |
|||
initialized_ = false; |
|||
host_ = Isolate::GetCurrent(); |
|||
host_loop_ = host_->GetLoop(); |
|||
init_callback_fn_ = Persistent<Value>::New(init); |
|||
|
|||
// Init async handle to invoke js callback once
|
|||
// debugger will be initialized
|
|||
uv_async_init(host_loop_, |
|||
&init_callback_, |
|||
IsolateDebugger::InitCallback); |
|||
init_callback_.data = reinterpret_cast<void*>(this); |
|||
|
|||
msg_channel_ = new Channel<IsolateDebuggerMessage*>( |
|||
host_loop_, MessageCallback, NULL); |
|||
} |
|||
|
|||
|
|||
IsolateDebugger::~IsolateDebugger() { |
|||
init_callback_fn_.Clear(); |
|||
init_callback_fn_.Dispose(); |
|||
delete msg_channel_; |
|||
} |
|||
|
|||
|
|||
void IsolateDebugger::Init(void) { |
|||
HandleScope scope; |
|||
|
|||
Isolate* isolate = Isolate::GetCurrent(); |
|||
|
|||
debuggee_ = isolate; |
|||
debuggee_v8_ = isolate->GetV8Isolate(); |
|||
v8::Debug::SetMessageHandler2(IsolateDebugger::DebugMessageHandler); |
|||
|
|||
// Expose v8debug for isolate
|
|||
|
|||
if (isolate->debug_state == Isolate::kDebugBrk) { |
|||
Local<Context> debugContext = v8::Debug::GetDebugContext(); |
|||
|
|||
debugContext->SetSecurityToken( |
|||
isolate->GetV8Context()->GetSecurityToken() |
|||
); |
|||
isolate->GetV8Context()->Global()->Set( |
|||
String::New("v8debug"), |
|||
debugContext->Global() |
|||
); |
|||
} |
|||
|
|||
initialized_ = true; |
|||
|
|||
uv_async_send(&init_callback_); |
|||
} |
|||
|
|||
|
|||
void IsolateDebugger::InitCallback(uv_async_t* c, int status) { |
|||
assert(c->data != NULL); |
|||
|
|||
IsolateDebugger* d = reinterpret_cast<IsolateDebugger*>(c->data); |
|||
|
|||
d->host_->Enter(); |
|||
HandleScope scope; |
|||
|
|||
Handle<Value> argv[1] = { d->handle_ }; |
|||
Function::Cast(*d->init_callback_fn_)->Call(d->handle_, 1, argv); |
|||
|
|||
d->host_->Exit(); |
|||
|
|||
// Unreference loop
|
|||
uv_unref(d->host_loop_); |
|||
} |
|||
|
|||
|
|||
Handle<Value> IsolateDebugger::New(const Arguments& args) { |
|||
HandleScope scope; |
|||
|
|||
IsolateDebugger* d = new IsolateDebugger(args[0]); |
|||
d->Wrap(args.Holder()); |
|||
|
|||
return args.This(); |
|||
} |
|||
|
|||
|
|||
IsolateDebugger* IsolateDebugger::New(Handle<Value> init) { |
|||
HandleScope scope; |
|||
|
|||
Handle<Value> argv[1] = { init }; |
|||
Handle<Object> i = isolate_debugger_constructor->GetFunction()->NewInstance( |
|||
1, |
|||
argv |
|||
); |
|||
|
|||
return ObjectWrap::Unwrap<IsolateDebugger>(i); |
|||
} |
|||
|
|||
|
|||
Handle<Value> IsolateDebugger::Write(const Arguments& args) { |
|||
HandleScope scope; |
|||
|
|||
if (args.Length() != 1) { |
|||
return ThrowException(String::New( |
|||
"IsolateDebugger::Write requires one argument" |
|||
)); |
|||
} |
|||
|
|||
IsolateDebugger* d = ObjectWrap::Unwrap<IsolateDebugger>(args.This()); |
|||
assert(d->initialized_); |
|||
|
|||
String::Value v(args[0]->ToString()); |
|||
v8::Debug::SendCommand(*v, |
|||
v.length(), |
|||
NULL, |
|||
d->debuggee_v8_); |
|||
|
|||
return Undefined(); |
|||
} |
|||
|
|||
|
|||
void IsolateDebugger::DebugMessageHandler(const v8::Debug::Message& message) { |
|||
IsolateDebugger* d = Isolate::GetCurrent()->debugger_instance; |
|||
|
|||
String::Value v(message.GetJSON()); |
|||
d->msg_channel_->Send(new IsolateDebuggerMessage(d, *v, v.length())); |
|||
} |
|||
|
|||
|
|||
void IsolateDebugger::MessageCallback(IsolateDebuggerMessage* msg, void*) { |
|||
assert(msg != NULL); |
|||
|
|||
IsolateDebugger *d = msg->d_; |
|||
// Enter parent isolate context
|
|||
d->host_->Enter(); |
|||
HandleScope scope; |
|||
|
|||
// debugger.onmessage should be a function!
|
|||
Handle<Value> argv[] = { String::New(msg->value_, msg->len_) }; |
|||
MakeCallback(d->handle_, "onmessage", ARRAY_SIZE(argv), argv); |
|||
|
|||
// Free memory allocated for message
|
|||
delete msg; |
|||
|
|||
// And leave isolate
|
|||
d->host_->Exit(); |
|||
} |
|||
|
|||
|
|||
} // namespace node
|
|||
|
|||
|
|||
NODE_MODULE(node_isolates, node::InitIsolates) |
|||
@ -1,185 +0,0 @@ |
|||
// Copyright Joyent, Inc. and other Node contributors.
|
|||
//
|
|||
// Permission is hereby granted, free of charge, to any person obtaining a
|
|||
// copy of this software and associated documentation files (the
|
|||
// "Software"), to deal in the Software without restriction, including
|
|||
// without limitation the rights to use, copy, modify, merge, publish,
|
|||
// distribute, sublicense, and/or sell copies of the Software, and to permit
|
|||
// persons to whom the Software is furnished to do so, subject to the
|
|||
// following conditions:
|
|||
//
|
|||
// The above copyright notice and this permission notice shall be included
|
|||
// in all copies or substantial portions of the Software.
|
|||
//
|
|||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|||
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|||
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
|
|||
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
|||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
|||
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
|||
// USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|||
|
|||
#ifndef SRC_NODE_ISOLATE_H_ |
|||
#define SRC_NODE_ISOLATE_H_ |
|||
|
|||
#include "v8.h" |
|||
#include "v8-debug.h" |
|||
#include "uv.h" |
|||
#include "node_vars.h" |
|||
#include "node_object_wrap.h" |
|||
#include "ngx-queue.h" |
|||
|
|||
#ifdef NDEBUG |
|||
# define NODE_ISOLATE_CHECK(ptr) ((void) (ptr)) |
|||
#else |
|||
# include <assert.h> |
|||
# define NODE_ISOLATE_CHECK(ptr) \ |
|||
do { \ |
|||
node::Isolate* data_ = node::Isolate::GetCurrent(); \ |
|||
assert(data_ == (ptr)); \ |
|||
} \ |
|||
while (0) |
|||
#endif |
|||
|
|||
|
|||
namespace node { |
|||
|
|||
template <class T> |
|||
|
|||
class Channel; |
|||
|
|||
class IsolateWrap; |
|||
class IsolateChannel; |
|||
class IsolateMessage; |
|||
class IsolateDebugger; |
|||
class IsolateDebuggerMessage; |
|||
|
|||
class Isolate { |
|||
public: |
|||
char** argv_; |
|||
int argc_; |
|||
uv_thread_t tid_; |
|||
|
|||
enum { |
|||
kNone, |
|||
kDebug, |
|||
kDebugBrk |
|||
} debug_state; |
|||
IsolateDebugger* debugger_instance; |
|||
|
|||
// Call this before instantiating any Isolate
|
|||
static void Initialize(); |
|||
static int Count(); |
|||
|
|||
typedef void (*AtExitCallback)(void* arg); |
|||
|
|||
static v8::Handle<v8::Value> Send(const v8::Arguments& args); |
|||
static v8::Handle<v8::Value> Unref(const v8::Arguments& args); |
|||
|
|||
static Isolate* GetCurrent() { |
|||
return reinterpret_cast<Isolate*>(v8::Isolate::GetCurrent()->GetData()); |
|||
} |
|||
|
|||
uv_loop_t* GetLoop() { |
|||
NODE_ISOLATE_CHECK(this); |
|||
return loop_; |
|||
} |
|||
|
|||
v8::Isolate* GetV8Isolate() { |
|||
NODE_ISOLATE_CHECK(this); |
|||
return v8_isolate_; |
|||
} |
|||
|
|||
v8::Handle<v8::Context> GetV8Context() { |
|||
NODE_ISOLATE_CHECK(this); |
|||
return v8_context_; |
|||
} |
|||
|
|||
/* Register a handler that should run when the current isolate exits.
|
|||
* Handlers run in LIFO order. |
|||
*/ |
|||
void AtExit(AtExitCallback callback, void *arg); |
|||
|
|||
struct globals* Globals(); |
|||
|
|||
unsigned int id_; |
|||
|
|||
// This constructor is used for every non-main thread
|
|||
Isolate(); |
|||
~Isolate(); |
|||
|
|||
void Enter(); |
|||
void Exit(); |
|||
|
|||
/* Shutdown the isolate. Call this method at thread death. */ |
|||
void Dispose(); |
|||
|
|||
private: |
|||
friend class IsolateWrap; |
|||
|
|||
struct AtExitCallbackInfo { |
|||
AtExitCallback callback_; |
|||
ngx_queue_t queue_; |
|||
void* arg_; |
|||
}; |
|||
|
|||
static void OnMessage(IsolateMessage*, void*); |
|||
|
|||
// Forbid implicit constructors and copy constructors
|
|||
void operator=(const Isolate&) {} |
|||
Isolate(const Isolate&) {} |
|||
|
|||
ngx_queue_t isolate_list_; // linked list of all isolates
|
|||
ngx_queue_t at_exit_callbacks_; |
|||
v8::Persistent<v8::Context> v8_context_; |
|||
v8::Isolate* v8_isolate_; |
|||
IsolateChannel* send_channel_; |
|||
IsolateChannel* recv_channel_; |
|||
uv_loop_t* loop_; |
|||
|
|||
// Global variables for this isolate.
|
|||
struct globals globals_; |
|||
bool globals_init_; |
|||
}; |
|||
|
|||
class IsolateDebugger : ObjectWrap { |
|||
public: |
|||
static void Initialize(); |
|||
void Init(); |
|||
static void InitCallback(uv_async_t* c, int status); |
|||
|
|||
static v8::Handle<v8::Value> New(const v8::Arguments& args); |
|||
static IsolateDebugger* New(v8::Handle<v8::Value> init); |
|||
|
|||
static v8::Handle<v8::Value> Write(const v8::Arguments& args); |
|||
|
|||
static void DebugMessageHandler(const v8::Debug::Message& message); |
|||
static void MessageCallback(IsolateDebuggerMessage* msg, void*); |
|||
|
|||
IsolateDebugger(v8::Handle<v8::Value> init); |
|||
~IsolateDebugger(); |
|||
|
|||
protected: |
|||
Isolate* host_; |
|||
uv_loop_t* host_loop_; |
|||
|
|||
uv_async_t init_callback_; |
|||
v8::Persistent<v8::Value> init_callback_fn_; |
|||
|
|||
bool initialized_; |
|||
Isolate* debuggee_; |
|||
v8::Isolate* debuggee_v8_; |
|||
|
|||
struct debug_msg_s { |
|||
uint16_t* value; |
|||
int len; |
|||
|
|||
IsolateDebugger* d; |
|||
}; |
|||
|
|||
Channel<IsolateDebuggerMessage*>* msg_channel_; |
|||
}; |
|||
|
|||
} // namespace node
|
|||
|
|||
#endif // SRC_NODE_ISOLATE_H_
|
|||
@ -1,48 +0,0 @@ |
|||
#include <node_vars.h> |
|||
#include <node_isolate.h> |
|||
#if HAVE_OPENSSL |
|||
# include <node_crypto.h> |
|||
#endif |
|||
#include <string.h> |
|||
|
|||
namespace node { |
|||
|
|||
// For now we just statically initialize the globals structure. Later there
|
|||
// will be one struct globals for each isolate.
|
|||
|
|||
void globals_init(struct globals* g) { |
|||
memset(g, 0, sizeof(struct globals)); |
|||
|
|||
#ifdef OPENSSL_NPN_NEGOTIATED |
|||
g->use_npn = true; |
|||
#else |
|||
g->use_npn = false; |
|||
#endif |
|||
|
|||
#ifdef SSL_CTRL_SET_TLSEXT_SERVERNAME_CB |
|||
g->use_sni = true; |
|||
#else |
|||
g->use_sni = false; |
|||
#endif |
|||
} |
|||
|
|||
|
|||
#if HAVE_ISOLATES |
|||
struct globals* globals_get() { |
|||
node::Isolate* isolate = node::Isolate::GetCurrent(); |
|||
return isolate->Globals(); |
|||
} |
|||
#else |
|||
static struct globals g_struct; |
|||
static struct globals* g_ptr; |
|||
|
|||
struct globals* globals_get() { |
|||
if (!g_ptr) { |
|||
g_ptr = &g_struct; |
|||
globals_init(g_ptr); |
|||
} |
|||
return g_ptr; |
|||
} |
|||
#endif // HAVE_ISOLATES
|
|||
|
|||
} // namespace node
|
|||
@ -1,197 +0,0 @@ |
|||
#ifndef NODE_VARS_H |
|||
#define NODE_VARS_H |
|||
|
|||
// This file contains all Isolate-local variables. We allow people to
|
|||
// compile Node either with Isolates or without. In the case that they
|
|||
// compile without isolates, these will be static variables.
|
|||
|
|||
#include <v8.h> |
|||
#include <uv.h> |
|||
#include <http_parser.h> |
|||
|
|||
#if defined(_MSC_VER) |
|||
# define PATH_MAX MAX_PATH |
|||
#endif |
|||
|
|||
#ifndef PATH_MAX |
|||
# define PATH_MAX 4096 |
|||
#endif |
|||
|
|||
namespace node { |
|||
|
|||
|
|||
#define NODE_VAR(x) (globals_get()->x) |
|||
|
|||
struct globals { |
|||
// node.cc
|
|||
v8::Persistent<v8::Object> process; |
|||
v8::Persistent<v8::String> errno_symbol; |
|||
v8::Persistent<v8::String> syscall_symbol; |
|||
v8::Persistent<v8::String> errpath_symbol; |
|||
v8::Persistent<v8::String> code_symbol; |
|||
v8::Persistent<v8::String> rss_symbol; |
|||
v8::Persistent<v8::String> heap_total_symbol; |
|||
v8::Persistent<v8::String> heap_used_symbol; |
|||
v8::Persistent<v8::String> listeners_symbol; |
|||
v8::Persistent<v8::String> uncaught_exception_symbol; |
|||
v8::Persistent<v8::String> emit_symbol; |
|||
uv_check_t check_tick_watcher; |
|||
uv_prepare_t prepare_tick_watcher; |
|||
uv_idle_t tick_spinner; |
|||
bool need_tick_cb; |
|||
v8::Persistent<v8::String> tick_callback_sym; |
|||
bool use_npn; |
|||
bool use_sni; |
|||
// Buffer for getpwnam_r(), getgrpam_r() and other misc callers; keep this
|
|||
// scoped at file-level rather than method-level to avoid excess stack usage.
|
|||
char getbuf[PATH_MAX + 1]; |
|||
// We need to notify V8 when we're idle so that it can run the garbage
|
|||
// collector. The interface to this is V8::IdleNotification(). It returns
|
|||
// true if the heap hasn't be fully compacted, and needs to be run again.
|
|||
// Returning false means that it doesn't have anymore work to do.
|
|||
//
|
|||
// A rather convoluted algorithm has been devised to determine when Node is
|
|||
// idle. You'll have to figure it out for yourself.
|
|||
uv_check_t gc_check; |
|||
uv_idle_t gc_idle; |
|||
uv_timer_t gc_timer; |
|||
bool need_gc; |
|||
# define FAST_TICK 700. |
|||
# define GC_WAIT_TIME 5000. |
|||
# define RPM_SAMPLES 100 |
|||
int64_t tick_times[RPM_SAMPLES]; |
|||
int tick_time_head; |
|||
int uncaught_exception_counter; |
|||
v8::Persistent<v8::Object> binding_cache; |
|||
v8::Persistent<v8::Array> module_load_list; |
|||
v8::Isolate* node_isolate; |
|||
volatile bool debugger_running; |
|||
double prog_start_time; |
|||
|
|||
// stream_wrap.cc
|
|||
size_t slab_used; |
|||
uv_stream_t* handle_that_last_alloced; |
|||
v8::Persistent<v8::String> slab_sym; |
|||
v8::Persistent<v8::String> buffer_sym; |
|||
v8::Persistent<v8::String> write_queue_size_sym; |
|||
bool stream_wrap_initialized; |
|||
|
|||
// tcp_wrap.cc
|
|||
v8::Persistent<v8::Function> tcpConstructor; |
|||
v8::Persistent<v8::String> family_symbol; |
|||
v8::Persistent<v8::String> address_symbol; |
|||
v8::Persistent<v8::String> port_symbol; |
|||
|
|||
// node_http_parser.cc
|
|||
v8::Persistent<v8::String> on_headers_sym; |
|||
v8::Persistent<v8::String> on_headers_complete_sym; |
|||
v8::Persistent<v8::String> on_body_sym; |
|||
v8::Persistent<v8::String> on_message_complete_sym; |
|||
v8::Persistent<v8::String> delete_sym; |
|||
v8::Persistent<v8::String> get_sym; |
|||
v8::Persistent<v8::String> head_sym; |
|||
v8::Persistent<v8::String> post_sym; |
|||
v8::Persistent<v8::String> put_sym; |
|||
v8::Persistent<v8::String> connect_sym; |
|||
v8::Persistent<v8::String> options_sym; |
|||
v8::Persistent<v8::String> trace_sym; |
|||
v8::Persistent<v8::String> patch_sym; |
|||
v8::Persistent<v8::String> copy_sym; |
|||
v8::Persistent<v8::String> lock_sym; |
|||
v8::Persistent<v8::String> mkcol_sym; |
|||
v8::Persistent<v8::String> move_sym; |
|||
v8::Persistent<v8::String> propfind_sym; |
|||
v8::Persistent<v8::String> proppatch_sym; |
|||
v8::Persistent<v8::String> unlock_sym; |
|||
v8::Persistent<v8::String> report_sym; |
|||
v8::Persistent<v8::String> mkactivity_sym; |
|||
v8::Persistent<v8::String> checkout_sym; |
|||
v8::Persistent<v8::String> merge_sym; |
|||
v8::Persistent<v8::String> msearch_sym; |
|||
v8::Persistent<v8::String> notify_sym; |
|||
v8::Persistent<v8::String> subscribe_sym; |
|||
v8::Persistent<v8::String> unsubscribe_sym; |
|||
v8::Persistent<v8::String> unknown_method_sym; |
|||
v8::Persistent<v8::String> method_sym; |
|||
v8::Persistent<v8::String> status_code_sym; |
|||
v8::Persistent<v8::String> http_version_sym; |
|||
v8::Persistent<v8::String> version_major_sym; |
|||
v8::Persistent<v8::String> version_minor_sym; |
|||
v8::Persistent<v8::String> should_keep_alive_sym; |
|||
v8::Persistent<v8::String> upgrade_sym; |
|||
v8::Persistent<v8::String> headers_sym; |
|||
v8::Persistent<v8::String> url_sym; |
|||
struct http_parser_settings settings; |
|||
// This is a hack to get the current_buffer to the callbacks with the least
|
|||
// amount of overhead. Nothing else will run while http_parser_execute()
|
|||
// runs, therefore this pointer can be set and used for the execution.
|
|||
v8::Local<v8::Value>* current_buffer; |
|||
char* current_buffer_data; |
|||
size_t current_buffer_len; |
|||
|
|||
// node_file.cc
|
|||
v8::Persistent<v8::String> encoding_symbol; |
|||
v8::Persistent<v8::String> buf_symbol; |
|||
v8::Persistent<v8::String> oncomplete_sym; |
|||
v8::Persistent<v8::FunctionTemplate> stats_constructor_template; |
|||
v8::Persistent<v8::String> dev_symbol; |
|||
v8::Persistent<v8::String> ino_symbol; |
|||
v8::Persistent<v8::String> mode_symbol; |
|||
v8::Persistent<v8::String> nlink_symbol; |
|||
v8::Persistent<v8::String> uid_symbol; |
|||
v8::Persistent<v8::String> gid_symbol; |
|||
v8::Persistent<v8::String> rdev_symbol; |
|||
v8::Persistent<v8::String> size_symbol; |
|||
v8::Persistent<v8::String> blksize_symbol; |
|||
v8::Persistent<v8::String> blocks_symbol; |
|||
v8::Persistent<v8::String> atime_symbol; |
|||
v8::Persistent<v8::String> mtime_symbol; |
|||
v8::Persistent<v8::String> ctime_symbol; |
|||
|
|||
// node_zlib.cc
|
|||
v8::Persistent<v8::String> callback_sym; |
|||
|
|||
// node_crypto.cc
|
|||
v8::Persistent<v8::String> subject_symbol; |
|||
v8::Persistent<v8::String> subjectaltname_symbol; |
|||
v8::Persistent<v8::String> modulus_symbol; |
|||
v8::Persistent<v8::String> exponent_symbol; |
|||
v8::Persistent<v8::String> issuer_symbol; |
|||
v8::Persistent<v8::String> valid_from_symbol; |
|||
v8::Persistent<v8::String> valid_to_symbol; |
|||
v8::Persistent<v8::String> fingerprint_symbol; |
|||
v8::Persistent<v8::String> name_symbol; |
|||
v8::Persistent<v8::String> version_symbol; |
|||
v8::Persistent<v8::String> ext_key_usage_symbol; |
|||
v8::Persistent<v8::FunctionTemplate> secure_context_constructor; |
|||
|
|||
// node_buffer.cc
|
|||
v8::Persistent<v8::String> length_symbol; |
|||
v8::Persistent<v8::String> chars_written_sym; |
|||
v8::Persistent<v8::String> write_sym; |
|||
v8::Persistent<v8::FunctionTemplate> buffer_constructor_template; |
|||
|
|||
// node_script.cc
|
|||
v8::Persistent<v8::FunctionTemplate> wrapped_context_constructor; |
|||
v8::Persistent<v8::FunctionTemplate> wrapped_script_constructor; |
|||
|
|||
// node_isolate.cc
|
|||
v8::Persistent<v8::FunctionTemplate> isolate_debugger_constructor; |
|||
|
|||
// node_signal_watcher.cc
|
|||
v8::Persistent<v8::String> callback_symbol; |
|||
v8::Persistent<v8::FunctionTemplate> signal_watcher_constructor_template; |
|||
|
|||
// cares_wrap.cc
|
|||
::ares_channel ares_channel; |
|||
}; |
|||
|
|||
// Initialize globals struct.
|
|||
void globals_init(struct globals*); |
|||
|
|||
// Get the globals struct for the current Isolate. The returned pointer is
|
|||
// already initialized.
|
|||
struct globals* globals_get(); |
|||
|
|||
} // namespace node
|
|||
#endif // NODE_VARS_H
|
|||
@ -1,55 +0,0 @@ |
|||
#include <node.h> |
|||
#include <v8.h> |
|||
#include <uv.h> |
|||
|
|||
using namespace v8; |
|||
|
|||
extern "C" { |
|||
void init(Handle<Object> target); |
|||
} |
|||
|
|||
|
|||
#define BUFSIZE 1024 |
|||
static uint8_t buf[BUFSIZE]; |
|||
static uv_mutex_t lock; |
|||
|
|||
|
|||
Handle<Value> Get(const Arguments& args) { |
|||
HandleScope scope; |
|||
|
|||
int index = args[0]->Uint32Value(); |
|||
|
|||
if (index < 0 || BUFSIZE <= index) { |
|||
return ThrowException(Exception::Error(String::New("out of bounds"))); |
|||
} |
|||
|
|||
return scope.Close(Integer::New(buf[index])); |
|||
} |
|||
|
|||
|
|||
Handle<Value> Set(const Arguments& args) { |
|||
uv_mutex_lock(&lock); |
|||
HandleScope scope; |
|||
|
|||
int index = args[0]->Uint32Value(); |
|||
|
|||
if (index < 0 || BUFSIZE <= index) { |
|||
return ThrowException(Exception::Error(String::New("out of bounds"))); |
|||
} |
|||
|
|||
buf[index] = args[1]->Uint32Value(); |
|||
|
|||
Local<Integer> val = Integer::New(buf[index]); |
|||
|
|||
uv_mutex_unlock(&lock); |
|||
|
|||
return scope.Close(val); |
|||
} |
|||
|
|||
|
|||
void init(Handle<Object> target) { |
|||
NODE_SET_METHOD(target, "get", Get); |
|||
NODE_SET_METHOD(target, "set", Set); |
|||
target->Set(String::New("length"), Integer::New(BUFSIZE)); |
|||
uv_mutex_init(&lock); |
|||
} |
|||
@ -1,8 +0,0 @@ |
|||
{ |
|||
'targets': [ |
|||
{ |
|||
'target_name': 'binding', |
|||
'sources': [ 'binding.cc' ] |
|||
} |
|||
] |
|||
} |
|||
@ -1,19 +0,0 @@ |
|||
var assert = require('assert'); |
|||
var binding = require('./out/Release/binding'); |
|||
var isolates = process.binding('isolates'); |
|||
|
|||
console.log("binding.length =", binding.length); |
|||
|
|||
if (process.tid === 1) { |
|||
var isolate = isolates.create(process.argv); |
|||
for (var i = 0; i < binding.length; i++) { |
|||
console.log('parent', |
|||
'binding.set(' + i + ', ' + i + ')', |
|||
binding.set(i, i)); |
|||
} |
|||
} else { |
|||
for (var i = 0; i < binding.length; i++) { |
|||
console.log('child', 'binding.get(' + i + ')', binding.get(i)); |
|||
} |
|||
} |
|||
|
|||
@ -1,68 +0,0 @@ |
|||
var isolates = process.binding('isolates'); |
|||
var assert = require('assert'); |
|||
|
|||
var N_ISOLATES = 4; |
|||
var N_MESSAGES = 20; |
|||
var N_MESSAGES_PER_TICK = 4; |
|||
|
|||
assert(N_MESSAGES % N_MESSAGES_PER_TICK == 0); |
|||
|
|||
if (process.tid === 1) |
|||
master(); |
|||
else |
|||
child(); |
|||
|
|||
function master() { |
|||
for (var i = 0; i < N_ISOLATES; ++i) spawn(); |
|||
|
|||
function spawn() { |
|||
var isolate = isolates.create(process.argv); |
|||
|
|||
var gotExit = false; // exit event emitted?
|
|||
var msgId = 0; // message IDs seen so far
|
|||
var tick = 0; |
|||
|
|||
isolate.onexit = function() { |
|||
gotExit = true; |
|||
}; |
|||
|
|||
isolate.onmessage = function(buf) { |
|||
var msg = JSON.parse(buf); |
|||
assert.equal(msg.id, msgId + 1); // verify that messages arrive in order
|
|||
assert.equal(msg.tick, tick); // and on the proper tick (=full mq drain)
|
|||
msgId = msg.id; |
|||
if (msgId % N_MESSAGES_PER_TICK == 0) tick++; |
|||
isolate.send(buf); |
|||
}; |
|||
|
|||
process.on('exit', function() { |
|||
assert.equal(gotExit, true); |
|||
assert.equal(msgId, N_MESSAGES); |
|||
assert.equal(tick, N_MESSAGES / N_MESSAGES_PER_TICK); |
|||
}); |
|||
} |
|||
} |
|||
|
|||
function child() { |
|||
var msgId = 0; |
|||
var tick = 0; |
|||
|
|||
function send() { |
|||
// Send multiple messages, verify that the message queue
|
|||
// is completely drained on each tick of the event loop.
|
|||
for (var i = 0; i < N_MESSAGES_PER_TICK; ++i) { |
|||
process.send({tick:tick, id:++msgId}); |
|||
} |
|||
|
|||
if (msgId < N_MESSAGES) { |
|||
setTimeout(send, 10); |
|||
} |
|||
|
|||
tick++; |
|||
} |
|||
|
|||
send(); |
|||
|
|||
process._onmessage = function(m) { |
|||
}; |
|||
} |
|||
@ -1,60 +0,0 @@ |
|||
var fs = require('fs'); |
|||
var http = require('http'); |
|||
var isolates = process.binding('isolates'); |
|||
|
|||
console.log("count: %d", isolates.count()); |
|||
|
|||
if (process.tid === 1) { |
|||
var isolate = isolates.create(process.argv, { |
|||
debug: function init(d) { |
|||
d.onmessage = function(data) { |
|||
data = JSON.parse(data); |
|||
if (data.event === 'break') { |
|||
d.write(JSON.stringify({ |
|||
type: 'request', |
|||
seq: 1, |
|||
command: 'continue' |
|||
})); |
|||
} |
|||
}; |
|||
} |
|||
}); |
|||
|
|||
isolate.onmessage = function() { |
|||
console.error("onmessage"); |
|||
}; |
|||
isolate.onexit = function() { |
|||
console.error("onexit"); |
|||
}; |
|||
|
|||
console.error("master"); |
|||
fs.stat(__dirname, function(err, stat) { |
|||
if (err) throw err; |
|||
console.error('thread 1', stat.mtime); |
|||
}); |
|||
|
|||
setTimeout(function() { |
|||
fs.stat(__dirname, function(err, stat) { |
|||
if (err) throw err; |
|||
console.error('thread 1', stat.mtime); |
|||
}); |
|||
}, 500); |
|||
|
|||
console.log("thread 1 count: %d", isolates.count()); |
|||
} else { |
|||
console.error("slave"); |
|||
fs.stat(__dirname, function(err, stat) { |
|||
if (err) throw err; |
|||
console.error('thread 2', stat.mtime); |
|||
}); |
|||
|
|||
setTimeout(function() { |
|||
fs.stat(__dirname, function(err, stat) { |
|||
if (err) throw err; |
|||
console.error('thread 2', stat.mtime); |
|||
process.exit(); |
|||
}); |
|||
}, 500); |
|||
|
|||
console.error("thread 2 count: %d", isolates.count()); |
|||
} |
|||
@ -1,13 +0,0 @@ |
|||
// Skip this test if Node is not compiled with isolates support.
|
|||
if (!process.features.isolates) return; |
|||
|
|||
var assert = require('assert'); |
|||
|
|||
// This is the same test as test-child-process-fork except it uses isolates
|
|||
// instead of processes. process.TEST_ISOLATE is a ghetto method of passing
|
|||
// some information into the other test.
|
|||
process.TEST_ISOLATE = true; |
|||
require('./test-child-process-fork'); |
|||
|
|||
var numThreads = process.binding('isolates').count(); |
|||
assert.ok(numThreads > 1); |
|||
@ -1,13 +0,0 @@ |
|||
// Skip this test if Node is not compiled with isolates support.
|
|||
if (!process.features.isolates) return; |
|||
|
|||
var assert = require('assert'); |
|||
|
|||
// This is the same test as test-child-process-fork2 except it uses isolates
|
|||
// instead of processes. process.TEST_ISOLATE is a ghetto method of passing
|
|||
// some information into the other test.
|
|||
process.TEST_ISOLATE = true; |
|||
require('./test-child-process-fork2'); |
|||
|
|||
var numThreads = process.binding('isolates').count(); |
|||
assert.ok(numThreads > 1); |
|||
@ -1,13 +0,0 @@ |
|||
// Skip this test if Node is not compiled with isolates support.
|
|||
if (!process.features.isolates) return; |
|||
|
|||
var assert = require('assert'); |
|||
|
|||
// This is the same test as test-child-process-fork3 except it uses isolates
|
|||
// instead of processes. process.TEST_ISOLATE is a ghetto method of passing
|
|||
// some information into the other test.
|
|||
process.TEST_ISOLATE = true; |
|||
require('./test-child-process-fork3'); |
|||
|
|||
var numThreads = process.binding('isolates').count(); |
|||
assert.ok(numThreads > 1); |
|||
Loading…
Reference in new issue