From 37892d02b728c376593823664c7ea8cec81c9fb8 Mon Sep 17 00:00:00 2001 From: Alex Peck Date: Mon, 13 Nov 2023 19:30:33 -0800 Subject: [PATCH 1/3] factory --- .../Lru/Builder/AsyncConcurrentLruBuilder.cs | 8 +--- BitFaster.Caching/Lru/ConcurrentLruBuilder.cs | 19 +------- BitFaster.Caching/Lru/ConcurrentLruFactory.cs | 47 +++++++++++++++++++ 3 files changed, 49 insertions(+), 25 deletions(-) create mode 100644 BitFaster.Caching/Lru/ConcurrentLruFactory.cs diff --git a/BitFaster.Caching/Lru/Builder/AsyncConcurrentLruBuilder.cs b/BitFaster.Caching/Lru/Builder/AsyncConcurrentLruBuilder.cs index db39e689..9f3c672d 100644 --- a/BitFaster.Caching/Lru/Builder/AsyncConcurrentLruBuilder.cs +++ b/BitFaster.Caching/Lru/Builder/AsyncConcurrentLruBuilder.cs @@ -16,13 +16,7 @@ internal AsyncConcurrentLruBuilder(LruInfo info) /// public override IAsyncCache Build() { - return info switch - { - LruInfo i when i.WithMetrics && !i.TimeToExpireAfterWrite.HasValue => new ConcurrentLru(info.ConcurrencyLevel, info.Capacity, info.KeyComparer), - LruInfo i when i.WithMetrics && i.TimeToExpireAfterWrite.HasValue => new ConcurrentTLru(info.ConcurrencyLevel, info.Capacity, info.KeyComparer, info.TimeToExpireAfterWrite.Value), - LruInfo i when i.TimeToExpireAfterWrite.HasValue => new FastConcurrentTLru(info.ConcurrencyLevel, info.Capacity, info.KeyComparer, info.TimeToExpireAfterWrite.Value), - _ => new FastConcurrentLru(info.ConcurrencyLevel, info.Capacity, info.KeyComparer), - }; + return ConcurrentLruFactory.CreateAsyncCache(this.info); } } } diff --git a/BitFaster.Caching/Lru/ConcurrentLruBuilder.cs b/BitFaster.Caching/Lru/ConcurrentLruBuilder.cs index 96f5192a..30b4524c 100644 --- a/BitFaster.Caching/Lru/ConcurrentLruBuilder.cs +++ b/BitFaster.Caching/Lru/ConcurrentLruBuilder.cs @@ -40,24 +40,7 @@ internal ConcurrentLruBuilder(LruInfo info) /// public override ICache Build() { - if (info.TimeToExpireAfterWrite.HasValue && info.TimeToExpireAfterAccess.HasValue) - Throw.InvalidOp("Specifying both ExpireAfterWrite and ExpireAfterAccess is not supported."); - - return info switch - { - LruInfo i when i.WithMetrics && !i.TimeToExpireAfterWrite.HasValue && !i.TimeToExpireAfterAccess.HasValue => new ConcurrentLru(info.ConcurrencyLevel, info.Capacity, info.KeyComparer), - LruInfo i when i.WithMetrics && i.TimeToExpireAfterWrite.HasValue && !i.TimeToExpireAfterAccess.HasValue => new ConcurrentTLru(info.ConcurrencyLevel, info.Capacity, info.KeyComparer, info.TimeToExpireAfterWrite.Value), - LruInfo i when i.TimeToExpireAfterWrite.HasValue && !i.TimeToExpireAfterAccess.HasValue => new FastConcurrentTLru(info.ConcurrencyLevel, info.Capacity, info.KeyComparer, info.TimeToExpireAfterWrite.Value), - LruInfo i when i.WithMetrics && !i.TimeToExpireAfterWrite.HasValue && i.TimeToExpireAfterAccess.HasValue => CreateExpireAfterAccess>(info), - LruInfo i when !i.TimeToExpireAfterWrite.HasValue && i.TimeToExpireAfterAccess.HasValue => CreateExpireAfterAccess>(info), - _ => new FastConcurrentLru(info.ConcurrencyLevel, info.Capacity, info.KeyComparer), - }; - } - - private static ICache CreateExpireAfterAccess(LruInfo info) where TP : struct, ITelemetryPolicy - { - return new ConcurrentLruCore, AfterAccessLongTicksPolicy, TP>( - info.ConcurrencyLevel, info.Capacity, info.KeyComparer, new AfterAccessLongTicksPolicy(info.TimeToExpireAfterAccess.Value), default); + return ConcurrentLruFactory.CreateCache(this.info); } } } diff --git a/BitFaster.Caching/Lru/ConcurrentLruFactory.cs b/BitFaster.Caching/Lru/ConcurrentLruFactory.cs new file mode 100644 index 00000000..f2e51787 --- /dev/null +++ b/BitFaster.Caching/Lru/ConcurrentLruFactory.cs @@ -0,0 +1,47 @@ +using BitFaster.Caching.Lru.Builder; + +namespace BitFaster.Caching.Lru +{ + /// + /// Factory class for creating ConcurrentLru variants. + /// + public static class ConcurrentLruFactory + { + /// + /// Creates a ConcurrentLru instance based on the provided LruInfo. + /// + /// The LruInfo + /// A ConcurrentLru + public static ICache CreateCache(LruInfo info) + { + if (info.TimeToExpireAfterWrite.HasValue && info.TimeToExpireAfterAccess.HasValue) + Throw.InvalidOp("Specifying both ExpireAfterWrite and ExpireAfterAccess is not supported."); + + return info switch + { + LruInfo i when i.WithMetrics && !i.TimeToExpireAfterWrite.HasValue && !i.TimeToExpireAfterAccess.HasValue => new ConcurrentLru(info.ConcurrencyLevel, info.Capacity, info.KeyComparer), + LruInfo i when i.WithMetrics && i.TimeToExpireAfterWrite.HasValue && !i.TimeToExpireAfterAccess.HasValue => new ConcurrentTLru(info.ConcurrencyLevel, info.Capacity, info.KeyComparer, info.TimeToExpireAfterWrite.Value), + LruInfo i when i.TimeToExpireAfterWrite.HasValue && !i.TimeToExpireAfterAccess.HasValue => new FastConcurrentTLru(info.ConcurrencyLevel, info.Capacity, info.KeyComparer, info.TimeToExpireAfterWrite.Value), + LruInfo i when i.WithMetrics && !i.TimeToExpireAfterWrite.HasValue && i.TimeToExpireAfterAccess.HasValue => CreateExpireAfterAccess>(info), + LruInfo i when !i.TimeToExpireAfterWrite.HasValue && i.TimeToExpireAfterAccess.HasValue => CreateExpireAfterAccess>(info), + _ => new FastConcurrentLru(info.ConcurrencyLevel, info.Capacity, info.KeyComparer), + }; + } + + /// + /// Creates a ConcurrentLru instance based on the provided LruInfo. + /// + /// The LruInfo + /// A ConcurrentLru + public static IAsyncCache CreateAsyncCache(LruInfo info) + { + return CreateCache(info) as IAsyncCache; + } + + private static ICache CreateExpireAfterAccess(LruInfo info) where TP : struct, ITelemetryPolicy + { + return new ConcurrentLruCore, AfterAccessLongTicksPolicy, TP>( + info.ConcurrencyLevel, info.Capacity, info.KeyComparer, new AfterAccessLongTicksPolicy(info.TimeToExpireAfterAccess.Value), default); + } + } +} From bab5dd1bb3ccaa2efa51355d6a400f2e03c64db2 Mon Sep 17 00:00:00 2001 From: Alex Peck Date: Mon, 13 Nov 2023 19:55:38 -0800 Subject: [PATCH 2/3] rename --- .../Lru/Builder/AsyncConcurrentLruBuilder.cs | 2 +- BitFaster.Caching/Lru/ConcurrentLruBuilder.cs | 2 +- BitFaster.Caching/Lru/ConcurrentLruFactory.cs | 47 --------------- BitFaster.Caching/Lru/LruFactory.cs | 58 +++++++++++++++++++ 4 files changed, 60 insertions(+), 49 deletions(-) delete mode 100644 BitFaster.Caching/Lru/ConcurrentLruFactory.cs create mode 100644 BitFaster.Caching/Lru/LruFactory.cs diff --git a/BitFaster.Caching/Lru/Builder/AsyncConcurrentLruBuilder.cs b/BitFaster.Caching/Lru/Builder/AsyncConcurrentLruBuilder.cs index 9f3c672d..5cbc887d 100644 --- a/BitFaster.Caching/Lru/Builder/AsyncConcurrentLruBuilder.cs +++ b/BitFaster.Caching/Lru/Builder/AsyncConcurrentLruBuilder.cs @@ -16,7 +16,7 @@ internal AsyncConcurrentLruBuilder(LruInfo info) /// public override IAsyncCache Build() { - return ConcurrentLruFactory.CreateAsyncCache(this.info); + return LruFactory.CreateAsyncConcurrent(this.info); } } } diff --git a/BitFaster.Caching/Lru/ConcurrentLruBuilder.cs b/BitFaster.Caching/Lru/ConcurrentLruBuilder.cs index 30b4524c..541d5897 100644 --- a/BitFaster.Caching/Lru/ConcurrentLruBuilder.cs +++ b/BitFaster.Caching/Lru/ConcurrentLruBuilder.cs @@ -40,7 +40,7 @@ internal ConcurrentLruBuilder(LruInfo info) /// public override ICache Build() { - return ConcurrentLruFactory.CreateCache(this.info); + return LruFactory.CreateConcurrent(this.info); } } } diff --git a/BitFaster.Caching/Lru/ConcurrentLruFactory.cs b/BitFaster.Caching/Lru/ConcurrentLruFactory.cs deleted file mode 100644 index f2e51787..00000000 --- a/BitFaster.Caching/Lru/ConcurrentLruFactory.cs +++ /dev/null @@ -1,47 +0,0 @@ -using BitFaster.Caching.Lru.Builder; - -namespace BitFaster.Caching.Lru -{ - /// - /// Factory class for creating ConcurrentLru variants. - /// - public static class ConcurrentLruFactory - { - /// - /// Creates a ConcurrentLru instance based on the provided LruInfo. - /// - /// The LruInfo - /// A ConcurrentLru - public static ICache CreateCache(LruInfo info) - { - if (info.TimeToExpireAfterWrite.HasValue && info.TimeToExpireAfterAccess.HasValue) - Throw.InvalidOp("Specifying both ExpireAfterWrite and ExpireAfterAccess is not supported."); - - return info switch - { - LruInfo i when i.WithMetrics && !i.TimeToExpireAfterWrite.HasValue && !i.TimeToExpireAfterAccess.HasValue => new ConcurrentLru(info.ConcurrencyLevel, info.Capacity, info.KeyComparer), - LruInfo i when i.WithMetrics && i.TimeToExpireAfterWrite.HasValue && !i.TimeToExpireAfterAccess.HasValue => new ConcurrentTLru(info.ConcurrencyLevel, info.Capacity, info.KeyComparer, info.TimeToExpireAfterWrite.Value), - LruInfo i when i.TimeToExpireAfterWrite.HasValue && !i.TimeToExpireAfterAccess.HasValue => new FastConcurrentTLru(info.ConcurrencyLevel, info.Capacity, info.KeyComparer, info.TimeToExpireAfterWrite.Value), - LruInfo i when i.WithMetrics && !i.TimeToExpireAfterWrite.HasValue && i.TimeToExpireAfterAccess.HasValue => CreateExpireAfterAccess>(info), - LruInfo i when !i.TimeToExpireAfterWrite.HasValue && i.TimeToExpireAfterAccess.HasValue => CreateExpireAfterAccess>(info), - _ => new FastConcurrentLru(info.ConcurrencyLevel, info.Capacity, info.KeyComparer), - }; - } - - /// - /// Creates a ConcurrentLru instance based on the provided LruInfo. - /// - /// The LruInfo - /// A ConcurrentLru - public static IAsyncCache CreateAsyncCache(LruInfo info) - { - return CreateCache(info) as IAsyncCache; - } - - private static ICache CreateExpireAfterAccess(LruInfo info) where TP : struct, ITelemetryPolicy - { - return new ConcurrentLruCore, AfterAccessLongTicksPolicy, TP>( - info.ConcurrencyLevel, info.Capacity, info.KeyComparer, new AfterAccessLongTicksPolicy(info.TimeToExpireAfterAccess.Value), default); - } - } -} diff --git a/BitFaster.Caching/Lru/LruFactory.cs b/BitFaster.Caching/Lru/LruFactory.cs new file mode 100644 index 00000000..8b13c502 --- /dev/null +++ b/BitFaster.Caching/Lru/LruFactory.cs @@ -0,0 +1,58 @@ +using System.Linq.Expressions; +using BitFaster.Caching.Lru.Builder; + +namespace BitFaster.Caching.Lru +{ + /// + /// Factory class for creating ConcurrentLru variants. + /// + public static class LruFactory + { + /// + /// Creates a ConcurrentLru instance based on the provided LruInfo. + /// + /// The LruInfo + /// A ConcurrentLru + public static ICache CreateConcurrent(LruInfo info) + { + if (info.TimeToExpireAfterWrite.HasValue && info.TimeToExpireAfterAccess.HasValue) + Throw.InvalidOp("Specifying both ExpireAfterWrite and ExpireAfterAccess is not supported."); + + //return info switch + //{ + // LruInfo i when i.WithMetrics && !i.TimeToExpireAfterWrite.HasValue && !i.TimeToExpireAfterAccess.HasValue => new ConcurrentLru(info.ConcurrencyLevel, info.Capacity, info.KeyComparer), + // LruInfo i when i.WithMetrics && i.TimeToExpireAfterWrite.HasValue && !i.TimeToExpireAfterAccess.HasValue => new ConcurrentTLru(info.ConcurrencyLevel, info.Capacity, info.KeyComparer, info.TimeToExpireAfterWrite.Value), + // LruInfo i when i.TimeToExpireAfterWrite.HasValue && !i.TimeToExpireAfterAccess.HasValue => new FastConcurrentTLru(info.ConcurrencyLevel, info.Capacity, info.KeyComparer, info.TimeToExpireAfterWrite.Value), + // LruInfo i when i.WithMetrics && !i.TimeToExpireAfterWrite.HasValue && i.TimeToExpireAfterAccess.HasValue => CreateExpireAfterAccess>(info), + // LruInfo i when !i.TimeToExpireAfterWrite.HasValue && i.TimeToExpireAfterAccess.HasValue => CreateExpireAfterAccess>(info), + // _ => new FastConcurrentLru(info.ConcurrencyLevel, info.Capacity, info.KeyComparer), + //}; + + return (info.WithMetrics, info.TimeToExpireAfterWrite.HasValue, info.TimeToExpireAfterAccess.HasValue) switch + { + (true, false, false) => new ConcurrentLru(info.ConcurrencyLevel, info.Capacity, info.KeyComparer), + (true, true, false) => new ConcurrentTLru(info.ConcurrencyLevel, info.Capacity, info.KeyComparer, info.TimeToExpireAfterWrite.Value), + (false, true, false) => new FastConcurrentTLru(info.ConcurrencyLevel, info.Capacity, info.KeyComparer, info.TimeToExpireAfterWrite.Value), + (true, false, true) => CreateExpireAfterAccess>(info), + (false, false, true) => CreateExpireAfterAccess>(info), + _ => new FastConcurrentLru(info.ConcurrencyLevel, info.Capacity, info.KeyComparer), + }; + } + + /// + /// Creates a ConcurrentLru instance based on the provided LruInfo. + /// + /// The LruInfo + /// A ConcurrentLru + public static IAsyncCache CreateAsyncConcurrent(LruInfo info) + { + return CreateConcurrent(info) as IAsyncCache; + } + + private static ICache CreateExpireAfterAccess(LruInfo info) where TP : struct, ITelemetryPolicy + { + return new ConcurrentLruCore, AfterAccessLongTicksPolicy, TP>( + info.ConcurrencyLevel, info.Capacity, info.KeyComparer, new AfterAccessLongTicksPolicy(info.TimeToExpireAfterAccess.Value), default); + } + } +} From b47edcd17cc9530fcd076647f7a9f46d2c82a285 Mon Sep 17 00:00:00 2001 From: Alex Peck Date: Mon, 13 Nov 2023 21:29:07 -0800 Subject: [PATCH 3/3] internal --- .../Lru/Builder/AsyncConcurrentLruBuilder.cs | 2 +- BitFaster.Caching/Lru/LruFactory.cs | 24 ++----------------- 2 files changed, 3 insertions(+), 23 deletions(-) diff --git a/BitFaster.Caching/Lru/Builder/AsyncConcurrentLruBuilder.cs b/BitFaster.Caching/Lru/Builder/AsyncConcurrentLruBuilder.cs index 5cbc887d..92272032 100644 --- a/BitFaster.Caching/Lru/Builder/AsyncConcurrentLruBuilder.cs +++ b/BitFaster.Caching/Lru/Builder/AsyncConcurrentLruBuilder.cs @@ -16,7 +16,7 @@ internal AsyncConcurrentLruBuilder(LruInfo info) /// public override IAsyncCache Build() { - return LruFactory.CreateAsyncConcurrent(this.info); + return LruFactory.CreateConcurrent(this.info) as IAsyncCache; } } } diff --git a/BitFaster.Caching/Lru/LruFactory.cs b/BitFaster.Caching/Lru/LruFactory.cs index 8b13c502..82ceecb0 100644 --- a/BitFaster.Caching/Lru/LruFactory.cs +++ b/BitFaster.Caching/Lru/LruFactory.cs @@ -6,28 +6,18 @@ namespace BitFaster.Caching.Lru /// /// Factory class for creating ConcurrentLru variants. /// - public static class LruFactory + internal static class LruFactory { /// /// Creates a ConcurrentLru instance based on the provided LruInfo. /// /// The LruInfo /// A ConcurrentLru - public static ICache CreateConcurrent(LruInfo info) + internal static ICache CreateConcurrent(LruInfo info) { if (info.TimeToExpireAfterWrite.HasValue && info.TimeToExpireAfterAccess.HasValue) Throw.InvalidOp("Specifying both ExpireAfterWrite and ExpireAfterAccess is not supported."); - //return info switch - //{ - // LruInfo i when i.WithMetrics && !i.TimeToExpireAfterWrite.HasValue && !i.TimeToExpireAfterAccess.HasValue => new ConcurrentLru(info.ConcurrencyLevel, info.Capacity, info.KeyComparer), - // LruInfo i when i.WithMetrics && i.TimeToExpireAfterWrite.HasValue && !i.TimeToExpireAfterAccess.HasValue => new ConcurrentTLru(info.ConcurrencyLevel, info.Capacity, info.KeyComparer, info.TimeToExpireAfterWrite.Value), - // LruInfo i when i.TimeToExpireAfterWrite.HasValue && !i.TimeToExpireAfterAccess.HasValue => new FastConcurrentTLru(info.ConcurrencyLevel, info.Capacity, info.KeyComparer, info.TimeToExpireAfterWrite.Value), - // LruInfo i when i.WithMetrics && !i.TimeToExpireAfterWrite.HasValue && i.TimeToExpireAfterAccess.HasValue => CreateExpireAfterAccess>(info), - // LruInfo i when !i.TimeToExpireAfterWrite.HasValue && i.TimeToExpireAfterAccess.HasValue => CreateExpireAfterAccess>(info), - // _ => new FastConcurrentLru(info.ConcurrencyLevel, info.Capacity, info.KeyComparer), - //}; - return (info.WithMetrics, info.TimeToExpireAfterWrite.HasValue, info.TimeToExpireAfterAccess.HasValue) switch { (true, false, false) => new ConcurrentLru(info.ConcurrencyLevel, info.Capacity, info.KeyComparer), @@ -39,16 +29,6 @@ public static ICache CreateConcurrent(LruInfo info) }; } - /// - /// Creates a ConcurrentLru instance based on the provided LruInfo. - /// - /// The LruInfo - /// A ConcurrentLru - public static IAsyncCache CreateAsyncConcurrent(LruInfo info) - { - return CreateConcurrent(info) as IAsyncCache; - } - private static ICache CreateExpireAfterAccess(LruInfo info) where TP : struct, ITelemetryPolicy { return new ConcurrentLruCore, AfterAccessLongTicksPolicy, TP>(