void OnReadUnix(UVBuffer.Unix buffer, IntPtr bytesAvaliable)
{
long bytesRead = bytesAvaliable.ToInt64();
if (bytesRead == 0)
{
return;
}
else if (bytesRead < 0)
{
var error = UVException.ErrorCodeToError((int)bytesRead);
if (error == UVError.EOF)
{
OnEndOfStream();
Dispose();
}
else
{
Dispose();
throw new UVException((int)bytesRead);
}
}
else
{
// This can be a Span<byte> but the samples pass it directly to TryWrite which
// needs to unpack the data and turn it back into either an array or native memory
var readSlice = new UnsafeMemory <byte>((byte *)buffer.Buffer, (int)bytesRead);
OnReadCompleted(readSlice);
buffer.Dispose();
}
}
protected override unsafe void Execute(Action <IntPtr, IntPtr, UIntPtr> fn, out string result, out string expected)
{
const int cnt = 17;
var d = new uint[] { 0x00000000, 0x10101010, 0x20100804, 0x30200003, 0x40204040, 0x5000004D, 0x60302E2C, 0x706F6E6D, 0x807F4F2F, 0x90349001, 0xA0010203, 0xB03204AB, 0xC023AFBD, 0xD0D0D0C0, 0xE0AABBCC, 0xFFFFFFFF, 0xF8F4F2F1 };
var s = new uint[] { 0xE0E0E0E0, 0xA0008080, 0x341F1E1A, 0xFEFEFEFE, 0x80302010, 0x49490A0B, 0x998F7798, 0x00000000, 0x01010101, 0xA0264733, 0xBAB0B1B9, 0xFF000000, 0xDAB0A0C1, 0xE0BACFDA, 0x99887766, 0xFFFFFF80, 0xEE0A5FEC };
var rawptr = Marshal.AllocHGlobal((cnt + 3) * sizeof(uint) + 8);
var pdst = new IntPtr(16 * (((long)rawptr + 15) / 16));
rawptr = Marshal.AllocHGlobal((cnt + 3) * sizeof(uint) + 8);
var psrc = new IntPtr(16 * (((long)rawptr + 15) / 16));
UnsafeMemory.Copy(pdst, Marshal.UnsafeAddrOfPinnedArrayElement(d, 0), cnt * sizeof(uint));
UnsafeMemory.Copy(psrc, Marshal.UnsafeAddrOfPinnedArrayElement(s, 0), cnt * sizeof(uint));
var e = new uint[cnt];
for (var z = 0; z < cnt; z++)
{
e[z] = BlendSrcOver(d[z], s[z]);
}
fn(pdst, psrc, (UIntPtr)cnt);
UnsafeMemory.Copy(Marshal.UnsafeAddrOfPinnedArrayElement(d, 0), pdst, cnt * sizeof(uint));
result = string.Join(",", d);
expected = string.Join(",", e);
}
public void Dispose()
{
foreach (var pointer in _dataAllocations)
{
UnsafeMemory.Free(pointer);
}
}
void OnReadCompleted(UnsafeMemory <byte> bytesRead)
{
if (ReadCompleted != null)
{
ReadCompleted(bytesRead);
}
}
public unsafe void TryWrite(UnsafeMemory <byte> data)
{
// This can work with Span<byte> because it's synchronous but we need pinning support
EnsureNotDisposed();
void *pointer;
if (!data.TryGetPointer(out pointer))
{
throw new InvalidOperationException("Pointer not available");
}
IntPtr ptrData = (IntPtr)pointer;
var length = data.Length;
if (IsUnix)
{
var buffer = new UVBuffer.Unix(ptrData, (uint)length);
UVException.ThrowIfError(UVInterop.uv_try_write(Handle, &buffer, 1));
}
else
{
var buffer = new UVBuffer.Windows(ptrData, (uint)length);
UVException.ThrowIfError(UVInterop.uv_try_write(Handle, &buffer, 1));
}
}
public BinaryVarValue(UnsafeMemory <BitState> bits, List <VarDef> variables, bool isValidBinary)
{
Debug.Assert(isValidBinary == bits.Span.IsAllBinary());
this.BitSlice = bits;
this.Vars = variables;
this.IsValidBinary = isValidBinary;
}
public void SlicePointerBackedMemory()
{
unsafe
{
var data = new byte[10];
for (int i = 0; i < 10; i++)
{
data[i] = (byte)i;
}
fixed(byte *ptr = data)
{
var memory = new UnsafeMemory <byte>(ptr, data.Length);
var slice = memory.Slice(0, 5);
var span = slice.Span;
for (int i = 0; i < 5; i++)
{
Assert.Equal(i, span[i]);
}
var subSlice = slice.Slice(2, 1);
Assert.Equal(2, subSlice.Span[0]);
}
}
}
public void Destroy()
{
if (data != null)
{
UnsafeMemory.Free(data);
data = null;
}
if (ffpipe != null)
{
ffpipe.Close();
ffpipe = null;
}
if (keyColors != null)
{
UnsafeMemory.Free(keyColors);
}
if (frame != null)
{
UnsafeMemory.Free(frame);
frame = null;
}
if (emptyFrame != null)
{
UnsafeMemory.Free(emptyFrame);
emptyFrame = null;
}
//if (renderPush != null)
//{
// renderPush.Wait();
//}
keyColors = null;
}
public unsafe void TryWrite(UnsafeMemory<byte> data)
{
// This can work with Span<byte> because it's synchronous but we need pinning support
EnsureNotDisposed();
void* pointer;
if (!data.TryGetPointer(out pointer))
{
throw new InvalidOperationException("Pointer not available");
}
IntPtr ptrData = (IntPtr)pointer;
var length = data.Length;
if (IsUnix)
{
var buffer = new UVBuffer.Unix(ptrData, (uint)length);
UVException.ThrowIfError(UVInterop.uv_try_write(Handle, &buffer, 1));
}
else
{
var buffer = new UVBuffer.Windows(ptrData, (uint)length);
UVException.ThrowIfError(UVInterop.uv_try_write(Handle, &buffer, 1));
}
}
public void Visit(Node node)
{
if (!node.Shared)
{
UnsafeMemory.Copy(Dst + node.Offset, node.Data, DataSize);
}
}
internal void Put(Node newNode)
{
var dataSize = DataSize;
Length++;
if (Root == null)
{
Root = newNode;
return;
}
var node = Root;
var stack = new Node[HeightLimit];
var top = 0;
int dir;
// Find a spot and save the stack.
for (; ;)
{
stack[top++] = node;
dir = UnsafeMemory.Compare(node.Data, newNode.Data, dataSize) < 0 ? 1 : 0;
var link = node.Link[dir];
if (link == null)
{
break;
}
node = link;
}
// Link and rebalance.
node.Link[dir] = newNode;
while (top > 0)
{
// Which child?
node = stack[--top];
if (top != 0)
{
dir = stack[top - 1].Link[1] == node ? 1 : 0;
}
node = SkewNode(node);
node = SplitNode(node);
// Fix the parent.
if (top != 0)
{
stack[top - 1].Link[dir] = node;
}
else
{
Root = node;
}
}
}
public void GetArrayOrPointer()
{
var original = new int[] { 1, 2, 3 };
ArraySegment <int> array;
UnsafeMemory <int> slice;
slice = new UnsafeMemory <int>(original, 1, 2);
Assert.True(slice.TryGetArray(out array));
Assert.Equal(2, array.Array[array.Offset + 0]);
Assert.Equal(3, array.Array[array.Offset + 1]);
slice = new UnsafeMemory <int>(original, 0, 3);
Assert.True(slice.TryGetArray(out array));
Assert.Equal(1, array.Array[array.Offset + 0]);
Assert.Equal(2, array.Array[array.Offset + 1]);
Assert.Equal(3, array.Array[array.Offset + 2]);
slice = new UnsafeMemory <int>(original, 0, 0);
Assert.True(slice.TryGetArray(out array));
Assert.Equal(0, array.Offset);
Assert.Equal(original, array.Array);
Assert.Equal(0, array.Count);
unsafe
{
fixed(int *pBytes = original)
{
slice = new UnsafeMemory <int>(pBytes, 1);
Assert.False(slice.TryGetArray(out array));
void *p;
Assert.True(slice.TryGetPointer(out p));
Assert.True(null != p);
Assert.Equal(null, array.Array);
Assert.Equal(0, array.Offset);
Assert.Equal(0, array.Count);
}
}
unsafe
{
fixed(int *pBytes = original)
{
var roSlice = new ReadOnlySpan <int>(pBytes, 1);
Assert.False(slice.TryGetArray(out array));
void *p;
Assert.True(slice.TryGetPointer(out p));
Assert.True(null != p);
Assert.Equal(null, array.Array);
Assert.Equal(0, array.Offset);
Assert.Equal(0, array.Count);
}
}
}
public void Serialize(ref MessagePackWriter writer, ref int idx, CultureInfo value, IFormatterResolver formatterResolver)
{
if (value != null)
{
var encodedBytes = MessagePackBinary.GetEncodedStringBytes(value.Name);
UnsafeMemory.WriteRaw(ref writer, encodedBytes, ref idx);
return;
}
writer.WriteNil(ref idx);
}
public void WriteRaw(byte[] rawValue)
{
#if NETSTANDARD
UnsafeMemory.WriteRaw(ref this, rawValue);
#else
BinaryUtil.EnsureCapacity(ref buffer, offset, rawValue.Length);
Buffer.BlockCopy(rawValue, 0, buffer, offset, rawValue.Length);
offset += rawValue.Length;
#endif
}
public void TryGetPointerReturnsFalseIfNotPinned()
{
var data = new byte[10];
var memory = new UnsafeMemory <byte>(data, 0, data.Length);
unsafe
{
void *pointer;
Assert.False(memory.TryGetPointer(out pointer));
}
}
static void RunLoop(bool log)
{
var loop = new UVLoop();
var listener = new TcpListener(s_ipAddress, s_port, loop);
var formatter = new ArrayFormatter(512, EncodingData.InvariantUtf8);
listener.ConnectionAccepted += (Tcp connection) =>
{
if (log)
{
Console.WriteLine("connection accepted");
}
connection.ReadCompleted += (data) =>
{
if (log)
{
unsafe
{
var requestString = new Utf8String(data);
Console.WriteLine("*REQUEST:\n {0}", requestString.ToString());
}
}
formatter.Clear();
formatter.Append("HTTP/1.1 200 OK");
formatter.Append("\r\n\r\n");
formatter.Append("Hello World!");
if (log)
{
formatter.Format(" @ {0:O}", DateTime.UtcNow);
}
var segment = formatter.Formatted;
unsafe
{
fixed(byte *p = segment.Array)
{
var response = new UnsafeMemory <byte>(segment.Array, segment.Offset, segment.Count, pointer: p);
connection.TryWrite(response);
}
}
connection.Dispose();
};
connection.ReadStart();
};
listener.Listen();
loop.Run();
}
public void Serialize(ref MessagePackWriter writer, ref int idx, T value, IFormatterResolver formatterResolver)
{
if (!valueNameMapping.TryGetValue(value, out string name))
{
name = value.ToString(); // fallback for flags etc, But Enum.ToString is too slow.
}
var encodedName = MessagePackBinary.GetEncodedStringBytes(name);
UnsafeMemory.WriteRaw(ref writer, encodedName, ref idx);
}
internal void Fill(Pointer dst)
{
UnsafeMemory.Fill(dst, 0, Size);
var filler = new ConstPoolFill(dst, 1);
foreach (var t in _tree)
{
t.Iterate(filler);
filler.DataSize <<= 1;
}
}
public void TryGetPointerReturnsTrueIfPointerUsed()
{
unsafe
{
IntPtr raw = Marshal.AllocHGlobal(10);
var memory = new UnsafeMemory <byte>((void *)raw, 10);
void * pointer;
Assert.True(memory.TryGetPointer(out pointer));
Assert.True(raw.ToPointer() == pointer);
Marshal.FreeHGlobal(raw);
}
}
internal static Node NewNode(Pointer data, int size, int offset, bool shared)
{
var node = new Node();
node.Link[0] = null;
node.Link[1] = null;
node.Level = 1;
node.Shared = shared;
node.Offset = offset;
node.Data = UnsafeMemory.Allocate(size);
UnsafeMemory.Copy(node.Data, data, size);
return(node);
}
public void MemoryCtorThrowsIfPtrDoesNotMatchArrayArgs()
{
Assert.Throws <ArgumentException>(() =>
{
unsafe
{
var data = new byte[10];
fixed(byte *ptr = data)
{
var memory = new UnsafeMemory <byte>(data, 0, data.Length, ptr + 1);
}
}
});
}
public void TryGetPointerReturnsTrueIfArrayAndPrePinned()
{
unsafe
{
var data = new byte[10];
fixed(byte *ptr = data)
{
var memory = new UnsafeMemory <byte>(data, 0, data.Length, ptr);
void *pointer;
Assert.True(memory.TryGetPointer(out pointer));
Assert.True(ptr == pointer);
}
}
}
private DataNode CreateDataNode(Pointer data, int size)
{
var clonedData = UnsafeMemory.Allocate(size);
if (clonedData == Pointer.Invalid)
{
return(null);
}
_dataAllocations.Add(clonedData);
if (data != Pointer.Invalid)
{
UnsafeMemory.Copy(clonedData, data, size);
}
return(new DataNode(clonedData, size));
}
private static void RunTest()
{
const int cnt = 17;
var d = new uint[] { 0x00000000, 0x10101010, 0x20100804, 0x30200003, 0x40204040, 0x5000004D, 0x60302E2C, 0x706F6E6D, 0x807F4F2F, 0x90349001, 0xA0010203, 0xB03204AB, 0xC023AFBD, 0xD0D0D0C0, 0xE0AABBCC, 0xFFFFFFFF, 0xF8F4F2F1 };
var s = new uint[] { 0xE0E0E0E0, 0xA0008080, 0x341F1E1A, 0xFEFEFEFE, 0x80302010, 0x49490A0B, 0x998F7798, 0x00000000, 0x01010101, 0xA0264733, 0xBAB0B1B9, 0xFF000000, 0xDAB0A0C1, 0xE0BACFDA, 0x99887766, 0xFFFFFF80, 0xEE0A5FEC };
var rawptr = Marshal.AllocHGlobal((cnt + 3) * sizeof(uint) + 8);
var pdst = new IntPtr(16 * (((long)rawptr + 15) / 16));
rawptr = Marshal.AllocHGlobal((cnt + 3) * sizeof(uint) + 8);
var psrc = new IntPtr(16 * (((long)rawptr + 15) / 16));
UnsafeMemory.Copy(pdst, Marshal.UnsafeAddrOfPinnedArrayElement(d, 0), cnt * sizeof(uint));
UnsafeMemory.Copy(psrc, Marshal.UnsafeAddrOfPinnedArrayElement(s, 0), cnt * sizeof(uint));
var t1 = new ExecutionTimer();
var t2 = new ExecutionTimer();
t1.Start();
for (int i = 0; i < 1000000; i++)
{
var e = new uint[cnt];
for (var z = 0; z < cnt; z++)
{
e[z] = BlendSrcOver(d[z], s[z]);
}
}
t1.Stop();
var tt1 = t1.Milliseconds;
var fn = Make();
t2.Start();
for (int i = 0; i < 1000000; i++)
{
fn(pdst, psrc, (UIntPtr)cnt);
}
t2.Stop();
var tt2 = t2.Milliseconds;
Console.WriteLine("NET: " + tt1);
Console.WriteLine("Asm: " + tt2);
Console.ReadKey();
UnsafeMemory.Copy(Marshal.UnsafeAddrOfPinnedArrayElement(d, 0), pdst, cnt * sizeof(uint));
}
internal static void VisitScalarValueChange(ReadOnlyMemory <byte> text, IDToVarDef idToVariable, SimPass pass, BitAllocator bitAlloc)
{
UnsafeMemory <BitState> bits = bitAlloc.GetBits(1);
BitState bit = ToBitState(text.Span[0]);
var id = text.Slice(1);
bits.Span[0] = bit;
if (idToVariable.TryGetValue(id, out List <VarDef>?variable))
{
pass.BinValue = new BinaryVarValue(bits, variable, ((int)bit & 0b10) == 0);
}
else
{
throw new Exception($"Unknown variable identifier: {id}");
}
}
internal static unsafe (UnsafeMemory <BitState> bits, bool isValidBinary) ToBitStates(ReadOnlySpan <byte> valueText, BitAllocator bitAlloc)
{
UnsafeMemory <BitState> bitsMem = bitAlloc.GetBits(valueText.Length);
Span <BitState> bits = bitsMem.Span;
ulong isValidBinary = 0;
int index = 0;
if (Ssse3.IsSupported && bits.Length >= Vector128 <byte> .Count)
{
int vecBitCount = bits.Length / Vector128 <byte> .Count;
fixed(BitState *bitsPtr = bits)
{
fixed(byte *textPtr = valueText)
{
Vector128 <ulong> isValidBin = Vector128 <ulong> .Zero;
for (; index < vecBitCount; index++)
{
var charText = Avx.LoadVector128(textPtr + index * Vector128 <byte> .Count);
var byteText = Avx.Shuffle(charText, shuffleIdxs);
var firstBit = Avx.And(onlyFirstBit, Avx.Or(byteText, Avx.ShiftRightLogical(byteText.AsInt32(), 1).AsByte()));
var secondBit = Avx.And(onlySecondBit, Avx.ShiftRightLogical(byteText.AsInt32(), 5).AsByte());
var bytesAsBitStates = Avx.Or(firstBit, secondBit);
Avx.Store((byte *)bitsPtr + bits.Length - (index + 1) * Vector128 <byte> .Count, bytesAsBitStates);
isValidBin = Avx.Or(isValidBin, secondBit.AsUInt64());
}
isValidBinary = isValidBin.GetElement(0) | isValidBin.GetElement(1);
}
}
index *= Vector128 <byte> .Count;
}
for (; index < bits.Length; index++)
{
BitState bit = ToBitState(valueText[index]);
bits[bits.Length - index - 1] = bit;
isValidBinary |= (uint)bit & 0b10;
}
return(bitsMem, isValidBinary == 0);
}
public int Send(UnsafeMemory <byte> buffer)
{
// This can work with Span<byte> because it's synchronous but we need pinning support
unsafe {
ArraySegment <byte> segment;
if (buffer.TryGetArray(out segment))
{
return(Send(segment));
}
else
{
void *pointer;
buffer.TryGetPointer(out pointer);
return(SendPinned(new IntPtr(pointer), buffer.Length));
}
}
}
internal Node Get(Pointer data)
{
var node = Root;
var dataSize = DataSize;
while (node != null)
{
var c = UnsafeMemory.Compare(node.Data, data, dataSize);
if (c == 0)
{
return(node);
}
node = node.Link[c < 0 ? 1 : 0];
}
return(null);
}
public void Clear()
{
//for (int i = 0; i != 128; ++i)
// keycolor[i] = (i % 12) switch
// {
// 1 or 3 or 6 or 8 or 10 => 0xFF000000,
// _ => 0xFFFFFFFF,
// };
fixed(uint *p = keycolor) UnsafeMemory.Copy(p, keyColors, 512);
//for (int i = keyh; i < Height; ++i)
//{
// //for (int j = 0; j < Width; ++j)
// //data[i][j] = 0xFF000000;
// UnsafeMemory.Copy(data[i], emptyData, (ulong)Width * 4);
//}
UnsafeMemory.Copy(frame, emptyFrame, (ulong)(Width * Height) * 4);
}
static void SerializeWithLengthPrefixExt <T>(Stream stream, T data, IFormatterResolver resolver)
{
const int ExtTypeCode = 111; // sample ext code
var serializedData = MessagePackSerializer.Serialize(data, resolver);
var tmp = MessagePackSerializer.Deserialize <T>(serializedData, resolver);
var dataSize = serializedData.Length;
var idx = 0;
var writer = new MessagePackWriter(16);
var headerLength = MessagePackBinary.GetExtensionFormatHeaderLength(dataSize);
writer.Ensure(idx, headerLength + dataSize);
writer.WriteExtensionFormatHeader(ExtTypeCode, dataSize, ref idx);
UnsafeMemory.WriteRaw(ref writer, serializedData, ref idx);
var buffer = writer.ToArray(idx);
stream.Write(buffer);
}
public void Serialize(ref MessagePackWriter writer, ref int idx, object value, IFormatterResolver formatterResolver)
{
if (value == null)
{
writer.WriteNil(ref idx); return;
}
var type = value.GetType();
if (!s_typeNameCache.TryGetValue(type, out Type expectedType))
{
GetExpectedTypeSlow(type, out expectedType);
}
if (expectedType == null)
{
Resolvers.TypelessFormatterFallbackResolver.Instance.GetFormatter <object>().Serialize(ref writer, ref idx, value, formatterResolver);
return;
}
// don't use GetOrAdd for avoid closure capture.
if (!s_serializers.TryGetValue(expectedType, out var formatterAndDelegate))
{
GetFormatterAndDelegateSlow(expectedType, formatterResolver, out formatterAndDelegate);
}
// mark as extension with code 100
writer.Ensure(idx, 6);
var startOffset = idx;
idx += 6; // mark will be written at the end, when size is known
var typeName = MessagePackBinary.GetEncodedTypeName(expectedType);
UnsafeMemory.WriteRaw(ref writer, typeName, ref idx);
formatterAndDelegate.Value(formatterAndDelegate.Key, ref writer, ref idx, value, formatterResolver);
var dataLength = idx - startOffset - 6;
MessagePackBinary.WriteExtensionFormatHeaderForceExt32Block(ref writer.PinnableAddress, startOffset, ExtensionTypeCode, dataLength);
}
public void MemoryCtorSubArrayWithPinnedPtr()
{
unsafe
{
var data = new byte[10];
for (int i = 0; i < data.Length; i++)
{
data[i] = (byte)i;
}
fixed (byte* ptr = data)
{
var memory = new UnsafeMemory<byte>(data, 5, 5, ptr + 5);
Assert.Equal(5, memory.Length);
var span = memory.Span;
for (int i = 0; i < 5; i++)
{
Assert.Equal(span[i], i + 5);
}
}
}
}
public void GetArrayOrPointer()
{
var original = new int[] { 1, 2, 3 };
ArraySegment<int> array;
UnsafeMemory<int> slice;
slice = new UnsafeMemory<int>(original, 1, 2);
Assert.True(slice.TryGetArray(out array));
Assert.Equal(2, array.Array[array.Offset + 0]);
Assert.Equal(3, array.Array[array.Offset + 1]);
slice = new UnsafeMemory<int>(original, 0, 3);
Assert.True(slice.TryGetArray(out array));
Assert.Equal(1, array.Array[array.Offset + 0]);
Assert.Equal(2, array.Array[array.Offset + 1]);
Assert.Equal(3, array.Array[array.Offset + 2]);
slice = new UnsafeMemory<int>(original, 0, 0);
Assert.True(slice.TryGetArray(out array));
Assert.Equal(0, array.Offset);
Assert.Equal(original, array.Array);
Assert.Equal(0, array.Count);
unsafe
{
fixed (int* pBytes = original)
{
slice = new UnsafeMemory<int>(pBytes, 1);
Assert.False(slice.TryGetArray(out array));
void* p;
Assert.True(slice.TryGetPointer(out p));
Assert.True(null != p);
Assert.Equal(null, array.Array);
Assert.Equal(0, array.Offset);
Assert.Equal(0, array.Count);
}
}
unsafe
{
fixed (int* pBytes = original)
{
var roSlice = new ReadOnlySpan<int>(pBytes, 1);
Assert.False(slice.TryGetArray(out array));
void* p;
Assert.True(slice.TryGetPointer(out p));
Assert.True(null != p);
Assert.Equal(null, array.Array);
Assert.Equal(0, array.Offset);
Assert.Equal(0, array.Count);
}
}
}
void OnReadWindows(UVBuffer.Windows buffer, IntPtr bytesAvaliable)
{
// TODO: all branches need to release buffer, I think
long bytesRead = bytesAvaliable.ToInt64();
if (bytesRead == 0)
{
buffer.Dispose();
return;
}
else if (bytesRead < 0)
{
var error = UVException.ErrorCodeToError((int)bytesRead);
if (error == UVError.EOF)
{
OnEndOfStream();
Dispose();
buffer.Dispose();
}
else if (error == UVError.ECONNRESET)
{
Debug.Assert(buffer.Buffer == IntPtr.Zero && buffer.Length == 0);
// no need to dispose
// TODO: what should we do here?
}
else
{
Dispose();
buffer.Dispose();
throw new UVException((int)bytesRead);
}
}
else
{
var readSlice = new UnsafeMemory<byte>((byte*)buffer.Buffer, (int)bytesRead);
OnReadCompleted(readSlice);
buffer.Dispose();
}
}
public void TryGetPointerReturnsFalseIfNotPinned()
{
var data = new byte[10];
var memory = new UnsafeMemory<byte>(data, 0, data.Length);
unsafe
{
void* pointer;
Assert.False(memory.TryGetPointer(out pointer));
}
}
public int Receive(UnsafeMemory<byte> buffer)
{
// This can work with Span<byte> because it's synchronous but we need pinning support
unsafe
{
ArraySegment<byte> segment;
if (buffer.TryGetArray(out segment)) {
return Receive(segment);
}
else {
void* pointer;
buffer.TryGetPointer(out pointer);
return ReceivePinned(new IntPtr(pointer), buffer.Length);
}
}
}
public void TryGetPointerReturnsTrueIfPointerUsed()
{
unsafe
{
IntPtr raw = Marshal.AllocHGlobal(10);
var memory = new UnsafeMemory<byte>((void*)raw, 10);
void* pointer;
Assert.True(memory.TryGetPointer(out pointer));
Assert.True(raw.ToPointer() == pointer);
Marshal.FreeHGlobal(raw);
}
}
public void TryGetPointerReturnsTrueIfArrayAndPrePinned()
{
unsafe
{
var data = new byte[10];
fixed (byte* ptr = data)
{
var memory = new UnsafeMemory<byte>(data, 0, data.Length, ptr);
void* pointer;
Assert.True(memory.TryGetPointer(out pointer));
Assert.True(ptr == pointer);
}
}
}
public void MemoryCtorThrowsIfPtrDoesNotMatchArrayArgs()
{
Assert.Throws<ArgumentException>(() =>
{
unsafe
{
var data = new byte[10];
fixed (byte* ptr = data)
{
var memory = new UnsafeMemory<byte>(data, 0, data.Length, ptr + 1);
}
}
});
}
public void SlicePointerBackedMemory()
{
unsafe
{
var data = new byte[10];
for (int i = 0; i < 10; i++)
{
data[i] = (byte)i;
}
fixed (byte* ptr = data)
{
var memory = new UnsafeMemory<byte>(ptr, data.Length);
var slice = memory.Slice(0, 5);
var span = slice.Span;
for (int i = 0; i < 5; i++)
{
Assert.Equal(i, span[i]);
}
var subSlice = slice.Slice(2, 1);
Assert.Equal(2, subSlice.Span[0]);
}
}
}
void OnReadUnix(UVBuffer.Unix buffer, IntPtr bytesAvaliable)
{
long bytesRead = bytesAvaliable.ToInt64();
if (bytesRead == 0)
{
return;
}
else if (bytesRead < 0)
{
var error = UVException.ErrorCodeToError((int)bytesRead);
if (error == UVError.EOF)
{
OnEndOfStream();
Dispose();
}
else
{
Dispose();
throw new UVException((int)bytesRead);
}
}
else
{
// This can be a Span<byte> but the samples pass it directly to TryWrite which
// needs to unpack the data and turn it back into either an array or native memory
var readSlice = new UnsafeMemory<byte>((byte*)buffer.Buffer, (int)bytesRead);
OnReadCompleted(readSlice);
buffer.Dispose();
}
}
public void SliceArrayBackedMemory()
{
var data = new byte[10];
for (int i = 0; i < 10; i++)
{
data[i] = (byte)i;
}
var memory = new UnsafeMemory<byte>(data, 0, data.Length);
var slice = memory.Slice(0, 5);
var span = slice.Span;
for (int i = 0; i < 5; i++)
{
Assert.Equal(i, span[i]);
}
var subSlice = slice.Slice(2, 1);
Assert.Equal(2, subSlice.Span[0]);
}
void OnReadCompleted(UnsafeMemory<byte> bytesRead)
{
if (ReadCompleted != null)
{
ReadCompleted(bytesRead);
}
}