Skip to content

Commit 00f0d22

Browse files
addaleaxaddaleax
committed
deps: cherry-pick 9b21865822243 from V8 upstream
Original commit message: [api] Add optional data pointer to GC callbacks This can be useful when there may be multiple callbacks attached by code that's not directly tied to a single isolate, e.g. working on a per-context basis. This also allows rephrasing the global non-isolate APIs in terms of this new API, rather than working around it inside `src/heap`. TBR=hpayer@chromium.org Bug: Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I2e490ec40d1a34ea812f25f41ef9741d2116d965 Reviewed-on: https://chromium-review.googlesource.com/647548 Reviewed-by: Yang Guo <yangguo@chromium.org> Reviewed-by: Adam Klein <adamk@chromium.org> Commit-Queue: Yang Guo <yangguo@chromium.org> Cr-Commit-Position: refs/heads/master@{#47923} PR-URL: nodejs/node#15391 Reviewed-By: James M Snell <jasnell@gmail.com> Reviewed-By: Michaël Zasso <targos@protonmail.com>
1 parent c04350d commit 00f0d22

5 files changed

Lines changed: 162 additions & 76 deletions

File tree

‎deps/v8/include/v8.h‎

Lines changed: 9 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -7203,6 +7203,8 @@ class V8_EXPORT Isolate {
72037203

72047204
typedef void (*GCCallback)(Isolate* isolate, GCType type,
72057205
GCCallbackFlags flags);
7206+
typedef void (*GCCallbackWithData)(Isolate* isolate, GCType type,
7207+
GCCallbackFlags flags, void* data);
72067208

72077209
/**
72087210
* Enables the host application to receive a notification before a
@@ -7213,13 +7215,16 @@ class V8_EXPORT Isolate {
72137215
* not possible to register the same callback function two times with
72147216
* different GCType filters.
72157217
*/
7218+
void AddGCPrologueCallback(GCCallbackWithData callback, void* data = nullptr,
7219+
GCType gc_type_filter = kGCTypeAll);
72167220
void AddGCPrologueCallback(GCCallback callback,
72177221
GCType gc_type_filter = kGCTypeAll);
72187222

72197223
/**
72207224
* This function removes callback which was installed by
72217225
* AddGCPrologueCallback function.
72227226
*/
7227+
void RemoveGCPrologueCallback(GCCallbackWithData, void* data = nullptr);
72237228
void RemoveGCPrologueCallback(GCCallback callback);
72247229

72257230
/**
@@ -7236,13 +7241,17 @@ class V8_EXPORT Isolate {
72367241
* not possible to register the same callback function two times with
72377242
* different GCType filters.
72387243
*/
7244+
void AddGCEpilogueCallback(GCCallbackWithData callback, void* data = nullptr,
7245+
GCType gc_type_filter = kGCTypeAll);
72397246
void AddGCEpilogueCallback(GCCallback callback,
72407247
GCType gc_type_filter = kGCTypeAll);
72417248

72427249
/**
72437250
* This function removes callback which was installed by
72447251
* AddGCEpilogueCallback function.
72457252
*/
7253+
void RemoveGCEpilogueCallback(GCCallbackWithData callback,
7254+
void* data = nullptr);
72467255
void RemoveGCEpilogueCallback(GCCallback callback);
72477256

72487257
typedef size_t (*GetExternallyAllocatedMemoryInBytesCallback)();

‎deps/v8/src/api.cc‎

Lines changed: 47 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -8341,41 +8341,70 @@ v8::Local<Value> Isolate::ThrowException(v8::Local<v8::Value> value) {
83418341
return v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));
83428342
}
83438343

