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");
+                    }
+                }
+            }
+        }
+    }
+}