Пример #1
0
        public void Benchmark()
        {
            var serializer = new JsonCommonSerializer();

            var port = new Random().Next(30000, 60000);

            var options = new WebSocketListenerOptions();

            options.SubProtocols = new[] { "SignalR" };
            var listener = new WebSocketListener(new IPEndPoint(IPAddress.Loopback, port), options);
            var rfc6455  = new vtortola.WebSockets.Rfc6455.WebSocketFactoryRfc6455(listener);

            listener.Standards.RegisterStandard(rfc6455);
            var serverTransport = listener.GenerateTransportSource();
            var serverRouter    = new DefaultMessageRouter(serverTransport, serializer);

            serverRouter.AddService <ISumService>(new SumService());
            listener.Start();

            var client = new ClientWebSocket();

            client.Options.AddSubProtocol("SignalR");
            var clientTransport = client.GenerateTransportSource();
            var clientRouter    = new DefaultMessageRouter(clientTransport, serializer);
            var proxy           = clientRouter.AddInterface <ISumService>();

            client.ConnectAsync(new Uri("ws://localhost:" + port + "/"), CancellationToken.None).Wait();

            const int randCnt = 100;
            var       rand    = new Random(42);
            var       randoms = new int[randCnt];

            for (int i = 0; i < randCnt; i++)
            {
                randoms[i] = rand.Next(10000000, 20000000);
            }

            var       sw = new Stopwatch();
            long      timeFromClient = 0, timeToClient = 0;
            const int cnt = 1000;

            for (int j = 0; j < cnt; j++)
            {
                sw.Start();
                var sum = proxy.Sum(randoms).Result;
                sw.Stop();
                Assert.Equal(randoms.Sum(), sum);
                for (int i = 0; i < randCnt; i++)
                {
                    randoms[i] = rand.Next(10000000, 20000000);
                }
                var times = proxy.TimeDiff(Stopwatch.GetTimestamp()).Result;
                timeFromClient += times.Item1;
                timeToClient   += Stopwatch.GetTimestamp() - times.Item2;
            }

            _testOutputHelper.WriteLine("Completed {0} sum passes in {1}ms", cnt, sw.ElapsedMilliseconds);
            _testOutputHelper.WriteLine("Client to server latency: {0}us", timeFromClient / cnt / 10);
            _testOutputHelper.WriteLine("Server to client latency: {0}us", timeToClient / cnt / 10);

            sw.Reset();
            var tree = new SumServiceTree();

            SumServiceTree.FillTree(tree, rand, 2);
            _testOutputHelper.WriteLine("Starting large message transfer.");
            sw.Start();
            var result = proxy.Increment(tree).Result;

            sw.Stop();
            Assert.Equal(tree.Leaf + 1, result.Leaf);
            _testOutputHelper.WriteLine("Completed large transfer in {0}ms", sw.Elapsed.TotalMilliseconds);

            clientRouter.Dispose();
            clientTransport.Dispose();
            client.Dispose();

            serverRouter.Dispose();
            serverTransport.Dispose();
            listener.Dispose();
        }
Пример #2
0
        public void Benchmark()
        {
            var    serializer = new JsonCommonSerializer();          // new ProtobufCommonSerializer();//
            int    port = -1;
            Poller client = null, server = null;
            var    serverThread = RunServer <ISumService>(serializer, p => port = p, p => server = p, new SumService());

            while (port == -1)
            {
                Thread.Yield();
            }
            ISumService proxy        = null;
            var         clientThread = RunClient <ISumService>(serializer, port, p => client = p, p => proxy = p);

            while (proxy == null)
            {
                Thread.Yield();
            }

            const int randCnt = 100;
            var       rand    = new Random(42);
            var       randoms = new int[randCnt];

            for (int i = 0; i < randCnt; i++)
            {
                randoms[i] = rand.Next(10000000, 20000000);
            }

            var       sw = new Stopwatch();
            long      timeFromClient = 0, timeToClient = 0;
            const int cnt = 1000;

            for (int j = 0; j < cnt; j++)
            {
                sw.Start();
                var sum = proxy.Sum(randoms).Result;
                sw.Stop();
                Assert.Equal(randoms.Sum(), sum);
                for (int i = 0; i < randCnt; i++)
                {
                    randoms[i] = rand.Next(10000000, 20000000);
                }
                var times = proxy.TimeDiff(Stopwatch.GetTimestamp()).Result;
                timeFromClient += times.Item1;
                timeToClient   += Stopwatch.GetTimestamp() - times.Item2;
            }

            _testOutputHelper.WriteLine("Completed {0} sum passes in {1}ms", cnt, sw.ElapsedMilliseconds);
            _testOutputHelper.WriteLine("Client to server latency: {0}us", timeFromClient / cnt / 10);
            _testOutputHelper.WriteLine("Server to client latency: {0}us", timeToClient / cnt / 10);

            sw.Reset();
            var tree = new SumServiceTree();

            SumServiceTree.FillTree(tree, rand, 2);
            _testOutputHelper.WriteLine("Starting large message transfer.");
            sw.Start();
            var result = proxy.Increment(tree).Result;

            sw.Stop();
            Assert.True(tree.IsExactMatch(result, 1));
            _testOutputHelper.WriteLine("Completed large transfer in {0}ms", sw.Elapsed.TotalMilliseconds);

            client.CancelAndJoin();
            server.CancelAndJoin();

            clientThread.Wait();
            serverThread.Wait();
        }
