private static unsafe void Execute(IRdReactive reactive, byte[] msg)
{
fixed(byte *p = msg)
{
var reader = UnsafeReader.CreateReader(p, msg.Length);
var rdid0 = RdId.Read(reader);
Assertion.Assert(reactive.RdId.Equals(rdid0), "Not equals: {0}, {1}", reactive.RdId, rdid0);
reactive.OnWireReceived(reader);
}
}
private static unsafe void Execute(IRdWireable reactive, byte[] msg)
{
fixed(byte *p = msg)
{
var reader = UnsafeReader.CreateReader(p, msg.Length);
var rdid0 = RdId.Read(reader);
Assertion.Assert(reactive.RdId.Equals(rdid0), "Not equals: {0}, {1}", reactive.RdId, rdid0);
using (reactive.Proto.Contexts.ReadContextsIntoCookie(reader))
reactive.OnWireReceived(reader);
}
}
protected unsafe void Receive(byte[] msg)
{
RdId id;
fixed (byte* p = msg)
{
var reader = UnsafeReader.CreateReader(p, msg.Length);
id = RdId.Read(reader);
}
Log.Root.Catch(() =>
{
MessageBroker.Dispatch(id, msg);
});
}
public void Test1()
{
UnsafeReader reader;
using (var cookie = UnsafeWriter.NewThreadLocalWriter())
{
cookie.Writer.Write(false);
cookie.Writer.Write(true);
cookie.Writer.Write((byte)0);
cookie.Writer.Write((byte)10);
cookie.Writer.Write('y');
cookie.Writer.Write('й');
cookie.Writer.Write(1234.5678m);
cookie.Writer.Write(1234.5678d);
cookie.Writer.Write((short)1000);
cookie.Writer.Write((int)1001);
cookie.Writer.Write((long)-1002);
cookie.Writer.Write((string)null);
cookie.Writer.Write("");
cookie.Writer.Write("abcd = yй");
cookie.Writer.Write((int[])(null));
cookie.Writer.Write(new int[0]);
cookie.Writer.Write(new[] { 1, 2, 3 });
cookie.Writer.Write(UnsafeWriter.StringDelegate, (string[])null);
cookie.Writer.Write(UnsafeWriter.StringDelegate, new string[0]);
cookie.Writer.Write(UnsafeWriter.StringDelegate, new[] { "a", "b", "c" });
cookie.Writer.Write(UnsafeWriter.StringDelegate, (List <string>)null);
cookie.Writer.Write(UnsafeWriter.StringDelegate, new List <string>());
cookie.Writer.Write(UnsafeWriter.StringDelegate, new List <string> {
"d", "e"
});
reader = UnsafeReader.CreateReader(cookie.Data, cookie.Count);
}
Assert.False(reader.ReadBoolean());
Assert.True(reader.ReadBoolean());
Assert.AreEqual(0, reader.ReadByte());
Assert.AreEqual(10, reader.ReadByte());
Assert.AreEqual('y', reader.ReadChar());
Assert.AreEqual('й', reader.ReadChar());
Assert.AreEqual(1234.5678m, reader.ReadDecimal());
Assert.AreEqual(1234.5678d, reader.ReadDouble(), 1e-6);
Assert.AreEqual(1000, reader.ReadInt16());
Assert.AreEqual(1001, reader.ReadInt32());
Assert.AreEqual(-1002, reader.ReadInt64());
Assert.Null(reader.ReadString());
Assert.AreEqual("", reader.ReadString());
Assert.AreEqual("abcd = yй", reader.ReadString());
Assert.Null(reader.ReadIntArray());
Assert.AreEqual(new int[0], reader.ReadIntArray());
Assert.AreEqual(new[] { 1, 2, 3 }, reader.ReadIntArray());
Assert.Null(reader.ReadArray(UnsafeReader.StringDelegate));
Assert.AreEqual(new string[0], reader.ReadArray(UnsafeReader.StringDelegate));
Assert.AreEqual(new[] { "a", "b", "c" }, reader.ReadArray(UnsafeReader.StringDelegate));
Assert.Null(reader.ReadCollection(UnsafeReader.StringDelegate, n => new List <string>(n)));
CollectionAssert.AreEqual(new List <string>(), reader.ReadCollection(UnsafeReader.StringDelegate, n => new List <string>(n)));
CollectionAssert.AreEqual(new List <string> {
"d", "e"
}, reader.ReadCollection(UnsafeReader.StringDelegate, n => new List <string>(n)));
}
public unsafe void TestReprocess()
{
long prev = 0;
ByteBufferAsyncProcessor buffer = null;
List <long> log = new List <long>();
buffer = new ByteBufferAsyncProcessor("TestAsyncProcessor", 8,
delegate(byte[] data, int offset, int len, ref long seqN)
{
try
{
fixed(byte *b = data)
{
long l = UnsafeReader.CreateReader(b, 8).ReadLong();
if (seqN != 0)
{
Assert.AreEqual(l, seqN);
}
seqN = l;
log.Add(l);
Assert.True(l > prev);
prev = l;
}
}
catch (Exception e)
{
Log.Root.Error(e);
}
});
buffer.ShrinkIntervalMs = 10;
buffer.Start();
PutLong(buffer, 1);
PutLong(buffer, 2);
PutLong(buffer, 3);
PutLong(buffer, 4);
SpinWait.SpinUntil(() => buffer.AllDataProcessed);
Assert.AreEqual(new List <int> {
1, 2, 3, 4
}, log);
buffer.Acknowledge(2);
prev = 2;
buffer.ReprocessUnacknowledged();
PutLong(buffer, 5);
SpinWait.SpinUntil(() => buffer.AllDataProcessed);
Assert.AreEqual(new List <int> {
1, 2, 3, 4, 3, 4, 5
}, log);
buffer.Acknowledge(5);
buffer.ReprocessUnacknowledged();
SpinWait.SpinUntil(() => buffer.AllDataProcessed);
Assert.AreEqual(new List <int> {
1, 2, 3, 4, 3, 4, 5
}, log);
}
public unsafe void StressTestWithAck()
{
// LogLog.SeverityFilter = LoggingLevel.VERBOSE;
// LogLog.RecordsChanged += record => { Console.WriteLine(record.Format(true)); };
long prev = 0;
ByteBufferAsyncProcessor buffer = null;
buffer = new ByteBufferAsyncProcessor("TestAsyncProcessor", 8,
delegate(byte[] data, int offset, int len, ref long seqN)
{
long l = 0;
Log.Root.Catch(() =>
{
fixed(byte *b = data)
{
l = UnsafeReader.CreateReader(b, 8).ReadLong();
Assert.True(l > prev);
prev = l;
if (l % 1 == 0)
{
Ack(l);
}
}
});
seqN = l;
});
buffer.ShrinkIntervalMs = 10;
buffer.Start();
void Ack(long seqn)
{
buffer?.Acknowledge(seqn);
}
var start = Environment.TickCount;
bool Until() => Environment.TickCount - start < 1000;
long next = 0;
var tasks = new List <Task>();
for (int i = 0; i < 4; i++)
{
tasks.Add(Task.Run(() =>
{
var rnd = new Random();
while (Until())
{
lock (tasks)
{
using (var cookie = UnsafeWriter.NewThreadLocalWriter())
{
cookie.Writer.Write(++next);
buffer.Put(cookie);
}
}
if (rnd.Next(1000) < 1)
{
Thread.Sleep(1);
}
if (rnd.Next(1000) < 5)
{
buffer.Clear();
}
}
}));
}
Task.WaitAll(tasks.ToArray());
// Console.WriteLine(next);
// Console.WriteLine(buffer.ChunkCount);
}