jodydonetti
commented
9 months ago Hi @neon-sunset and thanks for your report, I appreciate the time it took you.
As you have pointed out other libs do in fact more than FastCache, and FusionCache in particular I think supports a lot of features and options, so it's something kinda expected, at least up to a certain point.
Having said that it's important to make sure the perf impact is as small as possible: in the last months I've been quite busy finishing the new Auto-Recovery feature which took a lot of time, and it may be that I haven't paid the needed attention to some extra allocations or cpu cycle spent here and there.
I'll try to make sure that the resources needed are as low as possible, and will update you on this later on as soon as I have updates: keep in mind though that to support all the extra features that FusionCache provides (2nd level, fail-safe, auto-recovery, etc), some extra resources are to be accounted for.
Meanwhile thanks again for your report!
neon-sunset
Describe the issue See numbers below. There are other issues like cache line pollution on reads through interlocked applied to a singular location which will ruin the scaling on many-core systems but I wanted to start with bringing attention to the implementation flaws in the first place.
In the outlined scenario of in-memory cache,
FusionCachecomes last and allocates significantly more than all other options. WhileFastCacheis very focused at doing a singular task (in-memory cache with per-item expiration and eviction) that allows it to be as fast as is technically possible,MemoryCacheandLazyCachehave much more features and still allocate much less.Unrelated but somewhat amusing is that OpenJDK improves by 10% at most between 17 and 21, and .NET sees 20-40% speed-up after just a single LTS version bump.
Benchmark code
```csharp using System; using System.Diagnostics.CodeAnalysis; using BenchmarkDotNet.Attributes; using BenchmarkDotNet.Jobs; using FastCache; using LazyCache; using Microsoft.Extensions.Caching.Memory; namespace ZiggyCreatures.Caching.Fusion.Benchmarks { [RankColumn] [MemoryDiagnoser] [ShortRunJob(RuntimeMoniker.Net60)] [ShortRunJob(RuntimeMoniker.Net80)] [Orderer(BenchmarkDotNet.Order.SummaryOrderPolicy.FastestToSlowest)] public class HappyPathBenchmark { const string Key = "test key"; const string Value = "test value"; readonly FusionCache Cache = new(new FusionCacheOptions()); readonly MemoryCache MemoryCache = new(new MemoryCacheOptions()); readonly CachingService LazyCache = new(); [GlobalSetup] public void Setup() { Cache.Set(Key, Value); MemoryCache.Set(Key, Value); LazyCache.Add(Key, Value); Cached.Save(Key, Value, TimeSpan.FromDays(1));
}
public class Reads : HappyPathBenchmark
{
[Benchmark(Baseline = true)]
public string GetFusionCache()
{
var result = Cache.TryGet(Key);
return result.HasValue ? result.Value : Unreachable();
}
[Benchmark]
public string GetMemoryCache()
{
return MemoryCache.TryGetValue(Key, out var value)
? value : Unreachable();
}
[Benchmark]
public string GetLazyCache()
{
return LazyCache.TryGetValue(Key, out var value)
? value : Unreachable();
}
[Benchmark]
public string GetFastCache()
{
return Cached.TryGet(Key, out var value)
? value : Unreachable();
}
}
public class Writes : HappyPathBenchmark
{
[Benchmark(Baseline = true)]
public void SetFusionCache() => Cache.Set(Key, Value);
[Benchmark]
public void SetMemoryCache() => MemoryCache.Set(Key, Value);
[Benchmark]
public void SetLazyCache() => LazyCache.Add(Key, Value);
[Benchmark]
public void SetFastCache() => Cached.Save(Key, Value, TimeSpan.FromDays(1));
}
[DoesNotReturn]
static string Unreachable() => throw new Exception("Unreachable code");
}
}
```
Reads:
Writes