perf: guard scheduler queue sorts by level order

Author: brnrdog

packages/rescript-signals/src/signals/Scheduler.res

@@ -225,6 +225,58 @@ let compareSubsByLevel = (a: Core.subs, b: Core.subs): float => {
   Int.toFloat(a.level - b.level)
 }
 
+let needsEffectSort = (effects: array<Core.observer>, ~length: int): bool => {
+  let i = ref(1)
+  let previousLevel = ref(0)
+  let unsorted = ref(false)
+
+  switch effects->Array.get(0) {
+  | Some(effect) => previousLevel := effect.level
+  | None => ()
+  }
+
+  while i.contents < length && !unsorted.contents {
+    switch effects->Array.get(i.contents) {
+    | Some(effect) =>
+      if previousLevel.contents > effect.level {
+        unsorted := true
+      } else {
+        previousLevel := effect.level
+      }
+    | None => ()
+    }
+    i := i.contents + 1
+  }
+
+  unsorted.contents
+}
+
+let needsSubsSort = (subsList: array<Core.subs>, ~length: int): bool => {
+  let i = ref(1)
+  let previousLevel = ref(0)
+  let unsorted = ref(false)
+
+  switch subsList->Array.get(0) {
+  | Some(subs) => previousLevel := subs.level
+  | None => ()
+  }
+
+  while i.contents < length && !unsorted.contents {
+    switch subsList->Array.get(i.contents) {
+    | Some(subs) =>
+      if previousLevel.contents > subs.level {
+        unsorted := true
+      } else {
+        previousLevel := subs.level
+      }
+    | None => ()
+    }
+    i := i.contents + 1
+  }
+
+  unsorted.contents
+}
+
 // Compute level for a computed (based on its dependencies)
 let computeSubsLevel = (s: Core.subs): int => {
   let maxLevel = ref(0)
@@ -418,7 +470,7 @@ let flush = (): unit => {
       // Process computeds first (they might trigger more effects)
       if pendingComputedSubs->Array.length > 0 {
         let computedsLength = pendingComputedSubs->Array.length
-        if computedsLength > 1 {
+        if computedsLength > 1 && needsSubsSort(pendingComputedSubs, ~length=computedsLength) {
           // Sort by level
           pendingComputedSubs->Array.sort(compareSubsByLevel)->ignore
         }
@@ -436,7 +488,7 @@ let flush = (): unit => {
       // Then process effects
       if pendingEffects->Array.length > 0 {
         let effectsLength = pendingEffects->Array.length
-        if effectsLength > 1 {
+        if effectsLength > 1 && needsEffectSort(pendingEffects, ~length=effectsLength) {
           pendingEffects->Array.sort(compareEffectsByLevel)->ignore
         }
         let i = ref(0)