Perception caching updates (#2649)

* Small updates to perception caching.

* wip

* debug

Author: mbrandonw

Sources/Perception/Internal/Memoization.swift

@@ -1,68 +1,45 @@
-import Foundation
-import OrderedCollections
+#if DEBUG
+  import Foundation
+  import OrderedCollections
 
-final class MemoizedCache<Key: Hashable, Value>: @unchecked Sendable {
-  private var dictionary = OrderedDictionary<Key, Value>()
-  private var lock = NSLock()
-  private let maxCapacity: Int
-  
-  // TODO possibly remove these stats later
-  private var totalEvictions = 0
-  private var totalCalls = 0
-  private var totalHits = 0
-  
-  init(maxCapacity: Int = 500) {
-    self.maxCapacity = maxCapacity
-  }
-  
-  func printStats() {
-    lock.sync {
-      let hitRate = (Float(totalHits) / Float(totalCalls)) * 100
-      let evictionRate = (Float(totalEvictions) / Float(totalCalls)) * 100
-      print("size = \(dictionary.count), totalCalls = \(totalCalls), hitRate = \(hitRate)%, evictionRate = \(evictionRate)%")
+  func memoize<Result>(
+    maxCapacity: Int = 500,
+    _ apply: @escaping () -> Result
+  ) -> () -> Result {
+    let cache = Cache<[NSNumber], Result>(maxCapacity: maxCapacity)
+    return {
+      let callStack = Thread.callStackReturnAddresses
+      guard let memoizedResult = cache[callStack]
+      else {
+        let result = apply()
+        defer { cache[callStack] = result }
+        return result
+      }
+      return memoizedResult
     }
   }
-  
-  subscript(key: Key) -> Value? {
-    get {
-      lock.sync {
-        totalCalls += 1
-        if let value = dictionary[key] {
-          totalHits += 1
-          return value
+
+  private final class Cache<Key: Hashable, Value>: @unchecked Sendable {
+    var dictionary = OrderedDictionary<Key, Value>()
+    var lock = NSLock()
+    let maxCapacity: Int
+    init(maxCapacity: Int = 500) {
+      self.maxCapacity = maxCapacity
+    }
+    subscript(key: Key) -> Value? {
+      get {
+        self.lock.sync {
+          self.dictionary[key]
         }
-        return nil
       }
-    }
-    set {
-      lock.sync {
-        dictionary[key] = newValue
-        if dictionary.count > maxCapacity {
-          // evict first (oldest) element
-          dictionary.removeFirst()
-          totalEvictions += 1
+      set {
+        self.lock.sync {
+          self.dictionary[key] = newValue
+          if self.dictionary.count > self.maxCapacity {
+            self.dictionary.removeFirst()
+          }
         }
       }
     }
   }
-  
-}
-
-func memoize<Input: Hashable, Result>(
-  maxCapacity: Int = 500,
-  _ apply: @escaping (Input) -> Result
-) -> (Input) -> Result {
-  let cache = MemoizedCache<Input, Result>(maxCapacity: maxCapacity)
-  
-  return { input in
-//    defer { cache.printStats() }
-    if let memoizedResult = cache[input] {
-      return memoizedResult
-    }
-    
-    let result = apply(input)
-    cache[input] = result
-    return result
-  }
-  
-}
+#endif

Sources/Perception/PerceptionRegistrar.swift

@@ -191,10 +191,11 @@ extension PerceptionRegistrar: Hashable {
 
 #if DEBUG
   private func perceptionCheck() {
-    if #unavailable(iOS 17, macOS 14, tvOS 17, watchOS 10),
+    if
+      #unavailable(iOS 17, macOS 14, tvOS 17, watchOS 10),
       !PerceptionLocals.isInPerceptionTracking,
       !PerceptionLocals.isInWithoutPerceptionChecking,
-      isInSwiftUIBody
+      isInSwiftUIBody()
     {
       runtimeWarn(
         """
@@ -205,15 +206,7 @@ extension PerceptionRegistrar: Hashable {
     }
   }
 
-  var isInSwiftUIBody: Bool {
-    determineIfInSwiftUIBodyMemoized(Thread.callStackReturnAddresses)
-  }
-
-  let determineIfInSwiftUIBodyMemoized = memoize({ (_ : [NSNumber]) in
-      determineIfInSwiftUIBody
-  })
-
-  var determineIfInSwiftUIBody: Bool {
+  private let isInSwiftUIBody: () -> Bool = memoize {
     for callStackSymbol in Thread.callStackSymbols {
       let mangledSymbol = callStackSymbol.utf8
         .drop(while: { $0 != .init(ascii: "$") })