public unsafe static void BenchUnsafe()
{
var count = 10000000;
var from = new byte[1024];
var to = new byte[1024];
var w = Stopwatch.StartNew();
fixed(byte *src = &from[0], dst = &to[0])
{
byte *dt = dst;
for (int n = 0; n < 100; n++)
{
for (int i = 0; i < count; i++)
{
FastBuffer.UnsafeBlockCopy(src, dst, n);
}
w.Stop();
Console.WriteLine($"FastBuffer.UnsafeBlockCopy {n}bytes cost:{w.ElapsedMilliseconds}");
w = Stopwatch.StartNew();
for (int i = 0; i < count; i++)
{
Buffer.MemoryCopy(src, dt, n, n);
}
w.Stop();
Console.WriteLine($"Buffer.MemoryCopy {n}bytes cost:{w.ElapsedMilliseconds}");
Console.WriteLine($"----------------------------{n}-------------------");
}
}
}
public void FastBufferCopy()
{
for (int i = 0; i < N; i++)
{
FastBuffer.BlockCopy(bufferFrom, 0, bufferTo, 0, Size);
}
}
public unsafe void UnsafeFastBufferCopyFixed()
{
fixed(byte *src = &bufferFrom[0], dst = &bufferTo[0])
{
for (int i = 0; i < N; i++)
{
FastBuffer.UnsafeBlockCopy(src, dst, Size);
}
}
}
public void SerializeTo(Stream stream)
{
var bw = new BinaryWriter(stream);
bw.Write(PacketId);
bw.Write(SeqGuid.ToByteArray());
bw.Write(SeqIdx);
bw.Write(IsLast);
bw.Write(SeqSize);
bw.Write(FastBuffer.SliceBuffer(SeqBuffer, 0, SeqSize));
}
public void test_buffer_position()
{
const int size = 15;
const int data = 123;
var buffer = new FastBuffer(size);
Assert.AreEqual(0, buffer.GetPosition());
buffer.Do(a => a.Write(data));
Assert.AreEqual(sizeof(int), buffer.GetPosition());
}
public void test_fast_buffer()
{
var expected = Utility.GetTestArray(16);
var buffer = new FastBuffer(expected);
Assert.AreEqual(expected.Length, buffer.GetCapacity());
Assert.AreSame(expected, buffer.Get());
Assert.IsTrue(buffer.Do(a => Utility.CheckTestArray(a, expected)));
Assert.AreEqual(expected.Length, buffer.GetPosition());
}
public void TestCopy()
{
for (int i = 0; i < 1024; i++)
{
var src = new byte[i];
var dst = new byte[i];
var rd = new Random(Guid.NewGuid().GetHashCode());
rd.NextBytes(src);
FastBuffer.BlockCopy(src, 0, dst, 0, src.Length);
for (int n = 0; n < i; n++)
{
Assert.AreEqual(src[n], dst[n]);
}
}
}
public void test_buffer_resize()
{
const int size1 = 15;
const int size2 = 25;
var buffer = new FastBuffer(size1);
Assert.AreEqual(size1, buffer.GetCapacity());
buffer.Reset(size2);
Assert.AreEqual(size2, buffer.GetCapacity());
buffer.Reset();
Assert.AreEqual(size2, buffer.GetCapacity());
}
public static void TestCopy()
{
for (int i = 0; i < 1024; i++)
{
byte[] src = new byte[i];
for (int n = 0; n < i; n++)
{
src[n] = (byte)n;
}
byte[] dst = new byte[i];
FastBuffer.BlockCopy(src, 0, dst, 0, src.Length);
for (int n = 0; n < i; n++)
{
if (src[n] != dst[n])
{
Console.WriteLine("error:" + i);
}
}
}
Console.WriteLine("finish");
}
private static IEnumerable <ISequencePacket> CreateSequence(byte[] newBuff, int buffSize, int modRest, int origSize)
{
var idx = 0;
for (var i = 0; i < newBuff.Length - modRest; i += buffSize, idx++)
{
var seqPacket = new SequencePacket
{
SeqIdx = (i / buffSize),
SeqBuffer = FastBuffer.SliceBuffer(newBuff, i, buffSize),
SeqSize = buffSize,
IsLast = false
};
yield return(seqPacket);
}
yield return(new SequencePacket
{
SeqIdx = idx,
SeqBuffer = FastBuffer.SliceBuffer(newBuff, idx * buffSize, modRest),
SeqSize = modRest,
IsLast = true
});
}
public void WritePacketToSocket(IDataPacket data, IChannel senderChannel, Guid guid, BufferObject buffObj,
Socket sock, AsyncCallback sendCallback, SocketOperationContext operationCtx)
{
var ms = new MemoryStream();
data.SerializeTo(ms);
sbyte integrityHashSize = 0;
if (senderChannel != null)
{
switch (senderChannel.IntegrityHash)
{
case Security.PacketIntegrityHash.Sha256:
integrityHashSize = 32;
break;
case Security.PacketIntegrityHash.Crc32:
integrityHashSize = 4;
break;
case Security.PacketIntegrityHash.Elf32:
integrityHashSize = 4;
break;
}
}
var headerSize = 1 + (operationCtx != null ? 32 : 0) +
(senderChannel != null && senderChannel.EnsurePacketIntegrity ? integrityHashSize + 2 : 1);
var sendBuff = new byte[ms.Length + headerSize + 4];
FastBuffer.MemCpy(BitConverter.GetBytes(headerSize + ms.Length), 0, sendBuff, 0, 4);
sendBuff[4] = operationCtx == null ? ((byte)0x0) : ((byte)0x1);
sendBuff[5] = senderChannel != null && senderChannel.EnsurePacketIntegrity ? (byte)0x1 : (byte)0x0;
if (senderChannel != null && senderChannel.EnsurePacketIntegrity)
{
sendBuff[6] = (byte)senderChannel.IntegrityHash;
}
if (operationCtx != null)
{
FastBuffer.MemCpy(operationCtx.OperationGuid.ToByteArray(), 0, sendBuff, 6, 16);
FastBuffer.MemCpy(guid.ToByteArray(), 0, sendBuff, 22, 16);
}
var tmpBuff = new byte[ms.Length];
ms.Seek(0, SeekOrigin.Begin);
ms.Read(tmpBuff, 0, tmpBuff.Length);
FastBuffer.MemCpy(tmpBuff, 0, sendBuff, operationCtx != null ? 38 : 6, tmpBuff.Length);
var sendObj = new Peer.Peer.SendObject {
Channel = senderChannel, Packet = data
};
if (sock.Connected)
{
sock.BeginSend(sendBuff, 0, sendBuff.Length, 0, sendCallback, sendObj);
}
}
private void ReadDataCallback(IAsyncResult res)
{
var buffObj = (BufferObject)res.AsyncState;
buffObj.ReadLen = ChannelSocket.EndReceive(res);
buffObj.TotalRead += buffObj.ReadLen;
buffObj.CompleteBuff.AddRange(FastBuffer.SliceBuffer(buffObj.RecBuff, 0, buffObj.ReadLen));
if (buffObj.CompleteBuff.Count < buffObj.PacketSize)
{
// keep reading
if (buffObj.BufferSize < (buffObj.PacketSize - buffObj.CompleteBuff.Count))
{
ChannelSocket.BeginReceive(buffObj.RecBuff, 0, buffObj.BufferSize, 0, ReadDataCallback, buffObj);
}
else
{
ChannelSocket.BeginReceive(buffObj.RecBuff, 0, (buffObj.PacketSize - buffObj.CompleteBuff.Count),
0, ReadDataCallback, buffObj);
}
}
else
{
// full message was received
var dataBuff = buffObj.CompleteBuff.ToArray();
var isOperation = BitConverter.ToBoolean(dataBuff, 0);
int internalId;
var operationGuid = Guid.Empty;
var connectionGuid = Guid.Empty;
if (isOperation)
{
operationGuid = new Guid(dataBuff.Slice(2, 16));
Debug.Print("Received operation guid: " + operationGuid);
connectionGuid = new Guid(dataBuff.Slice(18, 16));
internalId = BitConverter.ToInt32(dataBuff, 34);
}
else
{
internalId = BitConverter.ToInt32(dataBuff, 2);
}
if (_internalPacketTbl.ContainsKey(internalId))
{
var packet = (IDataPacket)Activator.CreateInstance(_internalPacketTbl[internalId]);
var ms = new MemoryStream(dataBuff)
{
Position = 2
};
packet.DeserializeFrom(ms);
if (packet is SynchronizePacket)
{
HandleSynchronizePacket(packet as SynchronizePacket);
}
else if (packet is SequenceInitPacket)
{
HandleSequenceInitPacket(packet as SequenceInitPacket);
}
else if (packet is SequencePacket)
{
HandleSequencePacket(packet as SequencePacket);
}
else if (packet is PeerRelocationRequestPacket)
{
HandleRelocationPacket(packet as PeerRelocationRequestPacket);
}
else if (packet is SocketOperationRequest)
{
HandleSocketOperationPacket(packet as SocketOperationRequest);
}
}
else if (ActiveSocketOperations.ContainsKey(operationGuid))
{
using (var ms = new MemoryStream(dataBuff)
{
Position = 34
})
{
var packet = PacketProcessor.ParsePacket(ms);
packet.DeserializeFrom(ms);
ActiveSocketOperations[operationGuid].PacketReceived(packet, this);
}
}
else
{
RawPacketReceived(dataBuff);
}
buffObj.ReadLen = 0;
buffObj.CompleteBuff.Clear();
buffObj.PacketSize = 0;
ChannelSocket.BeginReceive(buffObj.RecBuff, 0, 4, 0, ReadLengthCallback, buffObj);
}
}
public unsafe static void WriteUnsafe(string name, char[] buffer, int position)
{
fixed (char* src = name, dst = &buffer[position])
FastBuffer.UnsafeBlockCopy((byte*)src, (byte*)dst, name.Length * 2);
}
public unsafe static void WriteUnsafe(char* tsrc, char* tdst, int size)
{
FastBuffer.UnsafeBlockCopy((byte*)tsrc, (byte*)tdst, size);
}
