perf: add per-run dep cursors without mutating tails

Author: brnrdog

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

@@ -7,6 +7,10 @@ let currentObserver: ref<option<Core.observer>> = ref(None)
 // Current dependency tracking version (shared across nested compute/effect runs)
 let currentTrackingVersion: ref<int> = ref(0)
 
+// Per-run dependency cursors (separate from true tail pointers).
+let currentComputedDepCursor: ref<option<Core.link>> = ref(None)
+let currentObserverDepCursor: ref<option<Core.link>> = ref(None)
+
 // Pending effects to execute
 let pendingEffects: array<Core.observer> = []
 // Pending computeds to recompute (subs that are dirty)
@@ -44,20 +48,22 @@ let trackDepFromComputed = (computedSubs: Core.subs, sourceSubs: Core.subs): uni
     newLink.lastTrackedVersion = currentTrackingVersion.contents
     Core.linkToSubsDeps(computedSubs, newLink)
     Core.linkToSubs(sourceSubs, newLink)
+    currentComputedDepCursor := Some(newLink)
   } else {
     let currentVersion = currentTrackingVersion.contents
-    // Fast path: reuse tail or tail.next to avoid scanning in common cases
+    // Fast path: reuse run cursor or cursor.next to avoid scanning in common cases.
     let fastPathFound = ref(false)
-    switch computedSubs.lastDep {
-    | Some(lastDep) =>
-      if lastDep.subs === sourceSubs {
-        lastDep.lastTrackedVersion = currentVersion
+    switch currentComputedDepCursor.contents {
+    | Some(cursor) =>
+      if cursor.subs === sourceSubs {
+        cursor.lastTrackedVersion = currentVersion
         fastPathFound.contents = true
       } else {
-        switch lastDep.nextDep {
+        switch cursor.nextDep {
         | Some(nextDep) =>
           if nextDep.subs === sourceSubs {
             nextDep.lastTrackedVersion = currentVersion
+            currentComputedDepCursor := Some(nextDep)
             fastPathFound.contents = true
           }
         | None => ()
@@ -71,6 +77,7 @@ let trackDepFromComputed = (computedSubs: Core.subs, sourceSubs: Core.subs): uni
       | Some(lastSubLink) =>
         if lastSubLink.lastTrackedVersion === currentVersion && lastSubLink.observer === computedObserver {
           lastSubLink.lastTrackedVersion = currentVersion
+          currentComputedDepCursor := Some(lastSubLink)
           fastPathFound.contents = true
         }
       | None => ()
@@ -80,12 +87,14 @@ let trackDepFromComputed = (computedSubs: Core.subs, sourceSubs: Core.subs): uni
     if !fastPathFound.contents {
       // Fall back to full scan
       let found = ref(false)
+      let foundLink: ref<option<Core.link>> = ref(None)
       let link = ref(computedSubs.firstDep)
       while link.contents !== None && !found.contents {
         switch link.contents {
         | Some(l) =>
           if l.subs === sourceSubs {
             l.lastTrackedVersion = currentVersion
+            foundLink := Some(l)
             found := true
           } else {
             link := l.nextDep
@@ -100,6 +109,9 @@ let trackDepFromComputed = (computedSubs: Core.subs, sourceSubs: Core.subs): uni
         newLink.lastTrackedVersion = currentVersion
         Core.linkToSubsDeps(computedSubs, newLink)
         Core.linkToSubs(sourceSubs, newLink)
+        currentComputedDepCursor := Some(newLink)
+      } else {
+        currentComputedDepCursor := foundLink.contents
       }
     }
   }
@@ -113,20 +125,22 @@ let trackDepFromEffect = (observer: Core.observer, sourceSubs: Core.subs): unit
     newLink.lastTrackedVersion = currentTrackingVersion.contents
     Core.linkToDeps(observer, newLink)
     Core.linkToSubs(sourceSubs, newLink)
+    currentObserverDepCursor := Some(newLink)
   } else {
     let currentVersion = currentTrackingVersion.contents
-    // Fast path: reuse tail or tail.next to avoid scanning in common cases
+    // Fast path: reuse run cursor or cursor.next to avoid scanning in common cases.
     let fastPathFound = ref(false)
-    switch observer.lastDep {
-    | Some(lastDep) =>
-      if lastDep.subs === sourceSubs {
-        lastDep.lastTrackedVersion = currentVersion
+    switch currentObserverDepCursor.contents {
+    | Some(cursor) =>
+      if cursor.subs === sourceSubs {
+        cursor.lastTrackedVersion = currentVersion
         fastPathFound.contents = true
       } else {
-        switch lastDep.nextDep {
+        switch cursor.nextDep {
         | Some(nextDep) =>
           if nextDep.subs === sourceSubs {
             nextDep.lastTrackedVersion = currentVersion
+            currentObserverDepCursor := Some(nextDep)
             fastPathFound.contents = true
           }
         | None => ()
@@ -140,6 +154,7 @@ let trackDepFromEffect = (observer: Core.observer, sourceSubs: Core.subs): unit
       | Some(lastSubLink) =>
         if lastSubLink.lastTrackedVersion === currentVersion && lastSubLink.observer === observer {
           lastSubLink.lastTrackedVersion = currentVersion
+          currentObserverDepCursor := Some(lastSubLink)
           fastPathFound.contents = true
         }
       | None => ()
@@ -148,12 +163,14 @@ let trackDepFromEffect = (observer: Core.observer, sourceSubs: Core.subs): unit
 
     if !fastPathFound.contents {
       let found = ref(false)
+      let foundLink: ref<option<Core.link>> = ref(None)
       let link = ref(observer.firstDep)
       while link.contents !== None && !found.contents {
         switch link.contents {
         | Some(l) =>
           if l.subs === sourceSubs {
             l.lastTrackedVersion = currentVersion
+            foundLink := Some(l)
             found := true
           } else {
             link := l.nextDep
@@ -168,6 +185,9 @@ let trackDepFromEffect = (observer: Core.observer, sourceSubs: Core.subs): unit
         newLink.lastTrackedVersion = currentVersion
         Core.linkToDeps(observer, newLink)
         Core.linkToSubs(sourceSubs, newLink)
+        currentObserverDepCursor := Some(newLink)
+      } else {
+        currentObserverDepCursor := foundLink.contents
       }
     }
   }
@@ -248,7 +268,9 @@ let runComputedCycle = (subs: Core.subs, ~clearPending: bool): unit => {
   }
 
   let prev = currentComputedSubs.contents
+  let prevCursor = currentComputedDepCursor.contents
   currentComputedSubs := Some(subs)
+  currentComputedDepCursor := subs.firstDep
 
   try {
     switch subs.compute {
@@ -301,10 +323,12 @@ let runComputedCycle = (subs: Core.subs, ~clearPending: bool): unit => {
     }
 
     currentComputedSubs := prev
+    currentComputedDepCursor := prevCursor
     currentTrackingVersion.contents = previousTrackingVersion
   } catch {
   | exn =>
     currentComputedSubs := prev
+    currentComputedDepCursor := prevCursor
     currentTrackingVersion.contents = previousTrackingVersion
     throw(exn)
   }
@@ -333,7 +357,9 @@ let retrackEffect = (observer: Core.observer): unit => {
   Core.clearPending(observer)
 
   let prev = currentObserver.contents
+  let prevCursor = currentObserverDepCursor.contents
   currentObserver := Some(observer)
+  currentObserverDepCursor := observer.firstDep
 
   try {
     observer.run()
@@ -356,10 +382,12 @@ let retrackEffect = (observer: Core.observer): unit => {
 
     Core.clearDirty(observer)
     currentObserver := prev
+    currentObserverDepCursor := prevCursor
     currentTrackingVersion.contents = previousTrackingVersion
   } catch {
   | exn =>
     currentObserver := prev
+    currentObserverDepCursor := prevCursor
     currentTrackingVersion.contents = previousTrackingVersion
     throw(exn)
   }
@@ -508,17 +536,25 @@ let batch = fn => {
 let untrack = (fn: unit => 'a): 'a => {
   let prevComputed = currentComputedSubs.contents
   let prevObserver = currentObserver.contents
+  let prevComputedCursor = currentComputedDepCursor.contents
+  let prevObserverCursor = currentObserverDepCursor.contents
   currentComputedSubs := None
   currentObserver := None
+  currentComputedDepCursor := None
+  currentObserverDepCursor := None
   try {
     let result = fn()
     currentComputedSubs := prevComputed
     currentObserver := prevObserver
+    currentComputedDepCursor := prevComputedCursor
+    currentObserverDepCursor := prevObserverCursor
     result
   } catch {
   | exn =>
     currentComputedSubs := prevComputed
     currentObserver := prevObserver
+    currentComputedDepCursor := prevComputedCursor
+    currentObserverDepCursor := prevObserverCursor
     throw(exn)
   }
 }