src: implement countObjectsWithPrototype

This implements an internal utility for counting objects in the heap with a specified prototype. In addition this adds a checkIfCollectableByCounting() test helper. PR-URL: #50572 Refs: v8/v8@0fd478b Reviewed-By: Geoffrey Booth <[email protected]> Reviewed-By: Stephen Belanger <[email protected]>

Author: joyeecheung

src/heap_utils.cc

@@ -474,6 +474,39 @@ void TriggerHeapSnapshot(const FunctionCallbackInfo<Value>& args){
 return args.GetReturnValue().Set(filename_v);
 }
 
+classPrototypeChainHas : publicv8::QueryObjectPredicate{
+public:
+PrototypeChainHas(Local<Context> context, Local<Object> search)
+ : context_(context), search_(search){}
+
+// What we can do in the filter can be quite limited, but looking up
+// the prototype chain is something that the inspector console API
+// queryObject() does so it is supported.
+boolFilter(Local<Object> object) override{
+for (Local<Value> proto = object->GetPrototype(); proto->IsObject();
+ proto = proto.As<Object>()->GetPrototype()){
+if (search_ == proto) returntrue;
+ }
+returnfalse;
+ }
+
+private:
+ Local<Context> context_;
+ Local<Object> search_;
+};
+
+voidCountObjectsWithPrototype(const FunctionCallbackInfo<Value>& args){
+CHECK_EQ(args.Length(), 1);
+CHECK(args[0]->IsObject());
+ Local<Object> proto = args[0].As<Object>();
+ Isolate* isolate = args.GetIsolate();
+ Local<Context> context = isolate->GetCurrentContext();
+ PrototypeChainHas prototype_chain_has(context, proto);
+ std::vector<Global<Object>> out;
+ isolate->GetHeapProfiler()->QueryObjects(context, &prototype_chain_has, &out);
+ args.GetReturnValue().Set(static_cast<uint32_t>(out.size()));
+}
+
 voidInitialize(Local<Object> target,
  Local<Value> unused,
  Local<Context> context,
@@ -482,12 +515,15 @@ void Initialize(Local<Object> target,
 SetMethod(context, target, "triggerHeapSnapshot", TriggerHeapSnapshot);
 SetMethod(
  context, target, "createHeapSnapshotStream", CreateHeapSnapshotStream);
+SetMethod(
+ context, target, "countObjectsWithPrototype", CountObjectsWithPrototype);
 }
 
 voidRegisterExternalReferences(ExternalReferenceRegistry* registry){
  registry->Register(BuildEmbedderGraph);
  registry->Register(TriggerHeapSnapshot);
  registry->Register(CreateHeapSnapshotStream);
+ registry->Register(CountObjectsWithPrototype);
 }
 
 } // namespace heap

test/common/gc.js

@@ -75,7 +75,54 @@ async function runAndBreathe(fn, repeat, waitTime = 20){
 }
 }
 
+/**
+ * This requires --expose-internals.
+ * This function can be used to check if an object factory leaks or not by
+ * iterating over the heap and count objects with the specified class
+ * (which is checked by looking up the prototype chain).
+ * @param{(i: number) => number} fn The factory receiving iteration count
+ * and returning number of objects created. The return value should be
+ * precise otherwise false negatives can be produced.
+ * @param{Function} klass The class whose object is used to count the objects
+ * @param{number} count Number of iterations that this check should be done
+ * @param{number} waitTime Optional breathing time for GC.
+ */
+asyncfunctioncheckIfCollectableByCounting(fn,klass,count,waitTime=20){
+const{ internalBinding }=require('internal/test/binding');
+const{ countObjectsWithPrototype }=internalBinding('heap_utils');
+const{ prototype, name }=klass;
+constinitialCount=countObjectsWithPrototype(prototype);
+console.log(`Initial count of ${name}: ${initialCount}`);
+lettotalCreated=0;
+for(leti=0;i<count;++i){
+constcreated=awaitfn(i);
+totalCreated+=created;
+console.log(`#${i}: created ${created}${name}, total ${totalCreated}`);
+awaitwait(waitTime);// give GC some breathing room.
+constcurrentCount=countObjectsWithPrototype(prototype);
+constcollected=totalCreated-(currentCount-initialCount);
+console.log(`#${i}: counted ${currentCount}${name}, collected ${collected}`);
+if(collected>0){
+console.log(`Detected ${collected} collected ${name}, finish early`);
+return;
+}
+}
+
+awaitwait(waitTime);// give GC some breathing room.
+constcurrentCount=countObjectsWithPrototype(prototype);
+constcollected=totalCreated-(currentCount-initialCount);
+console.log(`Last count: counted ${currentCount}${name}, collected ${collected}`);
+// Some objects with the prototype can be collected.
+if(collected>0){
+console.log(`Detected ${collected} collected ${name}`);
+return;
+}
+
+thrownewError(`${name} cannot be collected`);
+}
+
 module.exports={
  checkIfCollectable,
  runAndBreathe,
+ checkIfCollectableByCounting,
 };