Implement minimal implementation of HybridCache #55147
There are no files selected for viewing
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,77 @@ | ||
| // 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.Buffers; | ||
| using System.Diagnostics; | ||
| using System.Runtime.CompilerServices; | ||
|
|
||
| namespace Microsoft.Extensions.Caching.Hybrid.Internal; | ||
|
|
||
| // used to convey buffer status; like ArraySegment<byte>, but Offset is always | ||
| // zero, and we use the MSB of the length to track whether or not to recycle this value | ||
| internal readonly struct BufferChunk | ||
| { | ||
| private const int MSB = (1 << 31); | ||
|
|
||
| private readonly int _lengthAndPoolFlag; | ||
| public byte[]? Array { get; } // null for default | ||
|
|
||
| public int Length => _lengthAndPoolFlag & ~MSB; | ||
|
|
||
| public bool ReturnToPool => (_lengthAndPoolFlag & MSB) != 0; | ||
|
|
||
| public byte[] ToArray() | ||
| { | ||
| var length = Length; | ||
| if (length == 0) | ||
| { | ||
| return []; | ||
| } | ||
|
|
||
| var copy = new byte[length]; | ||
| Buffer.BlockCopy(Array!, 0, copy, 0, length); | ||
| return copy; | ||
| } | ||
|
|
||
| public BufferChunk(byte[] array) | ||
| { | ||
| Debug.Assert(array is not null, "expected valid array input"); | ||
| Array = array; | ||
| _lengthAndPoolFlag = array.Length; | ||
| // assume not pooled, if exact-sized | ||
| Debug.Assert(!ReturnToPool, "do not return right-sized arrays"); | ||
mgravell marked this conversation as resolved.
Show resolved
Hide resolved
|
||
| Debug.Assert(Length == array.Length, "array length not respected"); | ||
| } | ||
|
|
||
| public BufferChunk(byte[] array, int length, bool returnToPool) | ||
| { | ||
| Debug.Assert(array is not null, "expected valid array input"); | ||
| Debug.Assert(length >= 0, "expected valid length"); | ||
| Array = array; | ||
| _lengthAndPoolFlag = length | (returnToPool ? MSB : 0); | ||
| Debug.Assert(ReturnToPool == returnToPool, "return-to-pool not respected"); | ||
| Debug.Assert(Length == length, "length not respected"); | ||
| } | ||
|
|
||
| internal void RecycleIfAppropriate() | ||
| { | ||
| if (ReturnToPool) | ||
| { | ||
| ArrayPool<byte>.Shared.Return(Array!); | ||
| } | ||
| Unsafe.AsRef(in this) = default; // anti foot-shotgun double-return guard; not 100%, but worth doing | ||
amcasey marked this conversation as resolved.
Show resolved
Hide resolved
|
||
| Debug.Assert(Array is null && !ReturnToPool, "expected clean slate after recycle"); | ||
mgravell marked this conversation as resolved.
Show resolved
Hide resolved
|
||
| } | ||
|
|
||
| internal ReadOnlySequence<byte> AsSequence() => Length == 0 ? default : new ReadOnlySequence<byte>(Array!, 0, Length); | ||
|
|
||
| internal BufferChunk DoNotReturnToPool() | ||
|
There was a problem hiding this comment. I'm pretty sure this makes a clone with the "return to pool" bit cleared and leaves this copy as-is? |
||
| { | ||
| var copy = this; | ||
| Unsafe.AsRef(in copy._lengthAndPoolFlag) &= ~MSB; | ||
amcasey marked this conversation as resolved.
Show resolved
Hide resolved
|
||
| Debug.Assert(copy.Length == Length, "same length expected"); | ||
| Debug.Assert(!copy.ReturnToPool, "do not return to pool"); | ||
| return copy; | ||
| } | ||
| } | ||
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,49 @@ | ||
| // 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 Microsoft.Extensions.Caching.Memory; | ||
|
|
||
| namespace Microsoft.Extensions.Caching.Hybrid.Internal; | ||
|
|
||
| partial class DefaultHybridCache | ||
| { | ||
| internal abstract class CacheItem | ||
| { | ||
| internal static readonly PostEvictionDelegate _sharedOnEviction = static (key, value, reason, state) => | ||
| { | ||
| if (value is CacheItem item) | ||
| { | ||
| // perform per-item clean-up; this could be buffer recycling (if defensive copies needed), | ||
| // or could be disposal | ||
| item.OnEviction(); | ||
| } | ||
| }; | ||
|
|
||
| public virtual void Release() { } // for recycling purposes | ||
|
|
||
| public abstract bool NeedsEvictionCallback { get; } // do we need to call Release when evicted? | ||
|
|
||
| public virtual void OnEviction() { } // only invoked if NeedsEvictionCallback reported true | ||
|
|
||
| public abstract bool TryReserveBuffer(out BufferChunk buffer); | ||
|
|
||
| public abstract bool DebugIsImmutable { get; } | ||
| } | ||
|
|
||
| internal abstract class CacheItem<T> : CacheItem | ||
| { | ||
| public abstract bool TryGetValue(out T value); | ||
|
|
||
| public T GetValue() | ||
| { | ||
| if (!TryGetValue(out var value)) | ||
| { | ||
| Throw(); | ||
| } | ||
| return value; | ||
|
|
||
| static void Throw() => throw new ObjectDisposedException("The cache item has been recycled before the value was obtained"); | ||
|
There was a problem hiding this comment. Why pull this out? Something about perf? There was a problem hiding this comment. Correct, it lets the calling method be inlined into its caller. See the "Use static throw helpers" section here: https://reubenbond.github.io/posts/dotnet-perf-tuning. I am not certain if the advice still holds, given all of the advancements in the JIT in the last 5 years, but I still generally manually split out the rare, expensive paths to make methods easier to inline There was a problem hiding this comment.
It still holds. For non-throwing rare path methods they can be marked with non-inlining, to make sure that the JIT won't inline these methods by coincidence. There was a problem hiding this comment. The reason the JIT doesn't inline methods with throws is that it wants to keep them on the stack in the event of an exception? |
||
| } | ||
| } | ||
| } | ||
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,70 @@ | ||
| // Licensed to the .NET Foundation under one or more agreements. | ||
| // The .NET Foundation licenses this file to you under the MIT license. | ||
|
|
||
| using System.Diagnostics; | ||
| using System.Diagnostics.CodeAnalysis; | ||
| using System.Threading; | ||
|
|
||
| namespace Microsoft.Extensions.Caching.Hybrid.Internal; | ||
|
|
||
| partial class DefaultHybridCache | ||
| { | ||
| internal bool DebugTryGetCacheItem(string key, [NotNullWhen(true)] out CacheItem? value) | ||
| { | ||
| if (_localCache.TryGetValue(key, out var untyped) && untyped is CacheItem typed) | ||
| { | ||
| value = typed; | ||
| return true; | ||
| } | ||
| value = null; | ||
| return false; | ||
| } | ||
|
|
||
| #if DEBUG // enable ref-counted buffers | ||
|
|
||
| private int _outstandingBufferCount; | ||
|
|
||
| internal int DebugGetOutstandingBuffers(bool flush = false) | ||
| => flush ? Interlocked.Exchange(ref _outstandingBufferCount, 0) : Volatile.Read(ref _outstandingBufferCount); | ||
|
|
||
| [Conditional("DEBUG")] | ||
| internal void DebugDecrementOutstandingBuffers() | ||
| { | ||
| Interlocked.Decrement(ref _outstandingBufferCount); | ||
| } | ||
|
|
||
| [Conditional("DEBUG")] | ||
| internal void DebugIncrementOutstandingBuffers() | ||
| { | ||
| Interlocked.Increment(ref _outstandingBufferCount); | ||
| } | ||
| #endif | ||
|
|
||
| partial class MutableCacheItem<T> | ||
| { | ||
| partial void DebugDecrementOutstandingBuffers(); | ||
| partial void DebugTrackBufferCore(DefaultHybridCache cache); | ||
|
|
||
| [Conditional("DEBUG")] | ||
| internal void DebugTrackBuffer(DefaultHybridCache cache) => DebugTrackBufferCore(cache); | ||
|
|
||
| #if DEBUG | ||
| private DefaultHybridCache? _cache; // for buffer-tracking - only enabled in DEBUG | ||
| partial void DebugDecrementOutstandingBuffers() | ||
| { | ||
| if (_buffer.ReturnToPool) | ||
| { | ||
| _cache?.DebugDecrementOutstandingBuffers(); | ||
| } | ||
| } | ||
| partial void DebugTrackBufferCore(DefaultHybridCache cache) | ||
| { | ||
| _cache = cache; | ||
| if (_buffer.ReturnToPool) | ||
| { | ||
| _cache?.DebugIncrementOutstandingBuffers(); | ||
| } | ||
| } | ||
| #endif | ||
| } | ||
| } |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,45 @@ | ||
| // 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.Diagnostics; | ||
| using System.Diagnostics.CodeAnalysis; | ||
|
|
||
| namespace Microsoft.Extensions.Caching.Hybrid.Internal; | ||
|
|
||
| partial class DefaultHybridCache | ||
| { | ||
| private sealed class ImmutableCacheItem<T> : CacheItem<T> // used to hold types that do not require defensive copies | ||
|
There was a problem hiding this comment. Make it a doc comment? (And below.) |
||
| { | ||
| private readonly T _value; | ||
| public ImmutableCacheItem(T value) => _value = value; | ||
|
|
||
| private static ImmutableCacheItem<T>? _sharedDefault; | ||
|
|
||
| // this is only used when the underlying store is disabled; we don't need 100% singleton; "good enough is" | ||
| public static ImmutableCacheItem<T> Default => _sharedDefault ??= new(default!); | ||
|
|
||
| public override void OnEviction() | ||
| { | ||
| var obj = _value as IDisposable; | ||
| Debug.Assert(obj is not null, "shouldn't be here for non-disposable types"); | ||
| obj?.Dispose(); | ||
| } | ||
|
|
||
| public override bool NeedsEvictionCallback => ImmutableTypeCache<T>.IsDisposable; | ||
|
|
||
| public override bool TryGetValue(out T value) | ||
| { | ||
| value = _value; | ||
| return true; // always available | ||
| } | ||
|
|
||
| public override bool TryReserveBuffer(out BufferChunk buffer) | ||
| { | ||
| buffer = default; | ||
| return false; // we don't have one to reserve! | ||
| } | ||
|
|
||
| public override bool DebugIsImmutable => true; | ||
| } | ||
| } | ||
Oops, something went wrong.
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Uh oh!
There was an error while loading. Please reload this page.