Пример #3
0
        public void Benchmark()
        {
            //var serializerSource = new Newtonsoft.Json.JsonSerializer();
            var serializer = new ProtobufCommonSerializer();            //new JsonCommonSerializer(serializerSource); //

            var port = new Random().Next(6000, 60000);

            var listener = new Socket(AddressFamily.InterNetwork, SocketType.Dgram);

            listener.Bind(IPAddress.Loopback, port);
            listener.Listen(100);
            var serverTransport = listener.GenerateTransportSource(true);
            var serverRouter    = new DefaultMessageRouter(serverTransport, serializer);

            serverRouter.AddService <ISumService>(new SumService());

            var client = new Socket(AddressFamily.InterNetwork, SocketType.Dgram);

            client.Connect(IPAddress.Loopback, port);
            var clientTransport = client.GenerateTransportSource(false);
            var clientRouter    = new DefaultMessageRouter(clientTransport, serializer);
            var proxy           = clientRouter.AddInterface <ISumService>();

            const int randCnt = 100;
            var       rand    = new Random(42);
            var       randoms = new int[randCnt];

            for (int i = 0; i < randCnt; i++)
            {
                randoms[i] = rand.Next(10000000, 20000000);
            }

            var       sw = new Stopwatch();
            long      timeFromClient = 0, timeToClient = 0;
            const int cnt = 1000;

            for (int j = 0; j < cnt; j++)
            {
                sw.Start();
                var sum = proxy.Sum(randoms).Result;
                sw.Stop();
                Assert.Equal(randoms.Sum(), sum);
                for (int i = 0; i < randCnt; i++)
                {
                    randoms[i] = rand.Next(10000000, 20000000);
                }
                var times = proxy.TimeDiff(Stopwatch.GetTimestamp()).Result;
                timeFromClient += times.Item1;
                timeToClient   += Stopwatch.GetTimestamp() - times.Item2;
            }

            _testOutputHelper.WriteLine("Completed {0} sum passes in {1}ms", cnt, sw.ElapsedMilliseconds);
            _testOutputHelper.WriteLine("Client to server latency: {0}us", timeFromClient / cnt / 10);
            _testOutputHelper.WriteLine("Server to client latency: {0}us", timeToClient / cnt / 10);

            sw.Reset();
            var tree = new SumServiceTree();

            SumServiceTree.FillTree(tree, rand, 2);
            _testOutputHelper.WriteLine("Starting large message transfer.");
            sw.Start();
            var result = proxy.Increment(tree).Result;

            sw.Stop();
            Assert.Equal(tree.Leaf + 1, result.Leaf);
            _testOutputHelper.WriteLine("Completed large transfer in {0}ms", sw.Elapsed.TotalMilliseconds);

            clientRouter.Dispose();
            clientTransport.Dispose();
            client.Dispose();

            serverRouter.Dispose();
            serverTransport.Dispose();
            listener.Dispose();
        }
Пример #4
0
        public void BenchmarkMessagesWebSocketSharp()
        {
            var serializer = new JsonCommonSerializer();             // new ProtobufCommonSerializer(); //
            var port       = new Random().Next(20000, 60000);

            var url    = "http://localhost:" + port + "/";
            var server = WebApp.Start <Startup>(url);

            var client          = new WebSocketSharp.WebSocket("ws://localhost:" + port + "/rt1");
            var clientTransport = client.GenerateTransportSource();
            var clientRouter    = new DefaultMessageRouter(clientTransport, serializer);
            var proxy           = clientRouter.AddInterface <ISumService>();

            client.Connect();

            const int randCnt = 100;
            var       rand    = new Random(42);
            var       randoms = new int[randCnt];

            for (int i = 0; i < randCnt; i++)
            {
                randoms[i] = rand.Next(10000000, 20000000);
            }

            var       sw = new Stopwatch();
            long      timeFromClient = 0, timeToClient = 0;
            const int cnt = 1000;

            for (int j = 0; j < cnt; j++)
            {
                sw.Start();
                var sum = proxy.Sum(randoms).Result;
                sw.Stop();
                Assert.Equal(randoms.Sum(), sum);
                for (int i = 0; i < randCnt; i++)
                {
                    randoms[i] = rand.Next(10000000, 20000000);
                }
                var times = proxy.TimeDiff(Stopwatch.GetTimestamp()).Result;
                timeFromClient += times.Item1;
                timeToClient   += Stopwatch.GetTimestamp() - times.Item2;
            }

            _testOutputHelper.WriteLine("Completed {0} sum passes in {1}ms", cnt, sw.ElapsedMilliseconds);
            _testOutputHelper.WriteLine("Client to server latency: {0}us", timeFromClient / cnt / 10);
            _testOutputHelper.WriteLine("Server to client latency: {0}us", timeToClient / cnt / 10);

            sw.Reset();
            var tree = new SumServiceTree();

            SumServiceTree.FillTree(tree, rand, 2);
            _testOutputHelper.WriteLine("Starting large message transfer.");
            sw.Start();
            var result = proxy.Increment(tree).Result;

            sw.Stop();
            Assert.Equal(tree.Leaf + 1, result.Leaf);
            _testOutputHelper.WriteLine("Completed large transfer in {0}ms", sw.Elapsed.TotalMilliseconds);

            client.Close();
            server.Dispose();
        }