rename (#164)

bitfaster · web-flow · commit dc49552575f0 · 2022-07-24T15:50:29.000-07:00
diff --git a/BitFaster.Caching.UnitTests/Lru/ConcurrentLruBuilderTests.cs b/BitFaster.Caching.UnitTests/Lru/ConcurrentLruBuilderTests.cs
@@ -135,7 +135,7 @@ public void TestIntCapacity()
         public void TestPartitionCapacity()
         {
             ICache<int, Disposable> lru = new ConcurrentLruBuilder<int, Disposable>()
-                .WithCapacity(new FavorFrequencyPartition(6))
+                .WithCapacity(new FavorWarmPartition(6))
                 .Build();
 
             lru.Capacity.Should().Be(6);
diff --git a/BitFaster.Caching.UnitTests/Lru/FavorWarmPartitionTests.cs b/BitFaster.Caching.UnitTests/Lru/FavorWarmPartitionTests.cs
@@ -9,28 +9,28 @@
 
 namespace BitFaster.Caching.UnitTests.Lru
 {
-    public class FavorFrequencyPartitionTests
+    public class FavorWarmPartitionTests
     {
         [Fact]
         public void WhenCapacityBelow3Throws()
         {
-            Action constructor = () => { var x = new FavorFrequencyPartition(2); };
+            Action constructor = () => { var x = new FavorWarmPartition(2); };
 
             constructor.Should().Throw<ArgumentOutOfRangeException>();
         }
 
         [Fact]
         public void WhenRatioBelow0Throws()
         {
-            Action constructor = () => { var x = new FavorFrequencyPartition(5, 0.0); };
+            Action constructor = () => { var x = new FavorWarmPartition(5, 0.0); };
 
             constructor.Should().Throw<ArgumentOutOfRangeException>();
         }
 
         [Fact]
         public void WhenRatioAbove1Throws()
         {
-            Action constructor = () => { var x = new FavorFrequencyPartition(5, 1.0); };
+            Action constructor = () => { var x = new FavorWarmPartition(5, 1.0); };
 
             constructor.Should().Throw<ArgumentOutOfRangeException>();
         }
@@ -50,7 +50,7 @@ public void WhenRatioAbove1Throws()
         [InlineData(100, 10, 80, 10)]
         public void EqualPartitioningCreatesEqualQueues(int totalCapacity, int expectedHot, int expectedWarm, int expectedCold)
         {
-            var p = new FavorFrequencyPartition(totalCapacity);
+            var p = new FavorWarmPartition(totalCapacity);
 
             p.Hot.Should().Be(expectedHot);
             p.Warm.Should().Be(expectedWarm);
diff --git a/BitFaster.Caching/Lru/Builder/LruBuilderBase.cs b/BitFaster.Caching/Lru/Builder/LruBuilderBase.cs
@@ -26,7 +26,7 @@ protected LruBuilderBase(LruInfo<K> info)
         /// <returns>A ConcurrentLruBuilder</returns>
         public TBuilder WithCapacity(int capacity)
         {
-            this.info.Capacity = new FavorFrequencyPartition(capacity);
+            this.info.Capacity = new FavorWarmPartition(capacity);
             return this as TBuilder;
         }
 
diff --git a/BitFaster.Caching/Lru/Builder/LruInfo.cs b/BitFaster.Caching/Lru/Builder/LruInfo.cs
@@ -8,7 +8,7 @@ namespace BitFaster.Caching.Lru.Builder
 {
     public sealed class LruInfo<K>
     {
-        public ICapacityPartition Capacity { get; set; } = new FavorFrequencyPartition(128);
+        public ICapacityPartition Capacity { get; set; } = new FavorWarmPartition(128);
 
         public int ConcurrencyLevel { get; set; } = Defaults.ConcurrencyLevel;
 
diff --git a/BitFaster.Caching/Lru/ConcurrentLru.cs b/BitFaster.Caching/Lru/ConcurrentLru.cs
@@ -15,7 +15,7 @@ public sealed class ConcurrentLru<K, V> : TemplateConcurrentLru<K, V, LruItem<K,
         /// </summary>
         /// <param name="capacity">The maximum number of elements that the ConcurrentLru can contain.</param>
         public ConcurrentLru(int capacity)
-            : base(Defaults.ConcurrencyLevel, new FavorFrequencyPartition(capacity), EqualityComparer<K>.Default, default, default)
+            : base(Defaults.ConcurrencyLevel, new FavorWarmPartition(capacity), EqualityComparer<K>.Default, default, default)
         {
         }
 
@@ -27,7 +27,7 @@ public ConcurrentLru(int capacity)
         /// <param name="capacity">The maximum number of elements that the ConcurrentLru can contain.</param>
         /// <param name="comparer">The IEqualityComparer<T> implementation to use when comparing keys.</param>
         public ConcurrentLru(int concurrencyLevel, int capacity, IEqualityComparer<K> comparer)
-            : base(concurrencyLevel, new FavorFrequencyPartition(capacity), comparer, default, default)
+            : base(concurrencyLevel, new FavorWarmPartition(capacity), comparer, default, default)
         {
         }
 
diff --git a/BitFaster.Caching/Lru/ConcurrentTLru.cs b/BitFaster.Caching/Lru/ConcurrentTLru.cs
@@ -16,7 +16,7 @@ public sealed class ConcurrentTLru<K, V> : TemplateConcurrentLru<K, V, LongTickC
         /// <param name="capacity">The maximum number of elements that the ConcurrentTLru can contain.</param>
         /// <param name="timeToLive">The time to live for cached values.</param>
         public ConcurrentTLru(int capacity, TimeSpan timeToLive)
-            : base(Defaults.ConcurrencyLevel, new FavorFrequencyPartition(capacity), EqualityComparer<K>.Default, new TLruLongTicksPolicy<K, V>(timeToLive), default)
+            : base(Defaults.ConcurrencyLevel, new FavorWarmPartition(capacity), EqualityComparer<K>.Default, new TLruLongTicksPolicy<K, V>(timeToLive), default)
         { 
         }
 
@@ -29,7 +29,7 @@ public ConcurrentTLru(int capacity, TimeSpan timeToLive)
         /// <param name="comparer">The IEqualityComparer<T> implementation to use when comparing keys.</param>
         /// <param name="timeToLive">The time to live for cached values.</param>
         public ConcurrentTLru(int concurrencyLevel, int capacity, IEqualityComparer<K> comparer, TimeSpan timeToLive)
-            : base(concurrencyLevel, new FavorFrequencyPartition(capacity), comparer, new TLruLongTicksPolicy<K, V>(timeToLive), default)
+            : base(concurrencyLevel, new FavorWarmPartition(capacity), comparer, new TLruLongTicksPolicy<K, V>(timeToLive), default)
         {
         }
 
diff --git a/BitFaster.Caching/Lru/FastConcurrentLru.cs b/BitFaster.Caching/Lru/FastConcurrentLru.cs
@@ -13,7 +13,7 @@ public sealed class FastConcurrentLru<K, V> : TemplateConcurrentLru<K, V, LruIte
         /// </summary>
         /// <param name="capacity">The maximum number of elements that the FastConcurrentLru can contain.</param>
         public FastConcurrentLru(int capacity)
-            : base(Defaults.ConcurrencyLevel, new FavorFrequencyPartition(capacity), EqualityComparer<K>.Default, default, default)
+            : base(Defaults.ConcurrencyLevel, new FavorWarmPartition(capacity), EqualityComparer<K>.Default, default, default)
         {
         }
 
@@ -25,7 +25,7 @@ public FastConcurrentLru(int capacity)
         /// <param name="capacity">The maximum number of elements that the FastConcurrentLru can contain.</param>
         /// <param name="comparer">The IEqualityComparer<T> implementation to use when comparing keys.</param>
         public FastConcurrentLru(int concurrencyLevel, int capacity, IEqualityComparer<K> comparer)
-            : base(concurrencyLevel, new FavorFrequencyPartition(capacity), comparer, default, default)
+            : base(concurrencyLevel, new FavorWarmPartition(capacity), comparer, default, default)
         {
         }
 
diff --git a/BitFaster.Caching/Lru/FastConcurrentTLru.cs b/BitFaster.Caching/Lru/FastConcurrentTLru.cs
@@ -14,7 +14,7 @@ public sealed class FastConcurrentTLru<K, V> : TemplateConcurrentLru<K, V, LongT
         /// <param name="capacity">The maximum number of elements that the FastConcurrentTLru can contain.</param>
         /// <param name="timeToLive">The time to live for cached values.</param>
         public FastConcurrentTLru(int capacity, TimeSpan timeToLive)
-            : base(Defaults.ConcurrencyLevel, new FavorFrequencyPartition(capacity), EqualityComparer<K>.Default, new TLruLongTicksPolicy<K, V>(timeToLive), default)
+            : base(Defaults.ConcurrencyLevel, new FavorWarmPartition(capacity), EqualityComparer<K>.Default, new TLruLongTicksPolicy<K, V>(timeToLive), default)
         {
         }
 
@@ -27,7 +27,7 @@ public FastConcurrentTLru(int capacity, TimeSpan timeToLive)
         /// <param name="comparer">The IEqualityComparer<T> implementation to use when comparing keys.</param>
         /// <param name="timeToLive">The time to live for cached values.</param>
         public FastConcurrentTLru(int concurrencyLevel, int capacity, IEqualityComparer<K> comparer, TimeSpan timeToLive)
-            : base(concurrencyLevel, new FavorFrequencyPartition(capacity), comparer, new TLruLongTicksPolicy<K, V>(timeToLive), default)
+            : base(concurrencyLevel, new FavorWarmPartition(capacity), comparer, new TLruLongTicksPolicy<K, V>(timeToLive), default)
         {
         }
 
diff --git a/BitFaster.Caching/Lru/FavorWarmPartition.cs b/BitFaster.Caching/Lru/FavorWarmPartition.cs
@@ -10,7 +10,7 @@ namespace BitFaster.Caching.Lru
     /// A capacity partitioning scheme that favors frequently accessed items by allocating 80% 
     /// capacity to the warm queue.
     /// </summary>
-    public class FavorFrequencyPartition : ICapacityPartition
+    public class FavorWarmPartition : ICapacityPartition
     {
         private readonly int hotCapacity;
         private readonly int warmCapacity;
@@ -20,12 +20,12 @@ public class FavorFrequencyPartition : ICapacityPartition
         // This favors frequently accessed items.
         public const double DefaultWarmRatio = 0.8;
 
-        public FavorFrequencyPartition(int totalCapacity)
+        public FavorWarmPartition(int totalCapacity)
             : this(totalCapacity, DefaultWarmRatio)
         {
         }
 
-        public FavorFrequencyPartition(int totalCapacity, double warmRatio)
+        public FavorWarmPartition(int totalCapacity, double warmRatio)
         {
             var (hot, warm, cold) = ComputeQueueCapacity(totalCapacity, warmRatio);
             this.hotCapacity = hot;

Original file line number	Diff line number	Diff line change
`@@ -135,7 +135,7 @@ public void TestIntCapacity()`
`135`	`135`	`public void TestPartitionCapacity()`
`136`	`136`	`{`
`137`	`137`	`ICache<int, Disposable> lru = new ConcurrentLruBuilder<int, Disposable>()`
`138`		`- .WithCapacity(new FavorFrequencyPartition(6))`
	`138`	`+ .WithCapacity(new FavorWarmPartition(6))`
`139`	`139`	`.Build();`
`140`	`140`
`141`	`141`	`lru.Capacity.Should().Be(6);`
Original file line number	Diff line number	Diff line change
`@@ -9,28 +9,28 @@`
`9`	`9`
`10`	`10`	`namespace BitFaster.Caching.UnitTests.Lru`
`11`	`11`	`{`
`12`		`- public class FavorFrequencyPartitionTests`
	`12`	`+ public class FavorWarmPartitionTests`
`13`	`13`	`{`
`14`	`14`	`[Fact]`
`15`	`15`	`public void WhenCapacityBelow3Throws()`
`16`	`16`	`{`
`17`		`- Action constructor = () => { var x = new FavorFrequencyPartition(2); };`
	`17`	`+ Action constructor = () => { var x = new FavorWarmPartition(2); };`
`18`	`18`
`19`	`19`	`constructor.Should().Throw<ArgumentOutOfRangeException>();`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`[Fact]`
`23`	`23`	`public void WhenRatioBelow0Throws()`
`24`	`24`	`{`
`25`		`- Action constructor = () => { var x = new FavorFrequencyPartition(5, 0.0); };`
	`25`	`+ Action constructor = () => { var x = new FavorWarmPartition(5, 0.0); };`
`26`	`26`
`27`	`27`	`constructor.Should().Throw<ArgumentOutOfRangeException>();`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`[Fact]`
`31`	`31`	`public void WhenRatioAbove1Throws()`
`32`	`32`	`{`
`33`		`- Action constructor = () => { var x = new FavorFrequencyPartition(5, 1.0); };`
	`33`	`+ Action constructor = () => { var x = new FavorWarmPartition(5, 1.0); };`
`34`	`34`
`35`	`35`	`constructor.Should().Throw<ArgumentOutOfRangeException>();`
`36`	`36`	`}`
`@@ -50,7 +50,7 @@ public void WhenRatioAbove1Throws()`
`50`	`50`	`[InlineData(100, 10, 80, 10)]`
`51`	`51`	`public void EqualPartitioningCreatesEqualQueues(int totalCapacity, int expectedHot, int expectedWarm, int expectedCold)`
`52`	`52`	`{`
`53`		`- var p = new FavorFrequencyPartition(totalCapacity);`
	`53`	`+ var p = new FavorWarmPartition(totalCapacity);`
`54`	`54`
`55`	`55`	`p.Hot.Should().Be(expectedHot);`
`56`	`56`	`p.Warm.Should().Be(expectedWarm);`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ protected LruBuilderBase(LruInfo<K> info)`
`26`	`26`	`/// <returns>A ConcurrentLruBuilder</returns>`
`27`	`27`	`public TBuilder WithCapacity(int capacity)`
`28`	`28`	`{`
`29`		`- this.info.Capacity = new FavorFrequencyPartition(capacity);`
	`29`	`+ this.info.Capacity = new FavorWarmPartition(capacity);`
`30`	`30`	`return this as TBuilder;`
`31`	`31`	`}`
`32`	`32`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ namespace BitFaster.Caching.Lru.Builder`
`8`	`8`	`{`
`9`	`9`	`public sealed class LruInfo<K>`
`10`	`10`	`{`
`11`		`- public ICapacityPartition Capacity { get; set; } = new FavorFrequencyPartition(128);`
	`11`	`+ public ICapacityPartition Capacity { get; set; } = new FavorWarmPartition(128);`
`12`	`12`
`13`	`13`	`public int ConcurrencyLevel { get; set; } = Defaults.ConcurrencyLevel;`
`14`	`14`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ public sealed class ConcurrentLru<K, V> : TemplateConcurrentLru<K, V, LruItem<K,`
`15`	`15`	`/// </summary>`
`16`	`16`	`/// <param name="capacity">The maximum number of elements that the ConcurrentLru can contain.</param>`
`17`	`17`	`public ConcurrentLru(int capacity)`
`18`		`- : base(Defaults.ConcurrencyLevel, new FavorFrequencyPartition(capacity), EqualityComparer<K>.Default, default, default)`
	`18`	`+ : base(Defaults.ConcurrencyLevel, new FavorWarmPartition(capacity), EqualityComparer<K>.Default, default, default)`
`19`	`19`	`{`
`20`	`20`	`}`
`21`	`21`
`@@ -27,7 +27,7 @@ public ConcurrentLru(int capacity)`
`27`	`27`	`/// <param name="capacity">The maximum number of elements that the ConcurrentLru can contain.</param>`
`28`	`28`	`/// <param name="comparer">The IEqualityComparer<T> implementation to use when comparing keys.</param>`
`29`	`29`	`public ConcurrentLru(int concurrencyLevel, int capacity, IEqualityComparer<K> comparer)`
`30`		`- : base(concurrencyLevel, new FavorFrequencyPartition(capacity), comparer, default, default)`
	`30`	`+ : base(concurrencyLevel, new FavorWarmPartition(capacity), comparer, default, default)`
`31`	`31`	`{`
`32`	`32`	`}`
`33`	`33`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ public sealed class ConcurrentTLru<K, V> : TemplateConcurrentLru<K, V, LongTickC`
`16`	`16`	`/// <param name="capacity">The maximum number of elements that the ConcurrentTLru can contain.</param>`
`17`	`17`	`/// <param name="timeToLive">The time to live for cached values.</param>`
`18`	`18`	`public ConcurrentTLru(int capacity, TimeSpan timeToLive)`
`19`		`- : base(Defaults.ConcurrencyLevel, new FavorFrequencyPartition(capacity), EqualityComparer<K>.Default, new TLruLongTicksPolicy<K, V>(timeToLive), default)`
	`19`	`+ : base(Defaults.ConcurrencyLevel, new FavorWarmPartition(capacity), EqualityComparer<K>.Default, new TLruLongTicksPolicy<K, V>(timeToLive), default)`
`20`	`20`	`{`
`21`	`21`	`}`
`22`	`22`
`@@ -29,7 +29,7 @@ public ConcurrentTLru(int capacity, TimeSpan timeToLive)`
`29`	`29`	`/// <param name="comparer">The IEqualityComparer<T> implementation to use when comparing keys.</param>`
`30`	`30`	`/// <param name="timeToLive">The time to live for cached values.</param>`
`31`	`31`	`public ConcurrentTLru(int concurrencyLevel, int capacity, IEqualityComparer<K> comparer, TimeSpan timeToLive)`
`32`		`- : base(concurrencyLevel, new FavorFrequencyPartition(capacity), comparer, new TLruLongTicksPolicy<K, V>(timeToLive), default)`
	`32`	`+ : base(concurrencyLevel, new FavorWarmPartition(capacity), comparer, new TLruLongTicksPolicy<K, V>(timeToLive), default)`
`33`	`33`	`{`
`34`	`34`	`}`
`35`	`35`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ public sealed class FastConcurrentLru<K, V> : TemplateConcurrentLru<K, V, LruIte`
`13`	`13`	`/// </summary>`
`14`	`14`	`/// <param name="capacity">The maximum number of elements that the FastConcurrentLru can contain.</param>`
`15`	`15`	`public FastConcurrentLru(int capacity)`
`16`		`- : base(Defaults.ConcurrencyLevel, new FavorFrequencyPartition(capacity), EqualityComparer<K>.Default, default, default)`
	`16`	`+ : base(Defaults.ConcurrencyLevel, new FavorWarmPartition(capacity), EqualityComparer<K>.Default, default, default)`
`17`	`17`	`{`
`18`	`18`	`}`
`19`	`19`
`@@ -25,7 +25,7 @@ public FastConcurrentLru(int capacity)`
`25`	`25`	`/// <param name="capacity">The maximum number of elements that the FastConcurrentLru can contain.</param>`
`26`	`26`	`/// <param name="comparer">The IEqualityComparer<T> implementation to use when comparing keys.</param>`
`27`	`27`	`public FastConcurrentLru(int concurrencyLevel, int capacity, IEqualityComparer<K> comparer)`
`28`		`- : base(concurrencyLevel, new FavorFrequencyPartition(capacity), comparer, default, default)`
	`28`	`+ : base(concurrencyLevel, new FavorWarmPartition(capacity), comparer, default, default)`
`29`	`29`	`{`
`30`	`30`	`}`
`31`	`31`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ public sealed class FastConcurrentTLru<K, V> : TemplateConcurrentLru<K, V, LongT`
`14`	`14`	`/// <param name="capacity">The maximum number of elements that the FastConcurrentTLru can contain.</param>`
`15`	`15`	`/// <param name="timeToLive">The time to live for cached values.</param>`
`16`	`16`	`public FastConcurrentTLru(int capacity, TimeSpan timeToLive)`
`17`		`- : base(Defaults.ConcurrencyLevel, new FavorFrequencyPartition(capacity), EqualityComparer<K>.Default, new TLruLongTicksPolicy<K, V>(timeToLive), default)`
	`17`	`+ : base(Defaults.ConcurrencyLevel, new FavorWarmPartition(capacity), EqualityComparer<K>.Default, new TLruLongTicksPolicy<K, V>(timeToLive), default)`
`18`	`18`	`{`
`19`	`19`	`}`
`20`	`20`
`@@ -27,7 +27,7 @@ public FastConcurrentTLru(int capacity, TimeSpan timeToLive)`
`27`	`27`	`/// <param name="comparer">The IEqualityComparer<T> implementation to use when comparing keys.</param>`
`28`	`28`	`/// <param name="timeToLive">The time to live for cached values.</param>`
`29`	`29`	`public FastConcurrentTLru(int concurrencyLevel, int capacity, IEqualityComparer<K> comparer, TimeSpan timeToLive)`
`30`		`- : base(concurrencyLevel, new FavorFrequencyPartition(capacity), comparer, new TLruLongTicksPolicy<K, V>(timeToLive), default)`
	`30`	`+ : base(concurrencyLevel, new FavorWarmPartition(capacity), comparer, new TLruLongTicksPolicy<K, V>(timeToLive), default)`
`31`	`31`	`{`
`32`	`32`	`}`
`33`	`33`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ namespace BitFaster.Caching.Lru`
`10`	`10`	`/// A capacity partitioning scheme that favors frequently accessed items by allocating 80%`
`11`	`11`	`/// capacity to the warm queue.`
`12`	`12`	`/// </summary>`
`13`		`- public class FavorFrequencyPartition : ICapacityPartition`
	`13`	`+ public class FavorWarmPartition : ICapacityPartition`
`14`	`14`	`{`
`15`	`15`	`private readonly int hotCapacity;`
`16`	`16`	`private readonly int warmCapacity;`
`@@ -20,12 +20,12 @@ public class FavorFrequencyPartition : ICapacityPartition`
`20`	`20`	`// This favors frequently accessed items.`
`21`	`21`	`public const double DefaultWarmRatio = 0.8;`
`22`	`22`
`23`		`- public FavorFrequencyPartition(int totalCapacity)`
	`23`	`+ public FavorWarmPartition(int totalCapacity)`
`24`	`24`	`: this(totalCapacity, DefaultWarmRatio)`
`25`	`25`	`{`
`26`	`26`	`}`
`27`	`27`
`28`		`- public FavorFrequencyPartition(int totalCapacity, double warmRatio)`
	`28`	`+ public FavorWarmPartition(int totalCapacity, double warmRatio)`
`29`	`29`	`{`
`30`	`30`	`var (hot, warm, cold) = ComputeQueueCapacity(totalCapacity, warmRatio);`
`31`	`31`	`this.hotCapacity = hot;`