StackExchange redis client très lent par rapport aux tests de référence

les résultats de Mes le code ci-dessous:

Connecting to server...
Connected
PING (sync per op)
    1709ms for 1000000 ops on 50 threads took 1.709594 seconds
    585137 ops/s
SET (sync per op)
    759ms for 500000 ops on 50 threads took 0.7592914 seconds
    658761 ops/s
GET (sync per op)
    780ms for 500000 ops on 50 threads took 0.7806102 seconds
    641025 ops/s
PING (pipelined per thread)
    3751ms for 1000000 ops on 50 threads took 3.7510956 seconds
    266595 ops/s
SET (pipelined per thread)
    1781ms for 500000 ops on 50 threads took 1.7819831 seconds
    280741 ops/s
GET (pipelined per thread)
    1977ms for 500000 ops on 50 threads took 1.9772623 seconds
    252908 ops/s

===

configuration du serveur: Assurez-vous que la persistance est désactivée, etc

la première chose à faire dans un benchmark est: benchmark one thing. En ce moment, vous incluez beaucoup de sérialisation au-dessus, ce qui n'aidera pas à obtenir une image claire. Idéalement, pour un périmètre de référence, vous devriez utiliser une charge fixe de 3 octets, parce que:

3 octets charge utile

Ensuite, vous devez regarder le parallélisme:

50 clients parallèles

Il n'est pas clair si votre test est parallèle, mais si ce n'est pas que nous devrions absolument attendre voir moins de débit brut. Comme par hasard, SE.Redis est conçu pour être facile à paralléliser: vous pouvez tout simplement faire tourner plusieurs threads parlant de la même connexion (en fait, cela a aussi l'avantage d'éviter les paquets fragmentation, car vous pouvez vous retrouver avec plusieurs messages par paquet, où-comme une approche de synchronisation à un seul thread est garanti d'utiliser au plus un message par paquet).

enfin, nous devons comprendre ce que fait le benchmark. Est-il en train de faire:

(send, receive) x n

ou est-il en train de faire

send x n, receive separately until all n are received

? Les deux options sont possibles. Votre utilisation de l'API de synchronisation est la première, mais le second test est également bien défini, et pour autant que je sache: c'est ce qu'il mesure. Y deux façons de simuler cette deuxième configuration:

• envoyer les premiers (n-1) messages avec le drapeau "fire and forget", donc vous seulement en fait, attendre le dernier
• *Async API pour tous les messages, et seulement Wait() ou await la dernière Task

voici un benchmark que j'ai utilisé dans ce qui précède, qui montre à la fois "sync per op" (via L'API sync) et "pipeline per thread" (en utilisant le *Async API et juste en attendant le dernière tâche par thread), Les Deux utilisant 50 threads:

using StackExchange.Redis;
using System;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;

static class P
{
    static void Main()
    {
        Console.WriteLine("Connecting to server...");
        using (var muxer = ConnectionMultiplexer.Connect("127.0.0.1"))
        {
            Console.WriteLine("Connected");
            var db = muxer.GetDatabase();

            RedisKey key = "some key";
            byte[] payload = new byte[3];
            new Random(12345).NextBytes(payload);
            RedisValue value = payload;
            DoWork("PING (sync per op)", db, 1000000, 50, x => { x.Ping(); return null; });
            DoWork("SET (sync per op)", db, 500000, 50, x => { x.StringSet(key, value); return null; });
            DoWork("GET (sync per op)", db, 500000, 50, x => { x.StringGet(key); return null; });

            DoWork("PING (pipelined per thread)", db, 1000000, 50, x => x.PingAsync());
            DoWork("SET (pipelined per thread)", db, 500000, 50, x => x.StringSetAsync(key, value));
            DoWork("GET (pipelined per thread)", db, 500000, 50, x => x.StringGetAsync(key));
        }
    }
    static void DoWork(string action, IDatabase db, int count, int threads, Func<IDatabase, Task> op)
    {
        object startup = new object(), shutdown = new object();
        int activeThreads = 0, outstandingOps = count;
        Stopwatch sw = default(Stopwatch);
        var threadStart = new ThreadStart(() =>
        {
            lock(startup)
            {
                if(++activeThreads == threads)
                {
                    sw = Stopwatch.StartNew();
                    Monitor.PulseAll(startup);
                }
                else
                {
                    Monitor.Wait(startup);
                }
            }
            Task final = null;
            while (Interlocked.Decrement(ref outstandingOps) >= 0)
            {
                final = op(db);
            }
            if (final != null) final.Wait();
            lock(shutdown)
            {
                if (--activeThreads == 0)
                {
                    sw.Stop();
                    Monitor.PulseAll(shutdown);
                }
            }
        });
        lock (shutdown)
        {
            for (int i = 0; i < threads; i++)
            {
                new Thread(threadStart).Start();
            }
            Monitor.Wait(shutdown);
            Console.WriteLine($@"{action}
    {sw.ElapsedMilliseconds}ms for {count} ops on {threads} threads took {sw.Elapsed.TotalSeconds} seconds
    {(count * 1000) / sw.ElapsedMilliseconds} ops/s");
        }
    }
}