Reduce CacheEntry size

src/libraries/Microsoft.Extensions.Caching.Memory/src/CacheEntry.CacheEntryState.cs

@@ -0,0 +1,61 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+
+namespace Microsoft.Extensions.Caching.Memory
+{
+ internal partial class CacheEntry
+ {
+ // this type exists just to reduce CacheEntry size by replacing many enum & boolean fields with one of a size of Int32
+ private struct CacheEntryState
+ {
+ private byte _flags;
+ private byte _evictionReason;
+ private byte _priority;
+
+ internal CacheEntryState(CacheItemPriority priority) : this() => _priority = (byte)priority;
+
+ internal bool IsDisposed
+ {
+ get => ((Flags)_flags & Flags.IsDisposed) != 0;
+ set => SetFlag(Flags.IsDisposed, value);
+ }
+
+ internal bool IsExpired
+ {
+ get => ((Flags)_flags & Flags.IsExpired) != 0;
+ set => SetFlag(Flags.IsExpired, value);
+ }
+
+ internal bool IsValueSet
+ {
+ get => ((Flags)_flags & Flags.IsValueSet) != 0;
+ set => SetFlag(Flags.IsValueSet, value);
+ }
+
+ internal EvictionReason EvictionReason
+ {
+ get => (EvictionReason)_evictionReason;
+ set => _evictionReason = (byte)value;
+ }
+
+ internal CacheItemPriority Priority
+ {
+ get => (CacheItemPriority)_priority;
+ set => _priority = (byte)value;
+ }
+
+ private void SetFlag(Flags option, bool value) => _flags = (byte)(value ? (_flags | (byte)option) : (_flags & ~(byte)option));
+
+ [Flags]
+ private enum Flags : byte
+ {
+ Default = 0,
+ IsValueSet = 1 << 0,
+ IsExpired = 1 << 1,
+ IsDisposed = 1 << 2,
+ }
+ }
+ }
+}

src/libraries/Microsoft.Extensions.Caching.Memory/src/CacheEntry.CacheEntryTokens.cs

@@ -0,0 +1,139 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Primitives;
+
+namespace Microsoft.Extensions.Caching.Memory
+{
+ internal partial class CacheEntry
+ {
+ // this type exists just to reduce average CacheEntry size
+ // which typically is not using expiration tokens or callbacks
+ private sealed class CacheEntryTokens
+ {
+ private List<IChangeToken> _expirationTokens;
+ private List<IDisposable> _expirationTokenRegistrations;
+ private List<PostEvictionCallbackRegistration> _postEvictionCallbacks; // this is not really related to tokens, but was moved here to shrink typical CacheEntry size
+
+ internal List<IChangeToken> ExpirationTokens => _expirationTokens ??= new List<IChangeToken>();
+ internal List<PostEvictionCallbackRegistration> PostEvictionCallbacks => _postEvictionCallbacks ??= new List<PostEvictionCallbackRegistration>();
+
+ internal void AttachTokens()
+ {
+ if (_expirationTokens != null)
+ {
+ lock (this)
+ {
+ for (int i = 0; i < _expirationTokens.Count; i++)
+ {
+ IChangeToken expirationToken = _expirationTokens[i];
+ if (expirationToken.ActiveChangeCallbacks)
+ {
+ _expirationTokenRegistrations ??= new List<IDisposable>(1);
+ IDisposable registration = expirationToken.RegisterChangeCallback(ExpirationCallback, this);
+ _expirationTokenRegistrations.Add(registration);
+ }
+ }
+ }
+ }
+ }
+
+ internal bool CheckForExpiredTokens(CacheEntry cacheEntry)
+ {
+ if (_expirationTokens != null)
+ {
+ for (int i = 0; i < _expirationTokens.Count; i++)
+ {
+ IChangeToken expiredToken = _expirationTokens[i];
+ if (expiredToken.HasChanged)
+ {
+ cacheEntry.SetExpired(EvictionReason.TokenExpired);
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ internal bool CanPropagateTokens() => _expirationTokens != null;
+
+ internal void PropagateTokens(CacheEntry parentEntry)
+ {
+ if (_expirationTokens != null)
+ {
+ lock (this)
+ {
+ lock (parentEntry.GetOrCreateTokens())
+ {
+ foreach (IChangeToken expirationToken in _expirationTokens)
+ {
+ parentEntry.AddExpirationToken(expirationToken);
+ }
+ }
+ }
+ }
+ }
+
+ internal void DetachTokens()
+ {
+ // _expirationTokenRegistrations is not checked for null, because AttachTokens might initialize it under lock
+ // instead we are checking for _expirationTokens, because if they are not null, then _expirationTokenRegistrations might also be not null
+ if (_expirationTokens != null)
+ {
+ lock (this)
+ {
+ List<IDisposable> registrations = _expirationTokenRegistrations;
+ if (registrations != null)
+ {
+ _expirationTokenRegistrations = null;
+ for (int i = 0; i < registrations.Count; i++)
+ {
+ IDisposable registration = registrations[i];
+ registration.Dispose();
+ }
+ }
+ }
+ }
+ }
+
+ internal void InvokeEvictionCallbacks(CacheEntry cacheEntry)
+ {
+ if (_postEvictionCallbacks != null)
+ {
+ Task.Factory.StartNew(state => InvokeCallbacks((CacheEntry)state), cacheEntry,
+ CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
+ }
+ }
+
+ private static void InvokeCallbacks(CacheEntry entry)
+ {
+ List<PostEvictionCallbackRegistration> callbackRegistrations = Interlocked.Exchange(ref entry._tokens._postEvictionCallbacks, null);
+
+ if (callbackRegistrations == null)
+ {
+ return;
+ }
+
+ for (int i = 0; i < callbackRegistrations.Count; i++)
+ {
+ PostEvictionCallbackRegistration registration = callbackRegistrations[i];
+
+ try
+ {
+ registration.EvictionCallback?.Invoke(entry.Key, entry.Value, entry.EvictionReason, registration.State);
+ }
+ catch (Exception e)
+ {
+ // This will be invoked on a background thread, don't let it throw.
+ entry._cache._logger.LogError(e, "EvictionCallback invoked failed");
+ }
+ }
+ }
+ }
+ }
+}