perf_hooks: use arrays to store EntryBuffers

Also order entries by startTime when calling getEntriesByType. Fix: #42004Fix: #42024 PR-URL: #42032Fixes: #42004Fixes: #42024 Reviewed-By: Benjamin Gruenbaum <[email protected]> Reviewed-By: Antoine du Hamel <[email protected]>

Author: meixg

lib/internal/perf/observe.js

@@ -4,12 +4,12 @@ const{
  ArrayFrom,
  ArrayIsArray,
  ArrayPrototypeFilter,
- ArrayPrototypeFlatMap,
  ArrayPrototypeIncludes,
  ArrayPrototypePush,
  ArrayPrototypePushApply,
  ArrayPrototypeSlice,
  ArrayPrototypeSort,
+ ArrayPrototypeConcat,
  Error,
  ObjectDefineProperties,
  ObjectFreeze,
@@ -34,7 +34,6 @@ const{
 const{
  InternalPerformanceEntry,
  isPerformanceEntry,
- kBufferNext,
 }=require('internal/perf/performance_entry');
 
 const{
@@ -89,8 +88,8 @@ const kSupportedEntryTypes = ObjectFreeze([
 ]);
 
 // Performance timeline entry Buffers
-constmarkEntryBuffer=createBuffer();
-constmeasureEntryBuffer=createBuffer();
+letmarkEntryBuffer=[];
+letmeasureEntryBuffer=[];
 constkMaxPerformanceEntryBuffers=1e6;
 constkClearPerformanceEntryBuffers=ObjectFreeze({
 'mark': 'performance.clearMarks',
@@ -154,9 +153,7 @@ function maybeIncrementObserverCount(type){
 classPerformanceObserverEntryList{
 constructor(entries){
 this[kBuffer]=ArrayPrototypeSort(entries,(first,second)=>{
-if(first.startTime<second.startTime)return-1;
-if(first.startTime>second.startTime)return1;
-return0;
+returnfirst.startTime-second.startTime;
 });
 }
 
@@ -344,15 +341,8 @@ function enqueue(entry){
 return;
 }
 
-constcount=buffer.count+1;
-buffer.count=count;
-if(count===1){
-buffer.head=entry;
-buffer.tail=entry;
-return;
-}
-buffer.tail[kBufferNext]=entry;
-buffer.tail=entry;
+ArrayPrototypePush(buffer,entry);
+constcount=buffer.length;
 
 if(count>kMaxPerformanceEntryBuffers&&
 !kWarnedEntryTypes.has(entryType)){
@@ -372,63 +362,40 @@ function enqueue(entry){
 }
 
 functionclearEntriesFromBuffer(type,name){
-letbuffer;
-if(type==='mark'){
-buffer=markEntryBuffer;
-}elseif(type==='measure'){
-buffer=measureEntryBuffer;
-}else{
-return;
-}
-if(name===undefined){
-resetBuffer(buffer);
+if(type!=='mark'&&type!=='measure'){
 return;
 }
 
-lethead=null;
-lettail=null;
-letcount=0;
-for(letentry=buffer.head;entry!==null;entry=entry[kBufferNext]){
-if(entry.name!==name){
-head=head??entry;
-tail=entry;
-continue;
-}
-if(tail===null){
-continue;
-}
-tail[kBufferNext]=entry[kBufferNext];
-count++;
+if(type==='mark'){
+markEntryBuffer=name===undefined ?
+[] : ArrayPrototypeFilter(markEntryBuffer,(entry)=>entry.name!==name);
+}else{
+measureEntryBuffer=name===undefined ?
+[] : ArrayPrototypeFilter(measureEntryBuffer,(entry)=>entry.name!==name);
 }
-buffer.head=head;
-buffer.tail=tail;
-buffer.count=count;
 }
 
 functionfilterBufferMapByNameAndType(name,type){
 letbufferList;
 if(type==='mark'){
-bufferList=[markEntryBuffer];
+bufferList=markEntryBuffer;
 }elseif(type==='measure'){
-bufferList=[measureEntryBuffer];
+bufferList=measureEntryBuffer;
 }elseif(type!==undefined){
 // Unrecognized type;
 return[];
 }else{
-bufferList=[markEntryBuffer,measureEntryBuffer];
+bufferList=ArrayPrototypeConcat(markEntryBuffer,measureEntryBuffer);
 }
-returnArrayPrototypeFlatMap(bufferList,
-(buffer)=>filterBufferByName(buffer,name));
-}
-
-functionfilterBufferByName(buffer,name){
-constarr=[];
-for(letentry=buffer.head;entry!==null;entry=entry[kBufferNext]){
-if(name===undefined||entry.name===name){
-ArrayPrototypePush(arr,entry);
-}
+if(name!==undefined){
+bufferList=ArrayPrototypeFilter(bufferList,(buffer)=>buffer.name===name);
+}elseif(type!==undefined){
+bufferList=ArrayPrototypeSlice(bufferList);
 }
-returnarr;
+
+returnArrayPrototypeSort(bufferList,(first,second)=>{
+returnfirst.startTime-second.startTime;
+});
 }
 
 functionobserverCallback(name,type,startTime,duration,details){
@@ -476,20 +443,6 @@ function hasObserver(type){
 returnobserverCounts[observerType]>0;
 }
 
-functioncreateBuffer(){
-return{
-head: null,
-tail: null,
-count: 0,
-};
-}
-
-functionresetBuffer(buffer){
-buffer.head=null;
-buffer.tail=null;
-buffer.count=0;
-}
-
 module.exports={
  PerformanceObserver,
  PerformanceObserverEntryList,

lib/internal/perf/performance_entry.js

@@ -22,7 +22,6 @@ const kType = Symbol('kType');
 constkStart=Symbol('kStart');
 constkDuration=Symbol('kDuration');
 constkDetail=Symbol('kDetail');
-constkBufferNext=Symbol('kBufferNext');
 
 functionisPerformanceEntry(obj){
 returnobj?.[kName]!==undefined;
@@ -72,7 +71,6 @@ class InternalPerformanceEntry{
 this[kStart]=start;
 this[kDuration]=duration;
 this[kDetail]=detail;
-this[kBufferNext]=null;
 }
 }
 
@@ -85,5 +83,4 @@ module.exports ={
  InternalPerformanceEntry,
  PerformanceEntry,
  isPerformanceEntry,
- kBufferNext,
 };

test/parallel/test-performance-timeline.mjs

@@ -0,0 +1,35 @@
+// This file may needs to be updated to wpt:
+// https://github.com/web-platform-tests/wpt
+
+import'../common/index.mjs';
+importassertfrom'assert';
+
+import{performance}from'perf_hooks';
+import{setTimeout}from'timers/promises';
+
+// Order by startTime
+performance.mark('one');
+awaitsetTimeout(50);
+performance.mark('two');
+awaitsetTimeout(50);
+performance.mark('three');
+awaitsetTimeout(50);
+performance.measure('three','three');
+awaitsetTimeout(50);
+performance.measure('two','two');
+awaitsetTimeout(50);
+performance.measure('one','one');
+constentries=performance.getEntriesByType('measure');
+assert.deepStrictEqual(entries.map((x)=>x.name),['one','two','three']);
+constallEntries=performance.getEntries();
+assert.deepStrictEqual(allEntries.map((x)=>x.name),['one','one','two','two','three','three']);
+
+performance.mark('a');
+awaitsetTimeout(50);
+performance.measure('a','a');
+awaitsetTimeout(50);
+performance.mark('a');
+awaitsetTimeout(50);
+performance.measure('a','one');
+constentriesByName=performance.getEntriesByName('a');
+assert.deepStrictEqual(entriesByName.map((x)=>x.entryType),['measure','mark','measure','mark']);