Skip to content

Commit a2c5538

Browse files
WiddershinWiddershin
authored
[WIP] Restructure module for thread safety using context aware initialization
PR-URL: #15 Reviewed-BY: hyj1991 <[email protected]>
1 parent 97fdcf8 commit a2c5538

12 files changed

+168
-72
lines changed

‎binding.gyp

+1
Original file line numberDiff line numberDiff line change
@@ -7,6 +7,7 @@
77
'src/profiler.cc',
88
'src/cpu_profiler.cc',
99
'src/cpu_profile.cc',
10+
'src/profiler_data.cc',
1011
'src/cpu_profile_node.cc',
1112
'src/heap_profiler.cc',
1213
'src/heap_snapshot.cc',

‎src/cpu_profile.cc

+17-12
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,6 @@
11
#include "cpu_profile.h"
22
#include "cpu_profile_node.h"
3+
#include "profiler_data.h"
34

45
namespace nodex {
56
using v8::Array;
@@ -15,49 +16,53 @@ namespace nodex {
1516
using v8::Function;
1617
using v8::Value;
1718
using v8::Isolate;
19+
using v8::External;
1820

19-
Nan::Persistent<ObjectTemplate> Profile::profile_template_;
20-
Nan::Persistent<Object> Profile::profiles;
2121
uint32_t Profile::uid_counter = 0;
2222

2323
NAN_METHOD(Profile_EmptyMethod) {
2424
}
2525

26-
void Profile::Initialize () {
26+
void Profile::Initialize (ProfilerData* data) {
2727
Nan::HandleScope scope;
2828

2929
Local<FunctionTemplate> f = Nan::New<FunctionTemplate>(Profile_EmptyMethod);
3030
Local<ObjectTemplate> o = f->InstanceTemplate();
3131
o->SetInternalFieldCount(1);
32-
Nan::SetMethod(o, "delete", Profile::Delete);
33-
profile_template_.Reset(o);
32+
Local<External> externalData = Nan::New<External>(data);
33+
Nan::SetMethod(o, "delete", Profile::Delete, externalData);
34+
data->profile_template_.Reset(o);
3435
}
3536

3637
NAN_METHOD(Profile::Delete) {
3738
Local<Object> self = info.This();
3839
void* ptr = Nan::GetInternalFieldPointer(self, 0);
39-
Local<Object> profiles = Nan::New<Object>(Profile::profiles);
40+
41+
ProfilerData* data =
42+
reinterpret_cast<ProfilerData*>(info.Data().As<External>()->Value());
43+
44+
Local<Object> profiles = Nan::New<Object>(data->profiles);
4045
Local<Value> _uid = Nan::Get(info.This(), Nan::New<String>("uid").ToLocalChecked()).ToLocalChecked();
4146
Local<String> uid = Nan::To<String>(_uid).ToLocalChecked();
4247
Nan::Delete(profiles, uid);
4348
static_cast<CpuProfile*>(ptr)->Delete();
4449
}
4550

46-
Local<Value> Profile::New (const CpuProfile* node) {
51+
Local<Value> Profile::New (ProfilerData* data, const CpuProfile* node) {
4752
Nan::EscapableHandleScope scope;
4853

49-
if (profile_template_.IsEmpty()) {
50-
Profile::Initialize();
54+
if (data->profile_template_.IsEmpty()) {
55+
Profile::Initialize(data);
5156
}
5257

5358
uid_counter++;
5459

5560
Local<Object> profile;
5661
#if (NODE_MODULE_VERSION > 0x0040)
57-
profile = Nan::New(profile_template_)->
62+
profile = Nan::New(data->profile_template_)->
5863
NewInstance(Nan::GetCurrentContext()).ToLocalChecked();
5964
#else
60-
profile = Nan::New(profile_template_)->NewInstance();
65+
profile = Nan::New(data->profile_template_)->NewInstance();
6166
#endif
6267
Nan::SetInternalFieldPointer(profile, 0, const_cast<CpuProfile*>(node));
6368

@@ -102,7 +107,7 @@ namespace nodex {
102107
Nan::Set(profile, Nan::New<String>("timestamps").ToLocalChecked(), timestamps);
103108
#endif
104109

105-
Local<Object> profiles = Nan::New<Object>(Profile::profiles);
110+
Local<Object> profiles = Nan::New<Object>(data->profiles);
106111
Nan::Set(profiles, uid, profile);
107112

108113
return scope.Escape(profile);

‎src/cpu_profile.h

+4-5
Original file line numberDiff line numberDiff line change
@@ -2,19 +2,18 @@
22
#define NODE_PROFILE_
33

44
#include "v8-profiler.h"
5+
#include "profiler_data.h"
56
#include "nan.h"
67

78
namespace nodex {
89

910
class Profile {
1011
public:
11-
static v8::Local<v8::Value> New(const v8::CpuProfile* node);
12-
static Nan::Persistent<v8::Object> profiles;
12+
static v8::Local<v8::Value> New(ProfilerData* data, const v8::CpuProfile* node);
1313
private:
1414
static NAN_METHOD(Delete);
15-
static void Initialize();
16-
static Nan::Persistent<v8::ObjectTemplate> profile_template_;
17-
static uint32_t uid_counter;
15+
static void Initialize(ProfilerData* data);
16+
static uint32_t uid_counter; // TODO - is this going to cause thread safety issues?
1817
};
1918

2019
} //namespace nodex

‎src/cpu_profiler.cc

+34-22
Original file line numberDiff line numberDiff line change
@@ -2,45 +2,50 @@
22
#include "cpu_profile.h"
33

44
namespace nodex {
5+
using v8::Array;
6+
using v8::Boolean;
7+
using v8::Context;
58
using v8::CpuProfile;
9+
using v8::External;
610
using v8::Local;
711
using v8::Object;
8-
using v8::Array;
912
using v8::String;
10-
using v8::Boolean;
11-
12-
#if (NODE_MODULE_VERSION > 0x0039)
13-
v8::CpuProfiler* current_cpu_profiler = v8::CpuProfiler::New(v8::Isolate::GetCurrent());
14-
#endif
1513

1614
CpuProfiler::CpuProfiler () {}
1715
CpuProfiler::~CpuProfiler () {}
1816

19-
void CpuProfiler::Initialize (Local<Object> target) {
17+
void CpuProfiler::Initialize (Local<Object> target, Local<Context> context, ProfilerData* data) {
2018
Nan::HandleScope scope;
2119

2220
Local<Object> cpuProfiler = Nan::New<Object>();
2321
Local<Array> profiles = Nan::New<Array>();
2422

25-
Nan::SetMethod(cpuProfiler, "startProfiling", CpuProfiler::StartProfiling);
26-
Nan::SetMethod(cpuProfiler, "stopProfiling", CpuProfiler::StopProfiling);
27-
Nan::SetMethod(cpuProfiler, "setSamplingInterval", CpuProfiler::SetSamplingInterval);
23+
Local<External> externalData = Nan::New<External>(data);
24+
25+
v8::CpuProfiler* profiler = v8::CpuProfiler::New(context->GetIsolate());
26+
27+
data->profiler = profiler;
28+
29+
Nan::SetMethod(cpuProfiler, "startProfiling", CpuProfiler::StartProfiling, externalData);
30+
Nan::SetMethod(cpuProfiler, "stopProfiling", CpuProfiler::StopProfiling, externalData);
31+
Nan::SetMethod(cpuProfiler, "setSamplingInterval", CpuProfiler::SetSamplingInterval, externalData);
2832
Nan::SetMethod(cpuProfiler, "collectSample", CpuProfiler::CollectSample);
2933
Nan::Set(cpuProfiler, Nan::New<String>("profiles").ToLocalChecked(), profiles);
3034

31-
Profile::profiles.Reset(profiles);
35+
data->profiles.Reset(profiles);
3236
Nan::Set(target, Nan::New<String>("cpu").ToLocalChecked(), cpuProfiler);
3337
}
3438

3539
NAN_METHOD(CpuProfiler::StartProfiling) {
3640
Local<String> title = Nan::To<String>(info[0]).ToLocalChecked();
3741

38-
#if (NODE_MODULE_VERSION > 0x0039)
39-
bool recsamples = Nan::To<Boolean>(info[1]).ToLocalChecked()->Value();
40-
current_cpu_profiler->StartProfiling(title, recsamples);
41-
#elif (NODE_MODULE_VERSION > 0x000B)
42+
ProfilerData* data =
43+
reinterpret_cast<ProfilerData*>(info.Data().As<External>()->Value());
44+
v8::CpuProfiler* profiler = data->profiler;
45+
46+
#if (NODE_MODULE_VERSION > 0x000B)
4247
bool recsamples = Nan::To<Boolean>(info[1]).ToLocalChecked()->Value();
43-
v8::Isolate::GetCurrent()->GetCpuProfiler()->StartProfiling(title, recsamples);
48+
profiler->StartProfiling(title, recsamples);
4449
#else
4550
v8::CpuProfiler::StartProfiling(title);
4651
#endif
@@ -49,6 +54,10 @@ namespace nodex {
4954
NAN_METHOD(CpuProfiler::StopProfiling) {
5055
const CpuProfile* profile;
5156

57+
ProfilerData* data =
58+
reinterpret_cast<ProfilerData*>(info.Data().As<External>()->Value());
59+
v8::CpuProfiler* profiler = data->profiler;
60+
5261
Local<String> title = Nan::EmptyString();
5362
if (info.Length()) {
5463
if (info[0]->IsString()) {
@@ -58,20 +67,23 @@ namespace nodex {
5867
}
5968
}
6069

61-
#if (NODE_MODULE_VERSION > 0x0039)
62-
profile = current_cpu_profiler->StopProfiling(title);
63-
#elif (NODE_MODULE_VERSION > 0x000B)
64-
profile = v8::Isolate::GetCurrent()->GetCpuProfiler()->StopProfiling(title);
70+
#if (NODE_MODULE_VERSION > 0x000B)
71+
profile = profiler->StopProfiling(title);
6572
#else
6673
profile = v8::CpuProfiler::StopProfiling(title);
6774
#endif
6875

69-
info.GetReturnValue().Set(Profile::New(profile));
76+
info.GetReturnValue().Set(Profile::New(data, profile));
7077
}
7178

7279
NAN_METHOD(CpuProfiler::SetSamplingInterval) {
7380
#if (NODE_MODULE_VERSION > 0x0039)
74-
current_cpu_profiler->SetSamplingInterval(Nan::To<uint32_t>(info[0]).ToChecked());
81+
ProfilerData* data =
82+
reinterpret_cast<ProfilerData*>(info.Data().As<External>()->Value());
83+
84+
v8::CpuProfiler* profiler = data->profiler;
85+
86+
profiler->SetSamplingInterval(Nan::To<uint32_t>(info[0]).ToChecked());
7587
#elif (NODE_MODULE_VERSION > 0x000B)
7688
v8::Isolate::GetCurrent()->GetCpuProfiler()->SetSamplingInterval(Nan::To<uint32_t>(info[0]).ToChecked());
7789
#endif

‎src/cpu_profiler.h

+2-1
Original file line numberDiff line numberDiff line change
@@ -2,13 +2,14 @@
22
#define NODE_CPU_PROFILER_
33

44
#include "v8-profiler.h"
5+
#include "profiler_data.h"
56
#include "node.h"
67
#include "nan.h"
78

89
namespace nodex {
910
class CpuProfiler {
1011
public:
11-
static void Initialize(v8::Local<v8::Object> target);
12+
static void Initialize(v8::Local<v8::Object> target, v8::Local<v8::Context> context, ProfilerData* data);
1213

1314
CpuProfiler();
1415
virtual ~CpuProfiler();

‎src/heap_profiler.cc

+11-5
Original file line numberDiff line numberDiff line change
@@ -3,16 +3,18 @@
33
#include "heap_output_stream.h"
44

55
namespace nodex {
6+
using Nan::TryCatch;
67
using v8::ActivityControl;
78
using v8::Array;
9+
using v8::Context;
10+
using v8::External;
811
using v8::Function;
912
using v8::HeapSnapshot;
1013
using v8::Integer;
1114
using v8::Local;
1215
using v8::Object;
1316
using v8::SnapshotObjectId;
1417
using v8::String;
15-
using Nan::TryCatch;
1618
using v8::Value;
1719

1820
HeapProfiler::HeapProfiler() {}
@@ -47,21 +49,23 @@ namespace nodex {
4749
Local<Value> abort;
4850
};
4951

50-
void HeapProfiler::Initialize (Local<Object> target) {
52+
void HeapProfiler::Initialize (Local<Object> target, Local<Context> context, ProfilerData* data) {
5153
Nan::HandleScope scope;
5254

5355
Local<Object> heapProfiler = Nan::New<Object>();
5456
Local<Object> snapshots = Nan::New<Object>();
5557

56-
Nan::SetMethod(heapProfiler, "takeSnapshot", HeapProfiler::TakeSnapshot);
58+
Local<External> externalData = Nan::New<External>(data);
59+
60+
Nan::SetMethod(heapProfiler, "takeSnapshot", HeapProfiler::TakeSnapshot, externalData);
5761
Nan::SetMethod(heapProfiler, "startTrackingHeapObjects", HeapProfiler::StartTrackingHeapObjects);
5862
Nan::SetMethod(heapProfiler, "stopTrackingHeapObjects", HeapProfiler::StopTrackingHeapObjects);
5963
Nan::SetMethod(heapProfiler, "getHeapStats", HeapProfiler::GetHeapStats);
6064
Nan::SetMethod(heapProfiler, "getObjectByHeapObjectId", HeapProfiler::GetObjectByHeapObjectId);
6165
Nan::SetMethod(heapProfiler, "getHeapObjectId", HeapProfiler::GetHeapObjectId);
6266
Nan::Set(heapProfiler, Nan::New<String>("snapshots").ToLocalChecked(), snapshots);
6367

64-
Snapshot::snapshots.Reset(snapshots);
68+
data->snapshots.Reset(snapshots);
6569
Nan::Set(target, Nan::New<String>("heap").ToLocalChecked(), heapProfiler);
6670
}
6771

@@ -83,7 +87,9 @@ namespace nodex {
8387
const HeapSnapshot* snapshot = v8::HeapProfiler::TakeSnapshot(title, HeapSnapshot::kFull, control);
8488
#endif
8589

86-
info.GetReturnValue().Set(Snapshot::New(snapshot));
90+
ProfilerData* data =
91+
reinterpret_cast<ProfilerData*>(info.Data().As<External>()->Value());
92+
info.GetReturnValue().Set(Snapshot::New(data, snapshot));
8793
}
8894

8995
NAN_METHOD(HeapProfiler::StartTrackingHeapObjects) {

‎src/heap_profiler.h

+2-1
Original file line numberDiff line numberDiff line change
@@ -4,11 +4,12 @@
44
#include "v8-profiler.h"
55
#include "node.h"
66
#include "nan.h"
7+
#include "profiler_data.h"
78

89
namespace nodex {
910
class HeapProfiler {
1011
public:
11-
static void Initialize(v8::Local<v8::Object> target);
12+
static void Initialize(v8::Local<v8::Object> target, v8::Local<v8::Context> context, ProfilerData* data);
1213

1314
HeapProfiler();
1415
virtual ~HeapProfiler();

0 commit comments

Comments
 (0)