La Mémoire Cache .Net 4.0 test de performance : résultat étonnant

Le problème, c'est le Chronomètre de la classe qui ne peut pas être utilisé sur les systèmes multi-core machines! (Je suis en supposant que vous avez un PROCESSEUR multi-core) quelque Chose à voir avec la façon dont le BIOS gère le compteur lorsqu'un thread se déplace d'un coeur à un autre (même un seul thread de l'application des sauts de carottes!).

Edit:

Découvrez - http://msdn.microsoft.com/en-us/library/windows/desktop/ms644904(v=vs. 85).aspx - plus précisément, la section remarques.
Il y a un stackoverflow poste en tant que bien Multicœur et le thread courant .Net chronomètre?.
Fin Modifier

J'ai cherché haut et bas pour la meilleure méthode pour mesurer les performances de l'application et les plus fiables que j'ai est de type DateTime.UtcNow. Obtenez de départ et de fin, puis prendre la différence entre eux. Vous avez à votre boucle de code assez pour obtenir au-delà de la faible précision, mais pas d'autre méthode que j'ai trouver donne plus de fiable précision.

OriginalL'auteur Marko

J'ai juste cherché sur le net pour plus d'informations sur MemoryCache performance et je suis tombé sur cette SORTE de question. Je me suis demandé pourquoi un bon indice de référence de la bibliothèque n'était pas utilisé, donc j'ai fini la cuisson de ma propre référence en étant très paresseux (comme tous les bons programmeurs devraient 🙂 et utilisé l'incroyable BenchmarkDotNet bibliothèque pour vérifier (ou non) cette classe se comporte.

D'abord les résultats

BenchmarkDotNet=v0.11.5, OS=Windows 10.0.17134.706 (1803/April2018Update/Redstone4)
Intel Core i5-8250U CPU 1.60GHz (Kaby Lake R), 1 CPU, 8 logical and 4 physical cores
Frequency=1757813 Hz, Resolution=568.8887 ns, Timer=TSC
[Host]     : .NET Framework 4.7.2 (CLR 4.0.30319.42000), 64bit RyuJIT-v4.7.3394.0
DefaultJob : .NET Framework 4.7.2 (CLR 4.0.30319.42000), 64bit RyuJIT-v4.7.3394.0
|                         Method |     N |      Mean |     Error |    StdDev |
|------------------------------- |------ |----------:|----------:|----------:|
|            FindDadosEmpInCache | 30000 | 231.40 ns | 0.4435 ns | 0.3703 ns |
|               FindDataAtTheEnd | 30000 | 429.90 ns | 1.1490 ns | 1.0186 ns |
|           FindDataInDictionary | 30000 |  24.09 ns | 0.2244 ns | 0.2099 ns |
| FindDataInConcurrentDictionary | 30000 |  29.66 ns | 0.0990 ns | 0.0926 ns |
|              FindDataInHashset | 30000 |  16.25 ns | 0.0077 ns | 0.0065 ns |

Maintenant quelques explications...

J'étais surtout intéressé à voir comment rapide MemoryCache serait comparer haché listes (Dictionary, Hashset...) avec des milliers d'entrées, et aussi pour le pire des cas, la recherche linéaire sur la durée" de la liste. J'ai donc ajouté quelques tests supplémentaires et réalise que tout MemoryCache n'est pas aussi rapide que le simple ou simultanées, listes, la vitesse se trouve encore à l'ordre de la nanoseconde à l'échelle. Pas même une seule milliseconde est pris pour extraire un élément dans un 30,000 longue liste des éléments mis en cache.

Pour être juste MemoryCache fait BEAUCOUP plus que ceux de simples listes, comme il se doit de contrôle de la concurrence, élément d'expiration/de l'expulsion, etc. Je crois qu'il est assez rapide pour tous les types de charges de travail, mais si vous n'avez pas besoin de ces fonctionnalités supplémentaires, comme l'expulsion des politiques, il est préférable de coller avec le plus simple haché listes des implémentations.

D'autre part, puisque c'est une commande d'une ampleur "plus lent" que d'un hachage de recherche, il peut y avoir de place pour l'amélioration. Je suppose que les concepteurs de la pensée, il est juste assez bon comme il est, et qui suis-je pour être en désaccord avec la DOTNET ingénieurs? 🙂

Voici le code source pour le programme de test:

using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Caching;
namespace TestListPerformance
{
class Program
{
static void Main(string[] args) {
var summary = BenchmarkRunner.Run<BenchmarkMemoryCache>();
}
}
public class BenchmarkMemoryCache
{
[Params(30000)]
public int N { get; set; }
public string FindStr;
private IList<DadosEmp> data;
private Dictionary<string, DadosEmp> dict;
private ConcurrentDictionary<string, DadosEmp> concurrentDict;
private HashSet<DadosEmp> hashset;
private DadosEmp last;
[GlobalSetup]
public void BuildData() {
FindStr = N.ToString();
data = new List<DadosEmp>(N);
dict = new Dictionary<string, DadosEmp>(N);
concurrentDict = new ConcurrentDictionary<string, DadosEmp>();
hashset = new HashSet<DadosEmp>();
for (int i = 0; i <= N; i++) {
DadosEmp d;
data.Add(d = new DadosEmp {
Identificacao = i,
Pis = i * 100,
NumCartao = i * 1000,
Nome = "Nome " + i.ToString(),
});
MemoryCache.Default.Add(i.ToString(), d, 
new CacheItemPolicy { SlidingExpiration = TimeSpan.FromMinutes(30) });
dict.Add(i.ToString(), d);
concurrentDict.TryAdd(i.ToString(), d);
hashset.Add(d);
last = d;
}
}
[Benchmark]
public DadosEmp FindDadosEmpInCache() {
var f = (DadosEmp)MemoryCache.Default.Get(FindStr);
return f;
}
[Benchmark]
public DadosEmp FindDataAtTheEnd() {
var f = data.FirstOrDefault(e => e.NumCartao == N || e.Pis == N || e.Identificacao == N);
return f;
}
[Benchmark]
public DadosEmp FindDataInDictionary() {
var f = dict[FindStr];
return f;
}
[Benchmark]
public DadosEmp FindDataInConcurrentDictionary() {
var f = concurrentDict[FindStr];
return f;
}
[Benchmark]
public bool FindDataInHashset() {
return hashset.Contains(last);
}
}
public class DadosEmp : IEquatable<DadosEmp> 
{
public const string BIO_EXCLUSAO = "xbio";
public DadosEmp() {
Biometrias = new List<string>();
}
public long Identificacao { get; set; }
public long Pis { get; set; }
public long NumCartao { get; set; }
public string Nome { get; set; }
public int VersaoBio { get; set; }
public string Unidade { get; set; }
public IList<string> Biometrias { get; set; }
public string Biometria { get; set; } 
public bool ExcluirBiometria { get { return Biometria == BIO_EXCLUSAO; } }
public DateTime DataEnvioRep { get; set; } 
public string SenhaTeclado { get; set; }
public bool ExigeAutorizacaoSaida { get; set; }
public bool BioRepPendente { get; set; }
public override bool Equals(object obj) {
DadosEmp e = obj as DadosEmp;
if (ReferenceEquals(e, null))
return false;
return Equals(e);
}
public bool Equals(DadosEmp e) {
if (ReferenceEquals(e, null))
return false;
return e.Pis == this.Pis;
}
public override int GetHashCode() {
return Pis.GetHashCode();
}
public override string ToString() {
return string.Format("{0} ({1} - {2})", Nome, Pis, Identificacao);
}
}
}

OriginalL'auteur Loudenvier