protected override void OnHandler(ParameterHandlerInfo info)
{
Core.Log.Warning("Starting COMPRESSOR TEST");
Core.Log.InfoBasic("Generating Random Bytes");
var rnd = new Random();
var bytes = new byte[ushort.MaxValue * 2000];
for (var i = 0; i < bytes.Length; i++)
{
bytes[i] = (byte)rnd.Next(50, 60);
}
Core.Log.InfoBasic("Total Bytes = {0}", bytes.Length.ToReadableBytes());
Core.Log.InfoBasic("Creating GZip Compressor");
var gzipCompressor = CompressorManager.GetByEncodingType("gzip");
using (Watch.Create("GZIP COMPRESSOR"))
{
var gzipBytes = gzipCompressor.Compress(bytes);
Core.Log.InfoBasic("Total GZIP Bytes = {0} - {1:0.000}%", gzipBytes.Count.ToReadableBytes(), ((double)gzipBytes.Count * 100) / bytes.Length);
}
Core.Log.InfoBasic("Creating Deflate Compressor");
var deflateCompressor = CompressorManager.GetByEncodingType("deflate");
using (Watch.Create("DEFLATE COMPRESSOR"))
{
var deflateBytes = deflateCompressor.Compress(bytes);
Core.Log.InfoBasic("Total DEFLATE Bytes = {0} - {1:0.000}%", deflateBytes.Count.ToReadableBytes(), ((double)deflateBytes.Count * 100) / bytes.Length);
}
}
private static void SerializerProcess(string name, object value, Type valueType, int times, ISerializer serializer, MemoryStream memStream)
{
double totalValue;
memStream.Position = 0;
GC.Collect();
GC.WaitForPendingFinalizers();
Thread.Sleep(1500);
using (var w = Watch.Create(name + " SERIALIZER"))
{
for (var i = 0; i < times; i++)
{
serializer.Serialize(value, valueType, memStream);
memStream.Position = 0;
}
totalValue = w.GlobalElapsedMilliseconds;
}
Core.Log.InfoBasic("\t" + name + " SERIALIZER - Average Time: {0}ms", totalValue / times);
GC.Collect();
GC.WaitForPendingFinalizers();
Thread.Sleep(1500);
using (var w = Watch.Create(name + " DESERIALIZER"))
{
for (var i = 0; i < times; i++)
{
serializer.Deserialize(memStream, valueType);
memStream.Position = 0;
}
totalValue = w.GlobalElapsedMilliseconds;
}
Core.Log.InfoBasic("\t" + name + " DESERIALIZER - Average Time: {0}ms", totalValue / times);
Thread.Sleep(1000);
Core.Log.WriteEmptyLine();
}
protected override async Task OnHandlerAsync(ParameterHandlerInfo info)
{
Core.DebugMode = false;
Core.Log.Warning("Starting CACHE Async TEST");
var cacheService = new TestCacheService();
cacheService.OnStart(null);
using (var cachePool = new CacheClientPoolAsync("Pool Test")
{
Serializer = GlobalSerializer, ForceAtLeastOneNetworkItemEnabled = false, WriteNetworkItemsToMemoryOnGet = true
})
{
var cacheClient = await CacheClientProxy.GetClientAsync(new DefaultTransportClient("127.0.0.1", 20051, 3, GlobalSerializer)).ConfigureAwait(false);
cachePool.Add("localhost:20051", cacheClient, StorageItemMode.ReadAndWrite);
//cachePool.Add("memory", new LRU2QStorage(2000), StorageItemMode.ReadAndWrite);
var res = await cachePool.GetMetaAsync("metaValue").ConfigureAwait(false);
await cachePool.GetKeysAsync().ConfigureAwait(false);
using (var watch = Watch.Create("GetKeysAsync"))
{
for (var i = 0; i < 1000; i++)
{
await cachePool.GetKeysAsync().ConfigureAwait(false);
}
Core.Log.InfoBasic("Time Per Item: {0}ms", watch.GlobalElapsedMilliseconds / 1000);
}
Console.ReadLine();
using (var watch = Watch.Create("Get And Sets"))
{
for (var i = 0; i < 5000; i++)
{
var key = "test-" + (i % 500);
await cachePool.GetAsync(key).ConfigureAwait(false);
await cachePool.SetAsync(key, "bla bla bla bla bla").ConfigureAwait(false);
}
Core.Log.InfoBasic("Time Per Item: {0}ms", watch.GlobalElapsedMilliseconds / 5000);
}
}
cacheService.OnStop();
Console.ReadLine();
}
private static void RawTest(MQPairConfig mqConfig)
{
using (var mqServer = mqConfig.GetRawServer())
{
var byteRequest = new byte[] { 0x21, 0x22, 0x23, 0x24, 0x25, 0x30, 0x31, 0x32, 0x33, 0x34 };
var byteResponse = new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x10, 0x11, 0x12, 0x13, 0x14 };
mqServer.RequestReceived += (s, e) =>
{
e.Response = byteResponse;
return(Task.CompletedTask);
};
mqServer.StartListeners();
using (var mqClient = mqConfig.GetRawClient())
{
var totalQ = 5000;
#region Sync Mode
Core.Log.Warning("RAW Sync Mode Test, using Unique Response Queue");
using (var w = Watch.Create($"Hello World Example in Sync Mode for {totalQ} times"))
{
for (var i = 0; i < totalQ; i++)
{
var response = mqClient.SendAndReceiveAsync(byteRequest).WaitAndResults();
}
Core.Log.InfoBasic("Total time: {0}", TimeSpan.FromMilliseconds(w.GlobalElapsedMilliseconds));
Core.Log.InfoBasic("Average time in ms: {0}. Press ENTER To Continue.", (w.GlobalElapsedMilliseconds / totalQ));
}
Console.ReadLine();
#endregion
#region Parallel Mode
Core.Log.Warning("RAW Parallel Mode Test, using Unique Response Queue");
using (var w = Watch.Create($"Hello World Example in Parallel Mode for {totalQ} times"))
{
Task.WaitAll(
Enumerable.Range(0, totalQ).Select((i, vTuple) => (Task)vTuple.mqClient.SendAndReceiveAsync(vTuple.byteRequest), (mqClient, byteRequest)).ToArray()
);
//Parallel.For(0, totalQ, i =>
//{
// var response = mqClient.SendAndReceiveAsync(byteRequest).WaitAndResults();
//});
Core.Log.InfoBasic("Total time: {0}", TimeSpan.FromMilliseconds(w.GlobalElapsedMilliseconds));
Core.Log.InfoBasic("Average time in ms: {0}. Press ENTER To Continue.", (w.GlobalElapsedMilliseconds / totalQ));
}
Console.ReadLine();
#endregion
}
}
}
private static void NormalTest(MQPairConfig mqConfig)
{
using (var mqServer = mqConfig.GetServer())
{
mqServer.RequestReceived += (s, e) =>
{
e.Response.Body = "Bienvenido!!!";
return(Task.CompletedTask);
};
mqServer.StartListeners();
using (var mqClient = mqConfig.GetClient())
{
var totalQ = 5000;
#region Sync Mode
Core.Log.Warning("Sync Mode Test, using Unique Response Queue");
using (var w = Watch.Create($"Hello World Example in Sync Mode for {totalQ} times"))
{
for (var i = 0; i < totalQ; i++)
{
var response = mqClient.SendAndReceiveAsync <string>("Hola mundo").WaitAndResults();
}
Core.Log.InfoBasic("Total time: {0}", TimeSpan.FromMilliseconds(w.GlobalElapsedMilliseconds));
Core.Log.InfoBasic("Average time in ms: {0}. Press ENTER To Continue.", (w.GlobalElapsedMilliseconds / totalQ));
}
Console.ReadLine();
#endregion
#region Parallel Mode
Core.Log.Warning("Parallel Mode Test, using Unique Response Queue");
using (var w = Watch.Create($"Hello World Example in Parallel Mode for {totalQ} times"))
{
Task.WaitAll(
Enumerable.Range(0, totalQ).Select((i, mc) => (Task)mc.SendAndReceiveAsync <string>("Hola mundo"), mqClient).ToArray()
);
//Parallel.For(0, totalQ, i =>
//{
// var response = mqClient.SendAndReceiveAsync<string>("Hola mundo").WaitAndResults();
//});
Core.Log.InfoBasic("Total time: {0}", TimeSpan.FromMilliseconds(w.GlobalElapsedMilliseconds));
Core.Log.InfoBasic("Average time in ms: {0}. Press ENTER To Continue.", (w.GlobalElapsedMilliseconds / totalQ));
}
Console.ReadLine();
#endregion
}
}
}
protected override void OnHandler(ParameterHandlerInfo info)
{
Core.Log.Warning("Starting String Hash Test");
var str = "Lorem ipsum dolor sit amet";
int number = 10_000_000;
int normalHash = 0;
uint superFastHash = 0;
uint murmurhash2 = 0;
uint murmurhash3 = 0;
str.GetHashCode();
str.GetSuperFastHash();
str.GetMurmurHash2();
str.GetMurmurHash3();
using (Watch.Create("Normal Hash - GetHashCode()"))
{
for (var i = 0; i < number; i++)
{
normalHash = (str + i).GetHashCode();
}
}
using (Watch.Create("Superfast Hash - GetSuperFastHash()"))
{
for (var i = 0; i < number; i++)
{
superFastHash = (str + i).GetSuperFastHash();
}
}
using (Watch.Create("MurmurHash2 Hash - GetMurmurHash2()"))
{
for (var i = 0; i < number; i++)
{
murmurhash2 = (str + i).GetMurmurHash2();
}
}
using (Watch.Create("MurmurHash3 Hash - GetMurmurHash3()"))
{
for (var i = 0; i < number; i++)
{
murmurhash3 = (str + i).GetMurmurHash3();
}
}
Core.Log.InfoBasic("Normal Hash: {0}", normalHash);
Core.Log.InfoBasic("Superfast Hash: {0}", superFastHash);
Core.Log.InfoBasic("MurmurHash2 Hash: {0}", murmurhash2);
Core.Log.InfoBasic("MurmurHash3 Hash: {0}", murmurhash3);
}
protected override void OnHandler(ParameterHandlerInfo info)
{
var n2obj1 = Core.Injector.New <IInjectTestA>("Default");
var n2obj2 = Core.Injector.New <IInjectTestB>("Default");
var instance1 = Core.Injector.New <IInjectTestA>("Default");
var instance2 = Core.Injector.New <IInjectTestA>("Default");
var times = 10_000_000;
Core.Log.InfoBasic("Injector Number of times: {0}", times);
using (var w = Watch.Create("Injector Object A"))
for (var i = 0; i < times; i++)
{
Core.Injector.New <IInjectTestA>("Default");
}
using (var w = Watch.Create("Injector Object B"))
for (var i = 0; i < times; i++)
{
Core.Injector.New <IInjectTestB>("Default");
}
if (instance1 != instance2)
{
Core.Log.InfoBasic("The instance are differents. OK");
}
else
{
Core.Log.Error("The instance is the same. Error");
}
var guid1 = instance1.GetGuid();
var guid2 = instance2.GetGuid();
if (guid1 != guid2)
{
Core.Log.InfoBasic("The Guid are differents. OK");
}
else
{
Core.Log.Error("The Guid are the same. Error");
}
}
private static async Task NormalTest(MQPairConfig mqConfig)
{
using (var mqServer = mqConfig.GetServer())
{
mqServer.RequestReceived += (s, e) =>
{
//Core.Trace.Write("Grupo", e.Request.CorrelationId.ToString(), e.Request.Body);
e.Response.Body = new SerializedObject("Bienvenido!!!");
return(Task.CompletedTask);
};
mqServer.StartListeners();
using (var mqClient = mqConfig.GetClient())
{
var totalQ = 50000;
#region Sync Mode
Core.Log.Warning("Sync Mode Test, using Unique Response Queue");
using (var w = Watch.Create($"Hello World Example in Sync Mode for {totalQ} times"))
{
for (var i = 0; i < totalQ; i++)
{
var response = await mqClient.SendAndReceiveAsync <string>("Hola mundo").ConfigureAwait(false);
}
Core.Log.InfoBasic("Total time: {0}", TimeSpan.FromMilliseconds(w.GlobalElapsedMilliseconds));
Core.Log.InfoBasic("Average time in ms: {0}. Press ENTER To Continue.", (w.GlobalElapsedMilliseconds / totalQ));
}
Console.ReadLine();
#endregion
#region Parallel Mode
Core.Log.Warning("Parallel Mode Test, using Unique Response Queue");
using (var w = Watch.Create($"Hello World Example in Parallel Mode for {totalQ} times"))
{
await Task.WhenAll(
Enumerable.Range(0, totalQ).Select((i, mqc) => (Task)mqc.SendAndReceiveAsync <string>("Hola mundo"), mqClient).ToArray()
).ConfigureAwait(false);
Core.Log.InfoBasic("Total time: {0}", TimeSpan.FromMilliseconds(w.GlobalElapsedMilliseconds));
Core.Log.InfoBasic("Average time in ms: {0}. Press ENTER To Continue.", (w.GlobalElapsedMilliseconds / totalQ));
}
Console.ReadLine();
#endregion
}
}
}
protected override void OnHandler(ParameterHandlerInfo info)
{
Core.Log.Warning("Starting SQL Server Test");
IDalCity dalCity = new DalCity();
using (Watch.Create("Sync Test"))
{
for (var i = 0; i < 30; i++)
{
using (var w = Watch.Create())
{
var values = dalCity.GetAll();
w.Tap("GetAll");
var arr = values.ToArray();
w.Tap($"Entity Binding: {arr.Length} items");
}
}
}
Console.ReadLine();
Task.Run(async() =>
{
using (Watch.Create("Async Test"))
{
for (var i = 0; i < 30; i++)
{
using (var w = Watch.Create())
{
var values = await dalCity.GetAllAsync().ConfigureAwait(false);
w.Tap("GetAll");
var arr = values.ToArray();
w.Tap($"Entity Binding: {arr.Length} items");
}
}
}
});
Console.ReadLine();
}
private static void ApplyTest(IStorage fSto)
{
var sobj = new SerializedObject("Esto es un ejemplo del hola mundo");
using (var w = Watch.Create("Cache GET"))
{
Parallel.For(0, 25000, i => fSto.Get("Tony - " + i));
Core.Log.InfoBasic("Time per item: {0}ms", w.GlobalElapsedMilliseconds / 10000);
}
using (var w = Watch.Create("Cache SET"))
{
Parallel.For(0, 25000, i =>
{
fSto.Set("Tony - " + i, sobj);
});
Core.Log.InfoBasic("Time per item: {0}ms", w.GlobalElapsedMilliseconds / 10000);
}
using (var w = Watch.Create("Cache GET"))
{
Parallel.For(0, 25000, i => fSto.Get("Tony - " + i));
Core.Log.InfoBasic("Time per item: {0}ms", w.GlobalElapsedMilliseconds / 10000);
}
}
private static void NormalTest(MQPairConfig mqConfig)
{
using (var mqServer = mqConfig.GetServer())
{
mqServer.RequestReceived += (s, e) =>
{
//Core.Log.Warning("Waiting...");
//try
//{
// await Task.Delay(int.MaxValue, e.ProcessResponseTimeoutCancellationToken);
//}
//catch { }
//Core.Log.Warning("Cancelled.");
//Core.Log.InfoBasic("Received");
e.Response.Body = new SerializedObject("Bienvenido!!!");
return(Task.CompletedTask);
};
mqServer.StartListeners();
using (var mqClient = mqConfig.GetClient())
{
var totalQ = 50000;
#region Sync Mode
Core.Log.Warning("Sync Mode Test, using Unique Response Queue");
using (var w = Watch.Create($"Hello World Example in Sync Mode for {totalQ} times"))
{
for (var i = 0; i < totalQ; i++)
{
var response = mqClient.SendAndReceiveAsync <string>("Hola mundo").WaitAsync();
}
Core.Log.InfoBasic("Total time: {0}", TimeSpan.FromMilliseconds(w.GlobalElapsedMilliseconds));
Core.Log.InfoBasic("Average time in ms: {0}. Press ENTER To Continue.", (w.GlobalElapsedMilliseconds / totalQ));
}
Console.ReadLine();
#endregion
totalQ = 50000;
#region Parallel Mode
Core.Log.Warning("Parallel Mode Test, using Unique Response Queue");
using (var w = Watch.Create($"Hello World Example in Parallel Mode for {totalQ} times"))
{
var oldContext = Core.ContextGroupName;
Task.WaitAll(
Enumerable.Range(0, totalQ).Select((i, mc) =>
{
Core.ContextGroupName = "Message: " + i;
return((Task)mc.SendAndReceiveAsync <string>("Hola mundo"));
}
, mqClient).ToArray());
Core.ContextGroupName = oldContext;
//Parallel.For(0, totalQ, i =>
//{
// var response = mqClient.SendAndReceiveAsync<string>("Hola mundo").WaitAndResults();
//});
Core.Log.InfoBasic("Total time: {0}", TimeSpan.FromMilliseconds(w.GlobalElapsedMilliseconds));
Core.Log.InfoBasic("Average time in ms: {0}. Press ENTER To Continue.", (w.GlobalElapsedMilliseconds / totalQ));
}
Console.ReadLine();
#endregion
}
mqConfig.ResponseOptions.ClientReceiverOptions.Parameters["SingleResponseQueue"] = "false";
using (var mqClient = mqConfig.GetClient())
{
var totalQ = 50000;
#region Sync Mode
Core.Log.Warning("Sync Mode Test, using Multiple Response Queue");
using (var w = Watch.Create($"Hello World Example in Sync Mode for {totalQ} times"))
{
for (var i = 0; i < totalQ; i++)
{
var response = mqClient.SendAndReceiveAsync <string>("Hola mundo").WaitAndResults();
}
Core.Log.InfoBasic("Total time: {0}", TimeSpan.FromMilliseconds(w.GlobalElapsedMilliseconds));
Core.Log.InfoBasic("Average time in ms: {0}. Press ENTER To Continue.", (w.GlobalElapsedMilliseconds / totalQ));
}
Console.ReadLine();
#endregion
#region Parallel Mode
Core.Log.Warning("Parallel Mode Test, using Multiple Response Queue");
using (var w = Watch.Create($"Hello World Example in Parallel Mode for {totalQ} times"))
{
Task.WaitAll(
Enumerable.Range(0, totalQ).Select((i, mc) => (Task)mc.SendAndReceiveAsync <string>("Hola mundo"), mqClient).ToArray()
);
//Parallel.For(0, totalQ, i =>
//{
// var response = mqClient.SendAndReceiveAsync<string>("Hola mundo").WaitAndResults();
//});
Core.Log.InfoBasic("Total time: {0}", TimeSpan.FromMilliseconds(w.GlobalElapsedMilliseconds));
Core.Log.InfoBasic("Average time in ms: {0}. Press ENTER To Continue.", (w.GlobalElapsedMilliseconds / totalQ));
}
Console.ReadLine();
#endregion
}
}
}
protected override async Task OnHandlerAsync(ParameterHandlerInfo info)
{
var serializer = new NBinarySerializer();
var service = new SampleProvider();
Core.Log.InfoBasic("Setting RPC Server");
var rpcServer = new RPCServer(new DefaultTransportServer(20050, serializer));
rpcServer.AddService(typeof(ISampleProvider), service);
await rpcServer.StartAsync().ConfigureAwait(false);
Core.Log.InfoBasic("Setting RPC Client");
var rpcClient = new RPCClient(new DefaultTransportClient("127.0.0.1", 20050, 1, serializer));
var hClient = await rpcClient.CreateDynamicProxyAsync <ISampleProvider>().ConfigureAwait(false);
var client = hClient.ActAs <ISampleProvider>();
double perItemMs;
try
{
var intEnumerable = await client.GetInt().ConfigureAwait(false);
}
catch (Exception ex)
{
Core.Log.Write(ex);
}
using (var watch = Watch.Create("GetSampleAsync"))
{
Sample res;
for (var i = 0; i < 100000; i++)
{
res = await client.GetSampleAsync().ConfigureAwait(false);
}
perItemMs = watch.GlobalElapsedMilliseconds / 100000;
}
Core.Log.InfoBasic($"GetSampleAsync per item: {perItemMs}ms");
Console.ReadLine();
Core.Log.InfoBasic("DelayTestAsync");
await client.DelayTestAsync().ConfigureAwait(false);
Core.Log.InfoBasic("GetSample");
var sample = client.GetSample();
Core.Log.InfoBasic("GetSample as Async");
var sampleSimAsync = ((dynamic)hClient).GetSample2Async().Result;
Console.ReadLine();
var pClient = await rpcClient.CreateProxyAsync <SampleProxy>().ConfigureAwait(false);
using (var watch = Watch.Create("GetSampleAsync"))
{
Sample res;
for (var i = 0; i < 100000; i++)
{
res = await pClient.GetSampleAsync().ConfigureAwait(false);
}
perItemMs = watch.GlobalElapsedMilliseconds / 100000;
}
Core.Log.InfoBasic($"GetSampleAsync per item: {perItemMs}ms");
Console.ReadLine();
Core.Log.InfoBasic("DelayTestAsync");
await pClient.DelayTestAsync().ConfigureAwait(false);
Core.Log.InfoBasic("GetSample");
var sample2 = pClient.GetSample();
rpcClient.Dispose();
await rpcServer.StopAsync().ConfigureAwait(false);
}
protected override void OnHandler(ParameterHandlerInfo info)
{
Core.Log.Warning("Starting MEMORY STREAMS TEST");
Core.Log.WriteEmptyLine();
Core.Log.InfoBasic("Press Enter to Start RecycleMemoryStream Test.");
Console.ReadLine();
var xbuffer = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
using (Watch.Create("RecycleMemoryStream"))
{
for (var m = 0; m < 50000; m++)
{
using (var rms = new RecycleMemoryStream())
{
for (var x = 0; x < 1; x++)
{
for (int i = 0; i < 10000; i++)
{
rms.Write(xbuffer, 0, xbuffer.Length);
}
}
rms.Position = 0;
for (var x = 0; x < 10; x++)
{
for (int i = 0; i < 2000; i++)
{
var bt = rms.ReadByte();
}
}
}
}
}
Core.Log.WriteEmptyLine();
Core.Log.InfoBasic("Press Enter to Start MemoryStream Test.");
Console.ReadLine();
using (Watch.Create("MemoryStream"))
{
for (var m = 0; m < 50000; m++)
{
using (var rms = new MemoryStream())
{
for (var x = 0; x < 1; x++)
{
for (var i = 0; i < 10000; i++)
{
rms.Write(xbuffer, 0, xbuffer.Length);
}
}
rms.Position = 0;
for (var x = 0; x < 10; x++)
{
for (var i = 0; i < 2000; i++)
{
var bt = rms.ReadByte();
}
}
}
}
}
Core.Log.WriteEmptyLine();
Core.Log.InfoBasic("Press Enter to Start CircularBufferStream Test. Press Enter Again to finish the test.");
Console.ReadLine();
using (var cbs = new CircularBufferStream(50))
{
var cts = new CancellationTokenSource();
Task.Run(async() =>
{
var i = 0;
while (!cts.Token.IsCancellationRequested)
{
i++;
cbs.WriteBytes(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7 });
if (i % 50 == 0)
{
Core.Log.InfoMedium("Write {0}", i);
}
await Task.Delay(1, cts.Token).ConfigureAwait(false);
}
});
Task.Run(async() =>
{
var i = 0;
var buffer = new byte[15];
while (!cts.Token.IsCancellationRequested)
{
i++;
cbs.Read(buffer, 0, 7);
if (i % 50 == 0)
{
Core.Log.InfoMedium("Read {0}", i);
}
await Task.Delay(1, cts.Token).ConfigureAwait(false);
}
});
Console.ReadLine();
cts.Cancel();
}
Core.Log.WriteEmptyLine();
Core.Log.InfoBasic("Press Enter to Start SharedMemoryStream Test. Press Enter Again to finish the test.");
Console.ReadLine();
using (var sharedms = new SharedMemoryStream("test", 2000))
{
var cts = new CancellationTokenSource();
Task.Run(async() =>
{
var i = 0;
while (!cts.Token.IsCancellationRequested)
{
i++;
sharedms.WriteBytes(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 });
if (i % 50 == 0)
{
Core.Log.InfoMedium("Write {0}", i);
}
await Task.Delay(1, cts.Token).ConfigureAwait(false);
}
});
Task.Run(async() =>
{
var i = 0;
var buffer = new byte[15];
while (!cts.Token.IsCancellationRequested)
{
i++;
sharedms.Read(buffer, 0, 7);
if (i % 50 == 0)
{
Core.Log.InfoMedium("Read {0}", i);
}
await Task.Delay(1, cts.Token).ConfigureAwait(false);
}
});
Console.ReadLine();
}
}
protected override async Task OnHandlerAsync(ParameterHandlerInfo info)
{
Core.Log.Warning("Starting RPC TEST");
var serializer = new NBinarySerializer();
var service = new MyService();
Core.Log.InfoBasic("Setting RPC Server");
var rpcServer = new RPCServer(new DefaultTransportServer(20050, serializer));
rpcServer.AddService(service);
await rpcServer.StartAsync().ConfigureAwait(false);
Core.Log.InfoBasic("Setting RPC Client");
var rpcClient = new RPCClient(new DefaultTransportClient("127.0.0.1", 20050, 1, serializer));
var sw = Stopwatch.StartNew();
//IHello test
Core.Log.InfoBasic("IHello test");
dynamic hClient = await rpcClient.CreateDynamicProxyAsync <IHello>().ConfigureAwait(false);
var rtest = (string)hClient.SayHi("MyName");
using (var watch = Watch.Create("IHello Time - SayHi | TestAsync"))
{
for (var i = 0; i < 5000; i++)
{
var rHClient = (string)hClient.SayHi("MyName");
}
for (var i = 0; i < 5000; i++)
{
var rHClient = await((Task <object>)hClient.TestAsync()).ConfigureAwait(false);
}
Core.Log.InfoBasic("Per Item: {0}", watch.GlobalElapsedMilliseconds / 10000);
}
//IMyService test
Core.Log.InfoBasic("IMyService test");
dynamic dClient = await rpcClient.CreateDynamicProxyAsync <IMyService>().ConfigureAwait(false);
using (var watch = Watch.Create("IMyService Time - GetAllAsync"))
{
for (var i = 0; i < 5000; i++)
{
var aLst = await((Task <object>)dClient.GetAllAsync()).ConfigureAwait(false);
}
Core.Log.InfoBasic("Per Item: {0}", watch.GlobalElapsedMilliseconds / 5000);
}
//Proxy class test
Core.Log.InfoBasic("Proxy class test");
var client = await rpcClient.CreateProxyAsync <MyServiceProxy>().ConfigureAwait(false);
using (var watch = Watch.Create("Proxy class Time - GetAllAsync"))
{
for (var i = 0; i < 5000; i++)
{
var resp = await client.GetAllAsync().ConfigureAwait(false);
}
Core.Log.InfoBasic("Per Item: {0}", watch.GlobalElapsedMilliseconds / 5000);
}
using (var watch = Watch.Create("Parallel GetAllAsync Time"))
{
var rAwait = await Enumerable.Range(0, 50)
.Select(i => client.GetAllAsync())
.ConfigureAwait(false);
Core.Log.InfoBasic("Per Item: {0}", watch.GlobalElapsedMilliseconds / 100);
}
//Event test
Core.Log.InfoBasic("Event test");
using (var watch = Watch.Create("Event Test - AddSimplePersona"))
{
client.OnAddSimplePersona += (s, e) =>
{
//Core.Log.Warning("On Add SimplePersona was fired!!!");
};
for (var i = 0; i < 5000; i++)
{
client.AddSimplePersona(new SimplePerson {
Lastname = "Test", Firstname = "Test"
});
}
Core.Log.InfoBasic("Per Item: {0}", watch.GlobalElapsedMilliseconds / 5000);
}
var sTime = sw.Elapsed;
Console.ReadLine();
Core.Log.Warning("All Rpc Requests on: {0}", sTime);
rpcClient.Dispose();
await rpcServer.StopAsync().ConfigureAwait(false);
Core.Log.InfoBasic("Test End.");
}
public static void Run(int min, int max, int numberElements, int capacity)
{
var randNum = new Random();
var randomNumbers = Enumerable.Repeat(0, numberElements).Select((i, vTuple) => vTuple.randNum.Next(vTuple.min, vTuple.max), (randNum, min, max)).ToArray();
var lru = new LRUCollection <int, long>(capacity);
var lfu = new LFUCollection <int, long>(capacity);
var lru2Q = new LRU2QCollection <int, long>(capacity);
var lru2QSimple = new LRU2QSimpleCollection <int, long>(capacity);
Core.Log.InfoBasic("Processing: {0} elements", numberElements);
Core.Log.InfoBasic("Collections Capacity: {0} elements", capacity);
Core.Log.InfoBasic("Random numbers from {0} to {1}", min, max);
Core.Log.WriteEmptyLine();
using (var w = Watch.Create("LFU Start", "LFU End"))
{
Parallel.ForEach(randomNumbers, item =>
{
var value = lfu.GetOrAdd(item, item);
if (value != item)
{
Core.Log.Warning("Bad value: " + value + " " + item);
}
});
var ms = w.GlobalElapsedMilliseconds / numberElements;
Core.Log.InfoDetail("LFU Hits: {0}", lfu.Hits);
Core.Log.InfoDetail("LFU Deletes: {0}", lfu.Deletes);
Core.Log.InfoDetail("LFU Inserts: {0}", lfu.Inserts);
Core.Log.InfoDetail("LFU ms per item: {0}ms", ms);
Core.Log.InfoDetail("LFU ns per item: {0}ns", ms * 1_000_000);
}
Thread.Sleep(1000);
Core.Log.WriteEmptyLine();
using (var w = Watch.Create("LRU Start", "LRU End"))
{
Parallel.ForEach(randomNumbers, item =>
{
var value = lru.GetOrAdd(item, item);
if (value != item)
{
Core.Log.Warning("Bad value: " + value + " " + item);
}
});
var ms = w.GlobalElapsedMilliseconds / numberElements;
Core.Log.InfoDetail("LRU Hits: {0}", lru.Hits);
Core.Log.InfoDetail("LRU Deletes: {0}", lru.Deletes);
Core.Log.InfoDetail("LRU Inserts: {0}", lru.Inserts);
Core.Log.InfoDetail("LRU ms per item: {0}ms", ms);
Core.Log.InfoDetail("LRU ns per item: {0}ns", ms * 1_000_000);
}
Thread.Sleep(1000);
Core.Log.WriteEmptyLine();
using (var w = Watch.Create("LRU2QSimple Start", "LRU2QSimple End"))
{
Parallel.ForEach(randomNumbers, item =>
{
var value = lru2QSimple.GetOrAdd(item, item);
if (value != item)
{
Core.Log.Warning("Bad value: " + value + " " + item);
}
});
var ms = w.GlobalElapsedMilliseconds / numberElements;
Core.Log.InfoDetail("LRU2QSimple Hits: {0}", lru2QSimple.Hits);
Core.Log.InfoDetail("LRU2QSimple Deletes: {0}", lru2QSimple.Deletes);
Core.Log.InfoDetail("LRU2QSimple Inserts: {0}", lru2QSimple.Inserts);
Core.Log.InfoDetail("LRU2QSimple ms per item: {0}ms", ms);
Core.Log.InfoDetail("LRU2QSimple ns per item: {0}ns", ms * 1_000_000);
}
Thread.Sleep(1000);
Core.Log.WriteEmptyLine();
using (var w = Watch.Create("LRU2Q Start", "LRU2Q End"))
{
Parallel.ForEach(randomNumbers, item =>
{
var value = lru2Q.GetOrAdd(item, item);
if (value != item)
{
Core.Log.Warning("Bad value: " + value + " " + item);
}
});
var ms = w.GlobalElapsedMilliseconds / numberElements;
Core.Log.InfoDetail("LRU2Q Hits: {0}", lru2Q.Hits);
Core.Log.InfoDetail("LRU2Q Deletes: {0}", lru2Q.Deletes);
Core.Log.InfoDetail("LRU2Q Inserts: {0}", lru2Q.Inserts);
Core.Log.InfoDetail("LRU2Q ms per item: {0}ms", ms);
Core.Log.InfoDetail("LRU2Q ns per item: {0}ns", ms * 1_000_000);
}
Thread.Sleep(1000);
Core.Log.WriteEmptyLine();
}
