Remove scheduler sampling profiler shared array buffer (#20840)

No one has been using this data so there's no reason to collect it. Event log has been maintained and tests have been updated.

packages/scheduler/src/Scheduler.js

@@ -32,7 +32,6 @@ import {
   IdlePriority,
 } from './SchedulerPriorities';
 import {
-  sharedProfilingBuffer,
   markTaskRun,
   markTaskYield,
   markTaskCompleted,
@@ -181,12 +180,16 @@ function workLoop(hasTimeRemaining, initialTime) {
       currentTask.callback = null;
       currentPriorityLevel = currentTask.priorityLevel;
       const didUserCallbackTimeout = currentTask.expirationTime <= currentTime;
-      markTaskRun(currentTask, currentTime);
+      if (enableProfiling) {
+        markTaskRun(currentTask, currentTime);
+      }
       const continuationCallback = callback(didUserCallbackTimeout);
       currentTime = getCurrentTime();
       if (typeof continuationCallback === 'function') {
         currentTask.callback = continuationCallback;
-        markTaskYield(currentTask, currentTime);
+        if (enableProfiling) {
+          markTaskYield(currentTask, currentTime);
+        }
       } else {
         if (enableProfiling) {
           markTaskCompleted(currentTask, currentTime);
@@ -420,6 +423,5 @@ export const unstable_Profiling = enableProfiling
   ? {
       startLoggingProfilingEvents,
       stopLoggingProfilingEvents,
-      sharedProfilingBuffer,
     }
   : null;

packages/scheduler/src/SchedulerFeatureFlags.js

@@ -8,4 +8,4 @@
 
 export const enableSchedulerDebugging = false;
 export const enableIsInputPending = false;
-export const enableProfiling = __PROFILE__;
+export const enableProfiling = __VARIANT__;

packages/scheduler/src/SchedulerProfiling.js

@@ -10,40 +10,9 @@
 import type {PriorityLevel} from './SchedulerPriorities';
 import {enableProfiling} from './SchedulerFeatureFlags';
 
-import {NoPriority} from './SchedulerPriorities';
-
 let runIdCounter: number = 0;
 let mainThreadIdCounter: number = 0;
 
-const profilingStateSize = 4;
-export const sharedProfilingBuffer = enableProfiling
-  ? // $FlowFixMe Flow doesn't know about SharedArrayBuffer
-    typeof SharedArrayBuffer === 'function'
-    ? new SharedArrayBuffer(profilingStateSize * Int32Array.BYTES_PER_ELEMENT)
-    : // $FlowFixMe Flow doesn't know about ArrayBuffer
-    typeof ArrayBuffer === 'function'
-    ? new ArrayBuffer(profilingStateSize * Int32Array.BYTES_PER_ELEMENT)
-    : null // Don't crash the init path on IE9
-  : null;
-
-const profilingState =
-  enableProfiling && sharedProfilingBuffer !== null
-    ? new Int32Array(sharedProfilingBuffer)
-    : []; // We can't read this but it helps save bytes for null checks
-
-const PRIORITY = 0;
-const CURRENT_TASK_ID = 1;
-const CURRENT_RUN_ID = 2;
-const QUEUE_SIZE = 3;
-
-if (enableProfiling) {
-  profilingState[PRIORITY] = NoPriority;
-  // This is maintained with a counter, because the size of the priority queue
-  // array might include canceled tasks.
-  profilingState[QUEUE_SIZE] = 0;
-  profilingState[CURRENT_TASK_ID] = 0;
-}
-
 // Bytes per element is 4
 const INITIAL_EVENT_LOG_SIZE = 131072;
 const MAX_EVENT_LOG_SIZE = 524288; // Equivalent to 2 megabytes
@@ -111,8 +80,6 @@ export function markTaskStart(
   ms: number,
 ) {
   if (enableProfiling) {
-    profilingState[QUEUE_SIZE]++;
-
     if (eventLog !== null) {
       // performance.now returns a float, representing milliseconds. When the
       // event is logged, it's coerced to an int. Convert to microseconds to
@@ -131,10 +98,6 @@ export function markTaskCompleted(
   ms: number,
 ) {
   if (enableProfiling) {
-    profilingState[PRIORITY] = NoPriority;
-    profilingState[CURRENT_TASK_ID] = 0;
-    profilingState[QUEUE_SIZE]--;
-
     if (eventLog !== null) {
       logEvent([TaskCompleteEvent, ms * 1000, task.id]);
     }
@@ -150,8 +113,6 @@ export function markTaskCanceled(
   ms: number,
 ) {
   if (enableProfiling) {
-    profilingState[QUEUE_SIZE]--;
-
     if (eventLog !== null) {
       logEvent([TaskCancelEvent, ms * 1000, task.id]);
     }
@@ -167,10 +128,6 @@ export function markTaskErrored(
   ms: number,
 ) {
   if (enableProfiling) {
-    profilingState[PRIORITY] = NoPriority;
-    profilingState[CURRENT_TASK_ID] = 0;
-    profilingState[QUEUE_SIZE]--;
-
     if (eventLog !== null) {
       logEvent([TaskErrorEvent, ms * 1000, task.id]);
     }
@@ -188,10 +145,6 @@ export function markTaskRun(
   if (enableProfiling) {
     runIdCounter++;
 
-    profilingState[PRIORITY] = task.priorityLevel;
-    profilingState[CURRENT_TASK_ID] = task.id;
-    profilingState[CURRENT_RUN_ID] = runIdCounter;
-
     if (eventLog !== null) {
       logEvent([TaskRunEvent, ms * 1000, task.id, runIdCounter]);
     }
@@ -200,10 +153,6 @@ export function markTaskRun(
 
 export function markTaskYield(task: {id: number, ...}, ms: number) {
   if (enableProfiling) {
-    profilingState[PRIORITY] = NoPriority;
-    profilingState[CURRENT_TASK_ID] = 0;
-    profilingState[CURRENT_RUN_ID] = 0;
-
     if (eventLog !== null) {
       logEvent([TaskYieldEvent, ms * 1000, task.id, runIdCounter]);
     }

packages/scheduler/src/__tests__/SchedulerProfiling-test.js

@@ -13,7 +13,6 @@
 'use strict';
 
 let Scheduler;
-let sharedProfilingArray;
 // let runWithPriority;
 let ImmediatePriority;
 let UserBlockingPriority;
@@ -44,7 +43,8 @@ function priorityLevelToString(priorityLevel) {
 }
 
 describe('Scheduler', () => {
-  if (!__PROFILE__) {
+  const {enableProfiling} = require('scheduler/src/SchedulerFeatureFlags');
+  if (!enableProfiling) {
     // The tests in this suite only apply when profiling is on
     it('profiling APIs are not available', () => {
       Scheduler = require('scheduler');
@@ -58,10 +58,6 @@ describe('Scheduler', () => {
     jest.mock('scheduler', () => require('scheduler/unstable_mock'));
     Scheduler = require('scheduler');
 
-    sharedProfilingArray = new Int32Array(
-      Scheduler.unstable_Profiling.sharedProfilingBuffer,
-    );
-
     // runWithPriority = Scheduler.unstable_runWithPriority;
     ImmediatePriority = Scheduler.unstable_ImmediatePriority;
     UserBlockingPriority = Scheduler.unstable_UserBlockingPriority;
@@ -75,20 +71,6 @@ describe('Scheduler', () => {
     // shouldYield = Scheduler.unstable_shouldYield;
   });
 
-  const PRIORITY = 0;
-  const CURRENT_TASK_ID = 1;
-  const CURRENT_RUN_ID = 2;
-  const QUEUE_SIZE = 3;
-
-  afterEach(() => {
-    if (sharedProfilingArray[QUEUE_SIZE] !== 0) {
-      throw Error(
-        'Test exited, but the shared profiling buffer indicates that a task ' +
-          'is still running',
-      );
-    }
-  });
-
   const TaskStartEvent = 1;
   const TaskCompleteEvent = 2;
   const TaskErrorEvent = 3;
@@ -271,23 +253,6 @@ describe('Scheduler', () => {
     return '\n' + result;
   }
 
-  function getProfilingInfo() {
-    const queueSize = sharedProfilingArray[QUEUE_SIZE];
-    if (queueSize === 0) {
-      return 'Empty Queue';
-    }
-    const priorityLevel = sharedProfilingArray[PRIORITY];
-    if (priorityLevel === 0) {
-      return 'Suspended, Queue Size: ' + queueSize;
-    }
-    return (
-      `Task: ${sharedProfilingArray[CURRENT_TASK_ID]}, ` +
-      `Run: ${sharedProfilingArray[CURRENT_RUN_ID]}, ` +
-      `Priority: ${priorityLevelToString(priorityLevel)}, ` +
-      `Queue Size: ${sharedProfilingArray[QUEUE_SIZE]}`
-    );
-  }
-
   it('creates a basic flamegraph', () => {
     Scheduler.unstable_Profiling.startLoggingProfilingEvents();
 
@@ -296,35 +261,27 @@ describe('Scheduler', () => {
       NormalPriority,
       () => {
         Scheduler.unstable_advanceTime(300);
-        Scheduler.unstable_yieldValue(getProfilingInfo());
+        Scheduler.unstable_yieldValue('Yield 1');
         scheduleCallback(
           UserBlockingPriority,
           () => {
-            Scheduler.unstable_yieldValue(getProfilingInfo());
+            Scheduler.unstable_yieldValue('Yield 2');
             Scheduler.unstable_advanceTime(300);
           },
           {label: 'Bar'},
         );
         Scheduler.unstable_advanceTime(100);
-        Scheduler.unstable_yieldValue('Yield');
+        Scheduler.unstable_yieldValue('Yield 3');
         return () => {
-          Scheduler.unstable_yieldValue(getProfilingInfo());
+          Scheduler.unstable_yieldValue('Yield 4');
           Scheduler.unstable_advanceTime(300);
         };
       },
       {label: 'Foo'},
     );
-    expect(Scheduler).toFlushAndYieldThrough([
-      'Task: 1, Run: 1, Priority: Normal, Queue Size: 1',
-      'Yield',
-    ]);
+    expect(Scheduler).toFlushAndYieldThrough(['Yield 1', 'Yield 3']);
     Scheduler.unstable_advanceTime(100);
-    expect(Scheduler).toFlushAndYield([
-      'Task: 2, Run: 2, Priority: User-blocking, Queue Size: 2',
-      'Task: 1, Run: 3, Priority: Normal, Queue Size: 1',
-    ]);
-
-    expect(getProfilingInfo()).toEqual('Empty Queue');
+    expect(Scheduler).toFlushAndYield(['Yield 2', 'Yield 4']);
 
     expect(stopProfilingAndPrintFlamegraph()).toEqual(
       `
@@ -339,19 +296,16 @@ Task 1 [Normal]              │  ████████░░░░░░░
     Scheduler.unstable_Profiling.startLoggingProfilingEvents();
 
     const task = scheduleCallback(NormalPriority, () => {
-      Scheduler.unstable_yieldValue(getProfilingInfo());
+      Scheduler.unstable_yieldValue('Yield 1');
       Scheduler.unstable_advanceTime(300);
-      Scheduler.unstable_yieldValue('Yield');
+      Scheduler.unstable_yieldValue('Yield 2');
       return () => {
         Scheduler.unstable_yieldValue('Continuation');
         Scheduler.unstable_advanceTime(200);
       };
     });
 
-    expect(Scheduler).toFlushAndYieldThrough([
-      'Task: 1, Run: 1, Priority: Normal, Queue Size: 1',
-      'Yield',
-    ]);
+    expect(Scheduler).toFlushAndYieldThrough(['Yield 1', 'Yield 2']);
     Scheduler.unstable_advanceTime(100);
 
     cancelCallback(task);
@@ -391,28 +345,25 @@ Task 1 [Normal]              │██████🡐 errored
     Scheduler.unstable_Profiling.startLoggingProfilingEvents();
 
     const task1 = scheduleCallback(NormalPriority, () => {
-      Scheduler.unstable_yieldValue(getProfilingInfo());
+      Scheduler.unstable_yieldValue('Yield 1');
       Scheduler.unstable_advanceTime(300);
-      Scheduler.unstable_yieldValue('Yield');
+      Scheduler.unstable_yieldValue('Yield 2');
       return () => {
         Scheduler.unstable_yieldValue('Continuation');
         Scheduler.unstable_advanceTime(200);
       };
     });
     const task2 = scheduleCallback(NormalPriority, () => {
-      Scheduler.unstable_yieldValue(getProfilingInfo());
+      Scheduler.unstable_yieldValue('Yield 3');
       Scheduler.unstable_advanceTime(300);
-      Scheduler.unstable_yieldValue('Yield');
+      Scheduler.unstable_yieldValue('Yield 4');
       return () => {
         Scheduler.unstable_yieldValue('Continuation');
         Scheduler.unstable_advanceTime(200);
       };
     });
 
-    expect(Scheduler).toFlushAndYieldThrough([
-      'Task: 1, Run: 1, Priority: Normal, Queue Size: 2',
-      'Yield',
-    ]);
+    expect(Scheduler).toFlushAndYieldThrough(['Yield 1', 'Yield 2']);
     Scheduler.unstable_advanceTime(100);
 
     cancelCallback(task1);