private void AssertOrphanWithCount(CountingMemoryCache <string, int> .Entry entry, int count) { Assert.AreNotSame(entry, _cache._cachedEntries.Get(entry.Key), "entry found in the exclusives"); Assert.AreNotSame(entry, _cache._exclusiveEntries.Get(entry.Key), "entry found in the cache"); Assert.IsTrue(entry.Orphan, "entry is not an orphan"); Assert.AreEqual(count, entry.ClientCount, "client count mismatch"); }
public void TestCachingSameKeyTwice() { CloseableReference <int> originalRef1 = NewReference(110); CloseableReference <int> cachedRef1 = _cache.Cache(KEY, originalRef1); CloseableReference <int> cachedRef2a = _cache.Get(KEY); CloseableReference <int> cachedRef2b = cachedRef2a.Clone(); CloseableReference <int> cachedRef3 = _cache.Get(KEY); CountingMemoryCache <string, int> .Entry entry1 = _cache._cachedEntries.Get(KEY); CloseableReference <int> cachedRef2 = _cache.Cache(KEY, NewReference(120)); CountingMemoryCache <string, int> .Entry entry2 = _cache._cachedEntries.Get(KEY); Assert.AreNotSame(entry1, entry2); AssertOrphanWithCount(entry1, 3); AssertSharedWithCount(KEY, 120, 1); // Release the orphaned reference only when all clients are gone originalRef1.Dispose(); cachedRef2b.Dispose(); AssertOrphanWithCount(entry1, 3); cachedRef2a.Dispose(); AssertOrphanWithCount(entry1, 2); cachedRef1.Dispose(); AssertOrphanWithCount(entry1, 1); Assert.AreEqual(0, _releaseCallCount); cachedRef3.Dispose(); AssertOrphanWithCount(entry1, 0); Assert.AreEqual(1, _releaseCallCount); }
private void AssertExclusivelyOwned(string key, int value) { Assert.IsTrue(_cache._cachedEntries.Contains(key), "key not found in the cache"); Assert.IsTrue(_cache._exclusiveEntries.Contains(key), "key not found in the exclusives"); CountingMemoryCache <string, int> .Entry entry = _cache._cachedEntries.Get(key); Assert.IsNotNull(entry, "entry not found in the cache"); Assert.AreEqual(key, entry.Key, "key mismatch"); Assert.AreEqual(value, entry.ValueRef.Get(), "value mismatch"); Assert.AreEqual(0, entry.ClientCount, "client count greater than zero"); Assert.IsFalse(entry.Orphan, "entry is an orphan"); }
/// <summary> /// Gets the encoded counting memory cache. /// </summary> public CountingMemoryCache <ICacheKey, IPooledByteBuffer> GetEncodedCountingMemoryCache() { if (_encodedCountingMemoryCache == null) { _encodedCountingMemoryCache = EncodedCountingMemoryCacheFactory.Get( _config.EncodedMemoryCacheParamsSupplier, _config.MemoryTrimmableRegistry, GetPlatformBitmapFactory()); } return(_encodedCountingMemoryCache); }
/// <summary> /// Gets the bitmap counting memory cache. /// </summary> public CountingMemoryCache <ICacheKey, CloseableImage> GetBitmapCountingMemoryCache() { if (_bitmapCountingMemoryCache == null) { _bitmapCountingMemoryCache = BitmapCountingMemoryCacheFactory.Get( _config.BitmapMemoryCacheParamsSupplier, _config.MemoryTrimmableRegistry, GetPlatformBitmapFactory(), _config.Experiments.IsExternalCreatedBitmapLogEnabled); } return(_bitmapCountingMemoryCache); }
public void Initialize() { _releaseCallCount = 0; _releaseValues = new List <int>(); _releaser = new ResourceReleaserImpl <int>( v => { ++_releaseCallCount; _releaseValues.Add(v); }); _onExclusivityChangedCallCount = 0; _isExclusive = null; _entryStateObserver = new EntryStateObserverImpl <string>( (v, b) => { ++_onExclusivityChangedCallCount; _isExclusive = b; }); _cacheTrimStrategy = new CacheTrimStrategyImpl(v => _trimRatio); _valueDescriptor = new ValueDescriptorImpl <int>(v => v); _params = new MemoryCacheParams( CACHE_MAX_SIZE, CACHE_MAX_COUNT, CACHE_EVICTION_QUEUE_MAX_SIZE, CACHE_EVICTION_QUEUE_MAX_COUNT, CACHE_ENTRY_MAX_SIZE); _paramsSupplier = new MockSupplier <MemoryCacheParams>(_params); _platformBitmapFactory = new MockPlatformBitmapFactory(); _bitmap = new SoftwareBitmap(BitmapPixelFormat.Rgba8, 50, 50); _bitmapReference = CloseableReference <SoftwareBitmap> .of( _bitmap, BITMAP_RESOURCE_RELEASER); _cache = new CountingMemoryCache <string, int>( _valueDescriptor, _cacheTrimStrategy, _paramsSupplier, _platformBitmapFactory, true); }
public void TestRemoveAllMatchingPredicate() { CloseableReference <int> originalRef1 = NewReference(110); CloseableReference <int> valueRef1 = _cache.Cache(KEYS[1], originalRef1); originalRef1.Dispose(); valueRef1.Dispose(); CloseableReference <int> originalRef2 = NewReference(120); CloseableReference <int> valueRef2 = _cache.Cache(KEYS[2], originalRef2); originalRef2.Dispose(); valueRef2.Dispose(); CloseableReference <int> originalRef3 = NewReference(130); CloseableReference <int> valueRef3 = _cache.Cache(KEYS[3], originalRef3); originalRef3.Dispose(); CountingMemoryCache <string, int> .Entry entry3 = _cache._cachedEntries.Get(KEYS[3]); CloseableReference <int> originalRef4 = NewReference(150); CloseableReference <int> valueRef4 = _cache.Cache(KEYS[4], originalRef4); originalRef4.Dispose(); int numEvictedEntries = _cache.RemoveAll( new Predicate <string>(key => key.Equals(KEYS[2]) || key.Equals(KEYS[3]))); Assert.AreEqual(2, numEvictedEntries); AssertTotalSize(2, 260); AssertExclusivelyOwnedSize(1, 110); AssertExclusivelyOwned(KEYS[1], 110); AssertNotCached(KEYS[2], 120); AssertOrphanWithCount(entry3, 1); AssertSharedWithCount(KEYS[4], 150, 1); Assert.IsTrue(_releaseValues.Contains(120)); Assert.IsFalse(_releaseValues.Contains(130)); valueRef3.Dispose(); Assert.IsTrue(_releaseValues.Contains(130)); }
public void TestClear() { CloseableReference <int> originalRef1 = NewReference(110); CloseableReference <int> cachedRef1 = _cache.Cache(KEYS[1], originalRef1); originalRef1.Dispose(); CountingMemoryCache <string, int> .Entry entry1 = _cache._cachedEntries.Get(KEYS[1]); CloseableReference <int> originalRef2 = NewReference(120); CloseableReference <int> cachedRef2 = _cache.Cache(KEYS[2], originalRef2); originalRef2.Dispose(); cachedRef2.Dispose(); _cache.Clear(); AssertTotalSize(0, 0); AssertExclusivelyOwnedSize(0, 0); AssertOrphanWithCount(entry1, 1); AssertNotCached(KEYS[2], 120); Assert.IsTrue(_releaseValues.Contains(120)); cachedRef1.Dispose(); Assert.IsTrue(_releaseValues.Contains(110)); }
/// <summary> /// Do nothing. /// </summary> public void RegisterEncodedMemoryCache <K, V>(CountingMemoryCache <K, V> encodedMemoryCache) { }
/// <summary> /// Do nothing. /// </summary> public void RegisterBitmapMemoryCache <K, V>(CountingMemoryCache <K, V> bitmapMemoryCache) { }