8344-
void Isolate::AddGCPrologueCallback(GCCallback callback, GCType gc_type) {
8344+
void Isolate::AddGCPrologueCallback(GCCallbackWithData callback, void* data,
8345+
GCType gc_type) {
83458346
i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8346-
isolate->heap()->AddGCPrologueCallback(callback, gc_type);
8347+
isolate->heap()->AddGCPrologueCallback(callback, gc_type, data);
83478348
}
83488349

8349-
8350-
void Isolate::RemoveGCPrologueCallback(GCCallback callback) {
8350+
void Isolate::RemoveGCPrologueCallback(GCCallbackWithData callback,
8351+
void* data) {
83518352
i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8352-
isolate->heap()->RemoveGCPrologueCallback(callback);
8353+
isolate->heap()->RemoveGCPrologueCallback(callback, data);
83538354
}
83548355

8356+
void Isolate::AddGCEpilogueCallback(GCCallbackWithData callback, void* data,
8357+
GCType gc_type) {
8358+
i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8359+
isolate->heap()->AddGCEpilogueCallback(callback, gc_type, data);
8360+
}
83558361

8356-
void Isolate::AddGCEpilogueCallback(GCCallback callback, GCType gc_type) {
8362+
void Isolate::RemoveGCEpilogueCallback(GCCallbackWithData callback,
8363+
void* data) {
83578364
i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8358-
isolate->heap()->AddGCEpilogueCallback(callback, gc_type);
8365+
isolate->heap()->RemoveGCEpilogueCallback(callback, data);
83598366
}
83608367

8368+
static void CallGCCallbackWithoutData(Isolate* isolate, GCType type,
8369+
GCCallbackFlags flags, void* data) {
8370+
reinterpret_cast<Isolate::GCCallback>(data)(isolate, type, flags);
8371+
}
83618372

8362-
void Isolate::RemoveGCEpilogueCallback(GCCallback callback) {
8363-
i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
8364-
isolate->heap()->RemoveGCEpilogueCallback(callback);
8373+
void Isolate::AddGCPrologueCallback(GCCallback callback, GCType gc_type) {
8374+
void* data = reinterpret_cast<void*>(callback);
8375+
AddGCPrologueCallback(CallGCCallbackWithoutData, data, gc_type);
83658376
}
83668377

8378+
void Isolate::RemoveGCPrologueCallback(GCCallback callback) {
8379+
void* data = reinterpret_cast<void*>(callback);
8380+
RemoveGCPrologueCallback(CallGCCallbackWithoutData, data);
8381+
}
83678382

8368-
void V8::AddGCPrologueCallback(GCCallback callback, GCType gc_type) {
8369-
i::Isolate* isolate = i::Isolate::Current();
8370-
isolate->heap()->AddGCPrologueCallback(
8371-
reinterpret_cast<v8::Isolate::GCCallback>(callback), gc_type, false);
8383+
void Isolate::AddGCEpilogueCallback(GCCallback callback, GCType gc_type) {
8384+
void* data = reinterpret_cast<void*>(callback);
8385+
AddGCEpilogueCallback(CallGCCallbackWithoutData, data, gc_type);
8386+
}
8387+
8388+
void Isolate::RemoveGCEpilogueCallback(GCCallback callback) {
8389+
void* data = reinterpret_cast<void*>(callback);
8390+
RemoveGCEpilogueCallback(CallGCCallbackWithoutData, data);
83728391
}
83738392

8393+
static void CallGCCallbackWithoutIsolate(Isolate* isolate, GCType type,
8394+
GCCallbackFlags flags, void* data) {
8395+
reinterpret_cast<v8::GCCallback>(data)(type, flags);
8396+
}
83748397

8375-
void V8::AddGCEpilogueCallback(GCCallback callback, GCType gc_type) {
8376-
i::Isolate* isolate = i::Isolate::Current();
8377-
isolate->heap()->AddGCEpilogueCallback(
8378-
reinterpret_cast<v8::Isolate::GCCallback>(callback), gc_type, false);
8398+
void V8::AddGCPrologueCallback(v8::GCCallback callback, GCType gc_type) {
8399+
void* data = reinterpret_cast<void*>(callback);
8400+
Isolate::GetCurrent()->AddGCPrologueCallback(CallGCCallbackWithoutIsolate,
8401+
data, gc_type);
8402+
}
8403+
8404+
void V8::AddGCEpilogueCallback(v8::GCCallback callback, GCType gc_type) {
8405+
void* data = reinterpret_cast<void*>(callback);
8406+
Isolate::GetCurrent()->AddGCEpilogueCallback(CallGCCallbackWithoutIsolate,
8407+
data, gc_type);
83798408
}
83808409

83818410
void Isolate::SetEmbedderHeapTracer(EmbedderHeapTracer* tracer) {

‎deps/v8/src/heap/heap.cc‎

Lines changed: 29 additions & 42 deletions
Original file line numberDiff line numberDiff line change
@@ -57,15 +57,16 @@
5757
namespace v8 {
5858
namespace internal {
5959

60-
bool Heap::GCCallbackPair::operator==(const Heap::GCCallbackPair& other) const {
61-
return other.callback == callback;
60+
bool Heap::GCCallbackTuple::operator==(
61+
const Heap::GCCallbackTuple& other) const {
62+
return other.callback == callback && other.data == data;
6263
}
6364

64-
Heap::GCCallbackPair& Heap::GCCallbackPair::operator=(
65-
const Heap::GCCallbackPair& other) {
65+
Heap::GCCallbackTuple& Heap::GCCallbackTuple::operator=(
66+
const Heap::GCCallbackTuple& other) {
6667
callback = other.callback;
6768
gc_type = other.gc_type;
68-
pass_isolate = other.pass_isolate;
69+
data = other.data;
6970
return *this;
7071
}
7172

@@ -1513,35 +1514,21 @@ bool Heap::PerformGarbageCollection(
15131514
void Heap::CallGCPrologueCallbacks(GCType gc_type, GCCallbackFlags flags) {
15141515
RuntimeCallTimerScope runtime_timer(isolate(),
15151516
&RuntimeCallStats::GCPrologueCallback);
1516-
for (const GCCallbackPair& info : gc_prologue_callbacks_) {
1517+
for (const GCCallbackTuple& info : gc_prologue_callbacks_) {
15171518
if (gc_type & info.gc_type) {
1518-
if (!info.pass_isolate) {
1519-
v8::GCCallback callback =
1520-
reinterpret_cast<v8::GCCallback>(info.callback);
1521-
callback(gc_type, flags);
1522-
} else {
1523-
v8::Isolate* isolate = reinterpret_cast<v8::Isolate*>(this->isolate());
1524-
info.callback(isolate, gc_type, flags);
1525-
}
1519+
v8::Isolate* isolate = reinterpret_cast<v8::Isolate*>(this->isolate());
1520+
info.callback(isolate, gc_type, flags, info.data);
15261521
}
15271522
}
15281523
}
15291524

1530-
1531-
void Heap::CallGCEpilogueCallbacks(GCType gc_type,
1532-
GCCallbackFlags gc_callback_flags) {
1525+
void Heap::CallGCEpilogueCallbacks(GCType gc_type, GCCallbackFlags flags) {
15331526
RuntimeCallTimerScope runtime_timer(isolate(),
15341527
&RuntimeCallStats::GCEpilogueCallback);
1535-
for (const GCCallbackPair& info : gc_epilogue_callbacks_) {
1528+
for (const GCCallbackTuple& info : gc_epilogue_callbacks_) {
15361529
if (gc_type & info.gc_type) {
1537-
if (!info.pass_isolate) {
1538-
v8::GCCallback callback =
1539-
reinterpret_cast<v8::GCCallback>(info.callback);
1540-
callback(gc_type, gc_callback_flags);
1541-
} else {
1542-
v8::Isolate* isolate = reinterpret_cast<v8::Isolate*>(this->isolate());
1543-
info.callback(isolate, gc_type, gc_callback_flags);
1544-
}
1530+
v8::Isolate* isolate = reinterpret_cast<v8::Isolate*>(this->isolate());
1531+
info.callback(isolate, gc_type, flags, info.data);
15451532
}
15461533
}
15471534
}
@@ -5973,21 +5960,21 @@ void Heap::TearDown() {
59735960
memory_allocator_ = nullptr;
59745961
}
59755962

5976-
5977-
void Heap::AddGCPrologueCallback(v8::Isolate::GCCallback callback,
5978-
GCType gc_type, bool pass_isolate) {
5963+
void Heap::AddGCPrologueCallback(v8::Isolate::GCCallbackWithData callback,
5964+
GCType gc_type, void* data) {
59795965
DCHECK_NOT_NULL(callback);
59805966
DCHECK(gc_prologue_callbacks_.end() ==
59815967
std::find(gc_prologue_callbacks_.begin(), gc_prologue_callbacks_.end(),
5982-
GCCallbackPair(callback, gc_type, pass_isolate)));
5983-
gc_prologue_callbacks_.emplace_back(callback, gc_type, pass_isolate);
5968+
GCCallbackTuple(callback, gc_type, data)));
5969+
gc_prologue_callbacks_.emplace_back(callback, gc_type, data);
59845970
}
59855971

5986-
5987-
void Heap::RemoveGCPrologueCallback(v8::Isolate::GCCallback callback) {
5972+
void Heap::RemoveGCPrologueCallback(v8::Isolate::GCCallbackWithData callback,
5973+
void* data) {
59885974
DCHECK_NOT_NULL(callback);
59895975
for (size_t i = 0; i < gc_prologue_callbacks_.size(); i++) {
5990-
if (gc_prologue_callbacks_[i].callback == callback) {
5976+
if (gc_prologue_callbacks_[i].callback == callback &&
5977+
gc_prologue_callbacks_[i].data == data) {
59915978
gc_prologue_callbacks_[i] = gc_prologue_callbacks_.back();
59925979
gc_prologue_callbacks_.pop_back();
59935980
return;
@@ -5996,21 +5983,21 @@ void Heap::RemoveGCPrologueCallback(v8::Isolate::GCCallback callback) {
59965983
UNREACHABLE();
59975984
}
59985985

5999-
6000-
void Heap::AddGCEpilogueCallback(v8::Isolate::GCCallback callback,
6001-
GCType gc_type, bool pass_isolate) {
5986+
void Heap::AddGCEpilogueCallback(v8::Isolate::GCCallbackWithData callback,
5987+
GCType gc_type, void* data) {
60025988
DCHECK_NOT_NULL(callback);
60035989
DCHECK(gc_epilogue_callbacks_.end() ==
60045990
std::find(gc_epilogue_callbacks_.begin(), gc_epilogue_callbacks_.end(),
6005-
GCCallbackPair(callback, gc_type, pass_isolate)));
6006-
gc_epilogue_callbacks_.emplace_back(callback, gc_type, pass_isolate);
5991+
GCCallbackTuple(callback, gc_type, data)));
5992+
gc_epilogue_callbacks_.emplace_back(callback, gc_type, data);
60075993
}
60085994

6009-
6010-
void Heap::RemoveGCEpilogueCallback(v8::Isolate::GCCallback callback) {
5995+
void Heap::RemoveGCEpilogueCallback(v8::Isolate::GCCallbackWithData callback,
5996+
void* data) {
60115997
DCHECK_NOT_NULL(callback);
60125998
for (size_t i = 0; i < gc_epilogue_callbacks_.size(); i++) {
6013-
if (gc_epilogue_callbacks_[i].callback == callback) {
5999+
if (gc_epilogue_callbacks_[i].callback == callback &&
6000+
gc_epilogue_callbacks_[i].data == data) {
60146001
gc_epilogue_callbacks_[i] = gc_epilogue_callbacks_.back();
60156002
gc_epilogue_callbacks_.pop_back();
60166003
return;

‎deps/v8/src/heap/heap.h‎

Lines changed: 18 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -1422,13 +1422,15 @@ class Heap {
14221422
// Prologue/epilogue callback methods.========================================
14231423
// ===========================================================================
14241424

1425-
void AddGCPrologueCallback(v8::Isolate::GCCallback callback,
1426-
GCType gc_type_filter, bool pass_isolate = true);
1427-
void RemoveGCPrologueCallback(v8::Isolate::GCCallback callback);
1425+
void AddGCPrologueCallback(v8::Isolate::GCCallbackWithData callback,
1426+
GCType gc_type_filter, void* data);
1427+
void RemoveGCPrologueCallback(v8::Isolate::GCCallbackWithData callback,
1428+
void* data);
14281429

1429-
void AddGCEpilogueCallback(v8::Isolate::GCCallback callback,
1430-
GCType gc_type_filter, bool pass_isolate = true);
1431-
void RemoveGCEpilogueCallback(v8::Isolate::GCCallback callback);
1430+
void AddGCEpilogueCallback(v8::Isolate::GCCallbackWithData callback,
1431+
GCType gc_type_filter, void* data);
1432+
void RemoveGCEpilogueCallback(v8::Isolate::GCCallbackWithData callback,
1433+
void* data);
14321434

14331435
void CallGCPrologueCallbacks(GCType gc_type, GCCallbackFlags flags);
14341436
void CallGCEpilogueCallbacks(GCType gc_type, GCCallbackFlags flags);
@@ -1588,17 +1590,17 @@ class Heap {
15881590
RootListIndex index;
15891591
};
15901592

1591-
struct GCCallbackPair {
1592-
GCCallbackPair(v8::Isolate::GCCallback callback, GCType gc_type,
1593-
bool pass_isolate)
1594-
: callback(callback), gc_type(gc_type), pass_isolate(pass_isolate) {}
1593+
struct GCCallbackTuple {
1594+
GCCallbackTuple(v8::Isolate::GCCallbackWithData callback, GCType gc_type,
1595+
void* data)
1596+
: callback(callback), gc_type(gc_type), data(data) {}
15951597

1596-
bool operator==(const GCCallbackPair& other) const;
1597-
GCCallbackPair& operator=(const GCCallbackPair& other);
1598+
bool operator==(const GCCallbackTuple& other) const;
1599+
GCCallbackTuple& operator=(const GCCallbackTuple& other);
15981600

1599-
v8::Isolate::GCCallback callback;
1601+
v8::Isolate::GCCallbackWithData callback;
16001602
GCType gc_type;
1601-
bool pass_isolate;
1603+
void* data;
16021604
};
16031605

16041606
typedef String* (*ExternalStringTableUpdaterCallback)(Heap* heap,
@@ -2262,8 +2264,8 @@ class Heap {
22622264

22632265
Object* encountered_transition_arrays_;
22642266

2265-
std::vector<GCCallbackPair> gc_epilogue_callbacks_;
2266-
std::vector<GCCallbackPair> gc_prologue_callbacks_;
2267+
std::vector<GCCallbackTuple> gc_epilogue_callbacks_;
2268+
std::vector<GCCallbackTuple> gc_prologue_callbacks_;
22672269

22682270
GetExternallyAllocatedMemoryInBytesCallback external_memory_callback_;
22692271

‎deps/v8/test/cctest/test-api.cc‎

Lines changed: 59 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -19626,6 +19626,19 @@ void EpilogueCallbackSecond(v8::Isolate* isolate,
1962619626
++epilogue_call_count_second;
1962719627
}
1962819628

19629+
void PrologueCallbackNew(v8::Isolate* isolate, v8::GCType,
19630+
v8::GCCallbackFlags flags, void* data) {
19631+
CHECK_EQ(flags, v8::kNoGCCallbackFlags);
19632+
CHECK_EQ(gc_callbacks_isolate, isolate);
19633+
++*static_cast<int*>(data);
19634+
}
19635+
19636+
void EpilogueCallbackNew(v8::Isolate* isolate, v8::GCType,
19637+
v8::GCCallbackFlags flags, void* data) {
19638+
CHECK_EQ(flags, v8::kNoGCCallbackFlags);
19639+
CHECK_EQ(gc_callbacks_isolate, isolate);
19640+
++*static_cast<int*>(data);
19641+
}
1962919642

1963019643
void PrologueCallbackAlloc(v8::Isolate* isolate,
1963119644
v8::GCType,
@@ -19700,6 +19713,52 @@ TEST(GCCallbacksOld) {
1970019713
CHECK_EQ(2, epilogue_call_count_second);
1970119714
}
1970219715

19716+
TEST(GCCallbacksWithData) {
19717+
LocalContext context;
19718+
19719+
gc_callbacks_isolate = context->GetIsolate();
19720+
int prologue1 = 0;
19721+
int epilogue1 = 0;
19722+
int prologue2 = 0;
19723+
int epilogue2 = 0;
19724+
19725+
context->GetIsolate()->AddGCPrologueCallback(PrologueCallbackNew, &prologue1);
19726+
context->GetIsolate()->AddGCEpilogueCallback(EpilogueCallbackNew, &epilogue1);
19727+
CHECK_EQ(0, prologue1);
19728+
CHECK_EQ(0, epilogue1);
19729+
CHECK_EQ(0, prologue2);
19730+
CHECK_EQ(0, epilogue2);
19731+
CcTest::CollectAllGarbage();
19732+
CHECK_EQ(1, prologue1);
19733+
CHECK_EQ(1, epilogue1);
19734+
CHECK_EQ(0, prologue2);
19735+
CHECK_EQ(0, epilogue2);
19736+
context->GetIsolate()->AddGCPrologueCallback(PrologueCallbackNew, &prologue2);
19737+
context->GetIsolate()->AddGCEpilogueCallback(EpilogueCallbackNew, &epilogue2);
19738+
CcTest::CollectAllGarbage();
19739+
CHECK_EQ(2, prologue1);
19740+
CHECK_EQ(2, epilogue1);
19741+
CHECK_EQ(1, prologue2);
19742+
CHECK_EQ(1, epilogue2);
19743+
context->GetIsolate()->RemoveGCPrologueCallback(PrologueCallbackNew,
19744+
&prologue1);
19745+
context->GetIsolate()->RemoveGCEpilogueCallback(EpilogueCallbackNew,
19746+
&epilogue1);
19747+
CcTest::CollectAllGarbage();
19748+
CHECK_EQ(2, prologue1);
19749+
CHECK_EQ(2, epilogue1);
19750+
CHECK_EQ(2, prologue2);
19751+
CHECK_EQ(2, epilogue2);
19752+
context->GetIsolate()->RemoveGCPrologueCallback(PrologueCallbackNew,
19753+
&prologue2);
19754+
context->GetIsolate()->RemoveGCEpilogueCallback(EpilogueCallbackNew,
19755+
&epilogue2);
19756+
CcTest::CollectAllGarbage();
19757+
CHECK_EQ(2, prologue1);
19758+
CHECK_EQ(2, epilogue1);
19759+
CHECK_EQ(2, prologue2);
19760+
CHECK_EQ(2, epilogue2);
19761+
}
1970319762

1970419763
TEST(GCCallbacks) {
1970519764
LocalContext context;

0 commit comments

Comments
 (0)