fix: 2.1.2

Author: Zekfad

CHANGELOG.md

@@ -1,3 +1,10 @@
+## 2.1.2
+
+- Optimize cache entry removal performance.
+  > Previously `removeWhere` was used which caused iteration of whole cache set
+  > on every removal.
+  > Now additional `Expando` is used to map Weak references to their keys.
+
 ## 2.1.1
 
 - Fix web release target compilation.

README.md

@@ -3,7 +3,7 @@
 Weak cache is a `Map` implementation that uses `WeakReference`s for holding
 values and `Finalizer` to manage it's storage.
 
-You can use it to cache data for a small amount of time until next garbage
+You can use this to cache data for a small amount of time until next garbage
 collection cycle.
 
 > Note: Values cannot be numbers, strings, booleans, records, `null`,
@@ -18,13 +18,13 @@ collection cycle.
   > references, to prevent concurrent edit of storage, while iterating over it.
 * Optimized `containsValue` via internal managed `Expando`.
 * Implements full `Map<K, V>` interface.
-* WeakCache itself can be safely garbage collected and doesn't hold unto any
-  stored.
+* `WeakCache` itself can be safely garbage collected and doesn't hold unto any
+  stored data.
 
 ## Usage
 
-Create cache, add values, and they'll be removed when all other strong
-references to them are lost.
+Create cache, add values, and they'll be removed once there no more strong 
+references to them.
 
 ```dart
 // ID - Object cache

lib/src/cache_mutex.dart

@@ -24,8 +24,7 @@ class CacheMutex {
   /// Lock mutex.
   void lock() {
     debugPrint('CacheMutex.lock ($_locksCount + 1)');
-    _locksCount++;
-    if (_locksCount == 1)
+    if (++_locksCount == 1)
       onLock?.call();
   }
 
@@ -35,8 +34,7 @@ class CacheMutex {
     if (!isLocked)
       return;
 
-    _locksCount--;
-    if (_locksCount == 0)
+    if (--_locksCount == 0)
       onUnlock?.call();
   }
 }

lib/src/cache_state.dart

@@ -8,6 +8,7 @@ typedef CacheStateSnapshot<K, V extends Object> = ({
   Map<K, WeakReference<V>> cache,
   ListQueue<WeakReference<V>> removeQueue,
   Expando<bool> containsExpando,
+  Expando<(K,)> referenceKeys,
 });
 
 /// Aggregation of [CacheState] main properties with details
@@ -33,9 +34,11 @@ class CacheState<K, V extends Object> {
   final cache = <K, WeakReference<V>>{};
   /// Queue for delayed concurrent modifications.
   final removeQueue = ListQueue<WeakReference<V>>();
-  /// [Expando] used to optimize `containsValue` calls and bypass using
+  /// [Expando] used to optimize `containsValue` calls and bypass usage
   /// of iteration.
   final containsExpando = Expando<bool>();
+  /// [Expando] used to optimize `remove` calls and bypass usage of iteration.
+  final referenceKeys = Expando<(K,)>();
 
   /// [Finalizer] that manages [cache].
   static final cacheFinalizer = Finalizer<CacheStateSnapshotWithReference<Object?, Object>>(
@@ -54,28 +57,31 @@ class CacheState<K, V extends Object> {
     ) = argument;
     if (mutex?.isLocked != true)
       return removeCacheEntryStatic(argument);
-    removeQueue.addLast(reference);
+    return removeQueue.addLast(reference);
   }
 
   /// Removes cache entry from [cache] table and detach finalizer form it.
   static void removeCacheEntryStatic<K, V extends Object>(
     CacheStateSnapshotWithReference<K, V> argument,
   ) {
     final CacheStateSnapshotWithReference(
-      snapshot: CacheStateSnapshot(:cache, :containsExpando),
+      snapshot: CacheStateSnapshot(:cache, :containsExpando, :referenceKeys),
       :reference,
     ) = argument;
     cacheFinalizer.detach(reference);
+    if (referenceKeys[reference] case (final key,) when cache[key] == reference)
+      cache.remove(key);
+    referenceKeys[reference] = null;
     if (reference.target case final target?)
       containsExpando[target] = null;
-    cache.removeWhere((key, value) => value == reference);
   }
 
   /// Get aggregation of [CacheState] main properties.
   CacheStateSnapshot<K, V> get snapshot => (
     cache: cache,
     removeQueue: removeQueue,
     containsExpando: containsExpando,
+    referenceKeys: referenceKeys,
   );
 
   /// Create aggregation of [CacheState] properties required for value deletion.
@@ -99,6 +105,7 @@ class CacheState<K, V extends Object> {
     }
     containsExpando[value] = true;
     final reference = cache[key] = WeakReference<V>(value);
+    referenceKeys[reference] = (key,);
     cacheFinalizer.attach(
       value,
       makeSnapshotWithReference(reference),
@@ -113,6 +120,7 @@ class CacheState<K, V extends Object> {
       return null;
     }
     cacheFinalizer.detach(reference);
+    referenceKeys[reference] = null;
     if (reference.target case final target?)
       containsExpando[target] = null;
     return reference.target;

pubspec.yaml

@@ -2,7 +2,7 @@ name: weak_cache
 description: >
   Weak cache that uses weak references for holding values.
   Implements full Map interface including keys and values iteration.
-version: 2.1.1
+version: 2.1.2
 homepage: https://github.com/Zekfad/weak_cache
 repository: https://github.com/Zekfad/weak_cache
 issue_tracker: https://github.com/Zekfad/weak_cache/issues
@@ -18,5 +18,5 @@ dependencies:
   meta: ^1.9.1
 
 dev_dependencies:
-  test: ^1.25.2
-  zekfad_lints: ^2.0.0
+  test: ^1.25.7
+  zekfad_lints: ^2.1.0

test/weak_cache_test.dart

@@ -11,10 +11,7 @@ Future<void> parallelLoops(
   }
 ) => Future.wait([
   for (final function in functions)
-    Future.doWhile(() async {
-      await Future<void>.delayed(delay);
-      return function();
-    }),
+    Future.doWhile(() async => Future.delayed(delay, function)),
 ]);
 
 class _Int {
@@ -29,6 +26,109 @@ void main() {
   kDebug = true;
 
   group('Test Weak Cache', () {
+    test('updating key should not interfere removal', () async {
+      final events = <String>[];
+
+      final cache = WeakCache<int, Object>();
+
+      // Create some objects
+      Object? someObject = Object();
+      Object? someObject2 = Object();
+      Object? someObject3 = Object();
+
+      final _someObjectRef = WeakReference(someObject);
+      final _someObject2Ref = WeakReference(someObject2);
+      final _someObject3Ref = WeakReference(someObject3);
+
+      // Add them to cache
+      cache[0] = someObject;
+      cache[1] = someObject2;
+
+      final _someObjectRefDone = expectAsync0<bool>(() {
+        events.add('some object');
+        return false;
+      });
+
+      final _someObject2RefDone = expectAsync0<bool>(() {
+        events.add('some object 2');
+        return false;
+      });
+
+      final _someObject3RefDone = expectAsync0<bool>(() {
+        events.add('some object 3');
+        return false;
+      });
+
+      expect(identical(cache[0], someObject), isTrue);
+      expect(identical(cache[0], _someObjectRef.target), isTrue);
+      expect(identical(cache[1], someObject2), isTrue);
+      expect(identical(cache[1], _someObject2Ref.target), isTrue);
+
+      someObject = null;
+      someObject2 = null;
+
+      cache[1] = someObject3;
+
+      expect(identical(cache[1], someObject3), isTrue);
+      expect(identical(cache[1], _someObject3Ref.target), isTrue);
+
+      await parallelLoops([
+        () {
+          // ignore: unused_local_variable
+          final bigChunkOfData = '0' * 1024 * 1024 * 50; // about 50mb of data.
+          if (_someObjectRef.target != null)
+            return true;
+          return _someObjectRefDone();
+        },
+        () {
+          // ignore: unused_local_variable
+          final bigChunkOfData = '0' * 1024 * 1024 * 50; // about 50mb of data.
+          if (_someObject2Ref.target != null)
+            return true;
+          return _someObject2RefDone();
+        },
+      ]);
+
+      // 0 is null
+      expect(cache[0], isNull);
+      expect(_someObjectRef.target, isNull);
+      // 1 is obj3
+      expect(cache[1], isNotNull);
+      expect(identical(cache[1], _someObject3Ref.target), isTrue);
+      // obj2 is deleted
+      expect(_someObject2Ref.target, isNull);
+      expect(
+        events,
+        unorderedEquals([
+          'some object',
+          'some object 2',
+        ]),
+      );
+
+      someObject3 = null;
+
+      await parallelLoops([
+        () {
+          // ignore: unused_local_variable
+          final bigChunkOfData = '0' * 1024 * 1024 * 50; // about 50mb of data.
+          if (_someObject2Ref.target != null)
+            return true;
+          return _someObject3RefDone();
+        },
+      ]);
+
+      expect(cache[1], isNull);
+      expect(_someObject3Ref.target, isNull);
+      expect(
+        events,
+        unorderedEquals([
+          'some object',
+          'some object 2',
+          'some object 3',
+        ]),
+      );
+    });
+
     test('held objects should be garbage collected and removed from cache', () async {
       final events = <String>[];