mirror of https://github.com/SixLabors/ImageSharp
Anton Firszov
8 years ago
35 changed files with 322 additions and 1150 deletions
@ -0,0 +1,54 @@ |
|||
using System; |
|||
using System.Runtime.CompilerServices; |
|||
|
|||
namespace SixLabors.ImageSharp.Memory |
|||
{ |
|||
internal static class BufferExtensions |
|||
{ |
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static int Length<T>(this IBuffer<T> buffer) |
|||
where T : struct => buffer.Span.Length; |
|||
|
|||
/// <summary>
|
|||
/// Gets a <see cref="Span{T}"/> to an offseted position inside the buffer.
|
|||
/// </summary>
|
|||
/// <param name="buffer">The buffer</param>
|
|||
/// <param name="start">The start</param>
|
|||
/// <returns>The <see cref="Span{T}"/></returns>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static Span<T> Slice<T>(this IBuffer<T> buffer, int start) |
|||
where T : struct |
|||
{ |
|||
return buffer.Span.Slice(start); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Gets a <see cref="Span{T}"/> to an offsetted position inside the buffer.
|
|||
/// </summary>
|
|||
/// <param name="buffer">The buffer</param>
|
|||
/// <param name="start">The start</param>
|
|||
/// <param name="length">The length of the slice</param>
|
|||
/// <returns>The <see cref="Span{T}"/></returns>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static Span<T> Slice<T>(this IBuffer<T> buffer, int start, int length) |
|||
where T : struct |
|||
{ |
|||
return buffer.Span.Slice(start, length); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Clears the contents of this buffer.
|
|||
/// </summary>
|
|||
/// <param name="buffer">The buffer</param>
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public static void Clear<T>(this IBuffer<T> buffer) |
|||
where T : struct |
|||
{ |
|||
buffer.Span.Clear(); |
|||
} |
|||
|
|||
public static ref T DangerousGetPinnableReference<T>(this IBuffer<T> buffer) |
|||
where T : struct => |
|||
ref buffer.Span.DangerousGetPinnableReference(); |
|||
} |
|||
} |
|||
@ -1,42 +0,0 @@ |
|||
// ReSharper disable InconsistentNaming
|
|||
namespace SixLabors.ImageSharp.Benchmarks.General |
|||
{ |
|||
using System; |
|||
using System.Runtime.CompilerServices; |
|||
|
|||
using BenchmarkDotNet.Attributes; |
|||
|
|||
using SixLabors.ImageSharp.Memory; |
|||
|
|||
public unsafe class ClearBuffer |
|||
{ |
|||
private Buffer<Rgba32> buffer; |
|||
|
|||
[Params(32, 128, 512)] |
|||
public int Count { get; set; } |
|||
|
|||
[GlobalSetup] |
|||
public void Setup() |
|||
{ |
|||
this.buffer = Configuration.Default.MemoryManager.Allocate<Rgba32>(this.Count); |
|||
} |
|||
|
|||
[GlobalCleanup] |
|||
public void Cleanup() |
|||
{ |
|||
this.buffer.Dispose(); |
|||
} |
|||
|
|||
[Benchmark(Baseline = true)] |
|||
public void Array_Clear() |
|||
{ |
|||
Array.Clear(this.buffer.Array, 0, this.Count); |
|||
} |
|||
|
|||
[Benchmark] |
|||
public void Unsafe_InitBlock() |
|||
{ |
|||
Unsafe.InitBlock((void*)this.buffer.Pin(), default(byte), (uint)this.Count * sizeof(uint)); |
|||
} |
|||
} |
|||
} |
|||
@ -1,362 +0,0 @@ |
|||
namespace SixLabors.ImageSharp.Benchmarks.General |
|||
{ |
|||
using System.Numerics; |
|||
using System.Runtime.CompilerServices; |
|||
|
|||
using BenchmarkDotNet.Attributes; |
|||
|
|||
using SixLabors.ImageSharp.Memory; |
|||
|
|||
// Pixel indexing benchmarks compare different methods for getting/setting all pixel values in a subsegment of a single pixel row.
|
|||
public abstract unsafe class PixelIndexing |
|||
{ |
|||
/// <summary>
|
|||
/// https://github.com/dotnet/corefx/blob/master/src/System.Memory/src/System/Pinnable.cs
|
|||
/// </summary>
|
|||
protected class Pinnable<T> |
|||
{ |
|||
public T Data; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// The indexer methods are encapsulated into a struct to make sure everything is inlined.
|
|||
/// </summary>
|
|||
internal struct Data |
|||
{ |
|||
private Vector4* pointer; |
|||
|
|||
private Pinnable<Vector4> pinnable; |
|||
|
|||
private Vector4[] array; |
|||
|
|||
private int width; |
|||
|
|||
public Data(Buffer2D<Vector4> buffer) |
|||
{ |
|||
this.pointer = (Vector4*)buffer.Buffer.Pin(); |
|||
this.pinnable = Unsafe.As<Pinnable<Vector4>>(buffer.Buffer.Array); |
|||
this.array = buffer.Buffer.Array; |
|||
this.width = buffer.Width; |
|||
} |
|||
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public Vector4 GetPointersBasicImpl(int x, int y) |
|||
{ |
|||
return this.pointer[y * this.width + x]; |
|||
} |
|||
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public Vector4 GetPointersSrcsUnsafeImpl(int x, int y) |
|||
{ |
|||
// This is the original solution in PixelAccessor:
|
|||
return Unsafe.Read<Vector4>((byte*)this.pointer + (((y * this.width) + x) * Unsafe.SizeOf<Vector4>())); |
|||
} |
|||
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public Vector4 GetReferencesImpl(int x, int y) |
|||
{ |
|||
int elementOffset = (y * this.width) + x; |
|||
return Unsafe.Add(ref this.pinnable.Data, elementOffset); |
|||
} |
|||
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public ref Vector4 GetReferencesRefReturnsImpl(int x, int y) |
|||
{ |
|||
int elementOffset = (y * this.width) + x; |
|||
return ref Unsafe.Add(ref this.pinnable.Data, elementOffset); |
|||
} |
|||
|
|||
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public void IndexWithPointersBasicImpl(int x, int y, Vector4 v) |
|||
{ |
|||
this.pointer[y * this.width + x] = v; |
|||
} |
|||
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public void IndexWithPointersSrcsUnsafeImpl(int x, int y, Vector4 v) |
|||
{ |
|||
Unsafe.Write((byte*)this.pointer + (((y * this.width) + x) * Unsafe.SizeOf<Vector4>()), v); |
|||
} |
|||
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public void IndexWithReferencesOnPinnableIncorrectImpl(int x, int y, Vector4 v) |
|||
{ |
|||
int elementOffset = (y * this.width) + x; |
|||
// Incorrect, because also should add a runtime-specific byte offset here. See https://github.com/dotnet/corefx/blob/master/src/System.Memory/src/System/Span.cs#L68
|
|||
Unsafe.Add(ref this.pinnable.Data, elementOffset) = v; |
|||
} |
|||
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public ref Vector4 IndexWithReferencesOnPinnableIncorrectRefReturnImpl(int x, int y) |
|||
{ |
|||
int elementOffset = (y * this.width) + x; |
|||
// Incorrect, because also should add a runtime-specific byte offset here. See https://github.com/dotnet/corefx/blob/master/src/System.Memory/src/System/Span.cs#L68
|
|||
return ref Unsafe.Add(ref this.pinnable.Data, elementOffset); |
|||
} |
|||
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public void IndexWithUnsafeReferenceArithmeticsOnArray0Impl(int x, int y, Vector4 v) |
|||
{ |
|||
int elementOffset = (y * this.width) + x; |
|||
Unsafe.Add(ref this.array[0], elementOffset) = v; |
|||
} |
|||
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public ref Vector4 IndexWithUnsafeReferenceArithmeticsOnArray0RefReturnImpl(int x, int y) |
|||
{ |
|||
int elementOffset = (y * this.width) + x; |
|||
return ref Unsafe.Add(ref this.array[0], elementOffset); |
|||
} |
|||
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public void IndexSetArrayStraightforward(int x, int y, Vector4 v) |
|||
{ |
|||
// No magic.
|
|||
// We just index right into the array as normal people do.
|
|||
// And it looks like this is the fastest way!
|
|||
this.array[(y * this.width) + x] = v; |
|||
} |
|||
|
|||
[MethodImpl(MethodImplOptions.AggressiveInlining)] |
|||
public ref Vector4 IndexWithReferencesOnArrayStraightforwardRefReturnImpl(int x, int y) |
|||
{ |
|||
// No magic.
|
|||
// We just index right into the array as normal people do.
|
|||
// And it looks like this is the fastest way!
|
|||
return ref this.array[(y * this.width) + x]; |
|||
} |
|||
} |
|||
|
|||
internal Buffer2D<Vector4> buffer; |
|||
|
|||
protected int width; |
|||
|
|||
protected int startIndex; |
|||
|
|||
protected int endIndex; |
|||
|
|||
protected Vector4* pointer; |
|||
|
|||
protected Vector4[] array; |
|||
|
|||
protected Pinnable<Vector4> pinnable; |
|||
|
|||
// [Params(1024)]
|
|||
public int Count { get; set; } = 1024; |
|||
|
|||
[GlobalSetup] |
|||
public void Setup() |
|||
{ |
|||
this.width = 2048; |
|||
this.buffer = Configuration.Default.MemoryManager.Allocate2D<Vector4>(2048, 2048); |
|||
this.pointer = (Vector4*)this.buffer.Buffer.Pin(); |
|||
this.array = this.buffer.Buffer.Array; |
|||
this.pinnable = Unsafe.As<Pinnable<Vector4>>(this.array); |
|||
|
|||
this.startIndex = 2048 / 2 - (this.Count / 2); |
|||
this.endIndex = 2048 / 2 + (this.Count / 2); |
|||
} |
|||
|
|||
[GlobalCleanup] |
|||
public void Cleanup() |
|||
{ |
|||
this.buffer.Dispose(); |
|||
} |
|||
|
|||
} |
|||
|
|||
public class PixelIndexingGetter : PixelIndexing |
|||
{ |
|||
[Benchmark(Description = "Index.Get: Pointers+arithmetics", Baseline = true)] |
|||
public Vector4 IndexWithPointersBasic() |
|||
{ |
|||
Vector4 sum = Vector4.Zero; |
|||
Data data = new Data(this.buffer); |
|||
int y = this.startIndex; |
|||
for (int x = this.startIndex; x < this.endIndex; x++) |
|||
{ |
|||
sum += data.GetPointersBasicImpl(x, y); |
|||
} |
|||
|
|||
return sum; |
|||
} |
|||
|
|||
[Benchmark(Description = "Index.Get: Pointers+SRCS.Unsafe")] |
|||
public Vector4 IndexWithPointersSrcsUnsafe() |
|||
{ |
|||
Vector4 sum = Vector4.Zero; |
|||
Data data = new Data(this.buffer); |
|||
|
|||
int y = this.startIndex; |
|||
for (int x = this.startIndex; x < this.endIndex; x++) |
|||
{ |
|||
sum += data.GetPointersSrcsUnsafeImpl(x, y); |
|||
} |
|||
|
|||
return sum; |
|||
} |
|||
|
|||
[Benchmark(Description = "Index.Get: References")] |
|||
public Vector4 IndexWithReferences() |
|||
{ |
|||
Vector4 sum = Vector4.Zero; |
|||
Data data = new Data(this.buffer); |
|||
|
|||
int y = this.startIndex; |
|||
for (int x = this.startIndex; x < this.endIndex; x++) |
|||
{ |
|||
sum += data.GetReferencesImpl(x, y); |
|||
} |
|||
|
|||
return sum; |
|||
} |
|||
|
|||
[Benchmark(Description = "Index.Get: References|refreturns")] |
|||
public Vector4 IndexWithReferencesRefReturns() |
|||
{ |
|||
Vector4 sum = Vector4.Zero; |
|||
Data data = new Data(this.buffer); |
|||
|
|||
int y = this.startIndex; |
|||
for (int x = this.startIndex; x < this.endIndex; x++) |
|||
{ |
|||
sum += data.GetReferencesRefReturnsImpl(x, y); |
|||
} |
|||
|
|||
return sum; |
|||
} |
|||
} |
|||
|
|||
public class PixelIndexingSetter : PixelIndexing |
|||
{ |
|||
[Benchmark(Description = "!!! Index.Set: Pointers|arithmetics", Baseline = true)] |
|||
public void IndexWithPointersBasic() |
|||
{ |
|||
Vector4 v = new Vector4(1, 2, 3, 4); |
|||
Data data = new Data(this.buffer); |
|||
|
|||
int y = this.startIndex; |
|||
for (int x = this.startIndex; x < this.endIndex; x++) |
|||
{ |
|||
data.IndexWithPointersBasicImpl(x, y, v); |
|||
} |
|||
} |
|||
|
|||
[Benchmark(Description = "Index.Set: Pointers|SRCS.Unsafe")] |
|||
public void IndexWithPointersSrcsUnsafe() |
|||
{ |
|||
Vector4 v = new Vector4(1, 2, 3, 4); |
|||
Data data = new Data(this.buffer); |
|||
|
|||
int y = this.startIndex; |
|||
for (int x = this.startIndex; x < this.endIndex; x++) |
|||
{ |
|||
data.IndexWithPointersSrcsUnsafeImpl(x, y, v); |
|||
} |
|||
} |
|||
|
|||
[Benchmark(Description = "Index.Set: References|IncorrectPinnable")] |
|||
public void IndexWithReferencesPinnableBasic() |
|||
{ |
|||
Vector4 v = new Vector4(1, 2, 3, 4); |
|||
Data data = new Data(this.buffer); |
|||
|
|||
int y = this.startIndex; |
|||
for (int x = this.startIndex; x < this.endIndex; x++) |
|||
{ |
|||
data.IndexWithReferencesOnPinnableIncorrectImpl(x, y, v); |
|||
} |
|||
} |
|||
|
|||
[Benchmark(Description = "Index.Set: References|IncorrectPinnable|refreturn")] |
|||
public void IndexWithReferencesPinnableRefReturn() |
|||
{ |
|||
Vector4 v = new Vector4(1, 2, 3, 4); |
|||
Data data = new Data(this.buffer); |
|||
|
|||
int y = this.startIndex; |
|||
for (int x = this.startIndex; x < this.endIndex; x++) |
|||
{ |
|||
data.IndexWithReferencesOnPinnableIncorrectRefReturnImpl(x, y) = v; |
|||
} |
|||
} |
|||
|
|||
[Benchmark(Description = "Index.Set: References|Array[0]Unsafe")]
|
|||
public void IndexWithReferencesArrayBasic() |
|||
{ |
|||
Vector4 v = new Vector4(1, 2, 3, 4); |
|||
Data data = new Data(this.buffer); |
|||
|
|||
int y = this.startIndex; |
|||
for (int x = this.startIndex; x < this.endIndex; x++) |
|||
{ |
|||
data.IndexWithUnsafeReferenceArithmeticsOnArray0Impl(x, y, v); |
|||
} |
|||
} |
|||
|
|||
[Benchmark(Description = "Index.Set: References|Array[0]Unsafe|refreturn")]
|
|||
public void IndexWithReferencesArrayRefReturn() |
|||
{ |
|||
Vector4 v = new Vector4(1, 2, 3, 4); |
|||
Data data = new Data(this.buffer); |
|||
|
|||
int y = this.startIndex; |
|||
for (int x = this.startIndex; x < this.endIndex; x++) |
|||
{ |
|||
data.IndexWithUnsafeReferenceArithmeticsOnArray0RefReturnImpl(x, y) = v; |
|||
} |
|||
} |
|||
|
|||
[Benchmark(Description = "!!! Index.Set: References|Array+Straight")] |
|||
public void IndexWithReferencesArrayStraightforward() |
|||
{ |
|||
Vector4 v = new Vector4(1, 2, 3, 4); |
|||
Data data = new Data(this.buffer); |
|||
|
|||
int y = this.startIndex; |
|||
for (int x = this.startIndex; x < this.endIndex; x++) |
|||
{ |
|||
// No magic.
|
|||
// We just index right into the array as normal people do.
|
|||
// And it looks like this is the fastest way!
|
|||
data.IndexSetArrayStraightforward(x, y, v); |
|||
} |
|||
} |
|||
|
|||
|
|||
[Benchmark(Description = "!!! Index.Set: References|Array+Straight|refreturn")] |
|||
public void IndexWithReferencesArrayStraightforwardRefReturn() |
|||
{ |
|||
Vector4 v = new Vector4(1, 2, 3, 4); |
|||
Data data = new Data(this.buffer); |
|||
|
|||
int y = this.startIndex; |
|||
for (int x = this.startIndex; x < this.endIndex; x++) |
|||
{ |
|||
// No magic.
|
|||
// We just index right into the array as normal people do.
|
|||
// And it looks like this is the fastest way!
|
|||
data.IndexWithReferencesOnArrayStraightforwardRefReturnImpl(x, y) = v; |
|||
} |
|||
} |
|||
|
|||
[Benchmark(Description = "!!! Index.Set: SmartUnsafe")] |
|||
public void SmartUnsafe() |
|||
{ |
|||
Vector4 v = new Vector4(1, 2, 3, 4); |
|||
Data data = new Data(this.buffer); |
|||
|
|||
// This method is basically an unsafe variant of .GetRowSpan(y) + indexing individual pixels in the row.
|
|||
// If a user seriously needs by-pixel manipulation to be performant, we should provide this option.
|
|||
|
|||
ref Vector4 rowStart = ref data.IndexWithReferencesOnArrayStraightforwardRefReturnImpl(this.startIndex, this.startIndex); |
|||
|
|||
for (int i = 0; i < this.Count; i++) |
|||
{ |
|||
// We don't have to add 'Width * y' here!
|
|||
Unsafe.Add(ref rowStart, i) = v; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -1,251 +0,0 @@ |
|||
// Copyright (c) Six Labors and contributors.
|
|||
// Licensed under the Apache License, Version 2.0.
|
|||
|
|||
namespace SixLabors.ImageSharp.Tests.Memory |
|||
{ |
|||
using System; |
|||
using System.Runtime.CompilerServices; |
|||
|
|||
using SixLabors.ImageSharp.Memory; |
|||
|
|||
using Xunit; |
|||
|
|||
public unsafe class BufferTests |
|||
{ |
|||
// ReSharper disable once ClassNeverInstantiated.Local
|
|||
private class Assert : Xunit.Assert |
|||
{ |
|||
public static void SpanPointsTo<T>(Span<T> span, Buffer<T> buffer, int bufferOffset = 0) |
|||
where T : struct |
|||
{ |
|||
ref T actual = ref span.DangerousGetPinnableReference(); |
|||
ref T expected = ref Unsafe.Add(ref buffer[0], bufferOffset); |
|||
|
|||
Assert.True(Unsafe.AreSame(ref expected, ref actual), "span does not point to the expected position"); |
|||
} |
|||
|
|||
public static void Equal(void* expected, void* actual) |
|||
{ |
|||
Assert.Equal((IntPtr)expected, (IntPtr)actual); |
|||
} |
|||
} |
|||
|
|||
[Theory] |
|||
[InlineData(42)] |
|||
[InlineData(1111)] |
|||
public void ConstructWithOwnArray(int count) |
|||
{ |
|||
using (Buffer<TestStructs.Foo> buffer = Configuration.Default.MemoryManager.Allocate<TestStructs.Foo>(count)) |
|||
{ |
|||
Assert.False(buffer.IsDisposedOrLostArrayOwnership); |
|||
Assert.NotNull(buffer.Array); |
|||
Assert.Equal(count, buffer.Length); |
|||
Assert.True(buffer.Array.Length >= count); |
|||
} |
|||
} |
|||
|
|||
[Theory] |
|||
[InlineData(42)] |
|||
[InlineData(1111)] |
|||
public void ConstructWithExistingArray(int count) |
|||
{ |
|||
TestStructs.Foo[] array = new TestStructs.Foo[count]; |
|||
using (Buffer<TestStructs.Foo> buffer = new Buffer<TestStructs.Foo>(array)) |
|||
{ |
|||
Assert.False(buffer.IsDisposedOrLostArrayOwnership); |
|||
Assert.Equal(array, buffer.Array); |
|||
Assert.Equal(count, buffer.Length); |
|||
} |
|||
} |
|||
|
|||
[Fact] |
|||
public void Clear() |
|||
{ |
|||
TestStructs.Foo[] a = { new TestStructs.Foo() { A = 1, B = 2 }, new TestStructs.Foo() { A = 3, B = 4 } }; |
|||
using (Buffer<TestStructs.Foo> buffer = new Buffer<TestStructs.Foo>(a)) |
|||
{ |
|||
buffer.Clear(); |
|||
|
|||
Assert.Equal(default(TestStructs.Foo), a[0]); |
|||
Assert.Equal(default(TestStructs.Foo), a[1]); |
|||
} |
|||
} |
|||
|
|||
[Fact] |
|||
public void CreateClean() |
|||
{ |
|||
for (int i = 0; i < 100; i++) |
|||
{ |
|||
using (Buffer<int> buffer = Configuration.Default.MemoryManager.Allocate<int>(42, true)) |
|||
{ |
|||
for (int j = 0; j < buffer.Length; j++) |
|||
{ |
|||
Assert.Equal(0, buffer.Array[j]); |
|||
buffer.Array[j] = 666; |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
public class Indexer |
|||
{ |
|||
public static readonly TheoryData<int, int> IndexerData = |
|||
new TheoryData<int,int>() |
|||
{ |
|||
{ 10, 0 }, |
|||
{ 16, 3 }, |
|||
{ 10, 9 } |
|||
}; |
|||
|
|||
[Theory] |
|||
[MemberData(nameof(IndexerData))] |
|||
public void Read(int length, int index) |
|||
{ |
|||
TestStructs.Foo[] a = TestStructs.Foo.CreateArray(length); |
|||
|
|||
using (Buffer<TestStructs.Foo> buffer = new Buffer<TestStructs.Foo>(a)) |
|||
{ |
|||
TestStructs.Foo element = buffer[index]; |
|||
|
|||
Assert.Equal(a[index], element); |
|||
} |
|||
} |
|||
|
|||
[Theory] |
|||
[MemberData(nameof(IndexerData))] |
|||
public void Write(int length, int index) |
|||
{ |
|||
TestStructs.Foo[] a = TestStructs.Foo.CreateArray(length); |
|||
|
|||
using (Buffer<TestStructs.Foo> buffer = new Buffer<TestStructs.Foo>(a)) |
|||
{ |
|||
buffer[index] = new TestStructs.Foo(666, 666); |
|||
|
|||
Assert.Equal(new TestStructs.Foo(666, 666), a[index]); |
|||
} |
|||
} |
|||
} |
|||
|
|||
[Fact] |
|||
public void Dispose() |
|||
{ |
|||
Buffer<TestStructs.Foo> buffer = Configuration.Default.MemoryManager.Allocate<TestStructs.Foo>(42); |
|||
buffer.Dispose(); |
|||
|
|||
Assert.True(buffer.IsDisposedOrLostArrayOwnership); |
|||
} |
|||
|
|||
[Theory] |
|||
[InlineData(7)] |
|||
[InlineData(123)] |
|||
public void CastToSpan(int bufferLength) |
|||
{ |
|||
using (Buffer<TestStructs.Foo> buffer = Configuration.Default.MemoryManager.Allocate<TestStructs.Foo>(bufferLength)) |
|||
{ |
|||
Span<TestStructs.Foo> span = buffer; |
|||
|
|||
//Assert.Equal(buffer.Array, span.ToArray());
|
|||
//Assert.Equal(0, span.Start);
|
|||
Assert.SpanPointsTo(span, buffer); |
|||
Assert.Equal(span.Length, bufferLength); |
|||
} |
|||
} |
|||
|
|||
[Fact] |
|||
public void Span() |
|||
{ |
|||
using (Buffer<TestStructs.Foo> buffer = Configuration.Default.MemoryManager.Allocate<TestStructs.Foo>(42)) |
|||
{ |
|||
Span<TestStructs.Foo> span = buffer.Span; |
|||
|
|||
// Assert.Equal(buffer.Array, span.ToArray());
|
|||
// Assert.Equal(0, span.Start);
|
|||
Assert.SpanPointsTo(span, buffer); |
|||
Assert.Equal(42, span.Length); |
|||
} |
|||
} |
|||
|
|||
public class Slice |
|||
{ |
|||
|
|||
[Theory] |
|||
[InlineData(7, 2)] |
|||
[InlineData(123, 17)] |
|||
public void WithStartOnly(int bufferLength, int start) |
|||
{ |
|||
using (Buffer<TestStructs.Foo> buffer = Configuration.Default.MemoryManager.Allocate<TestStructs.Foo>(bufferLength)) |
|||
{ |
|||
Span<TestStructs.Foo> span = buffer.Slice(start); |
|||
|
|||
Assert.SpanPointsTo(span, buffer, start); |
|||
Assert.Equal(span.Length, bufferLength - start); |
|||
} |
|||
} |
|||
|
|||
[Theory] |
|||
[InlineData(7, 2, 5)] |
|||
[InlineData(123, 17, 42)] |
|||
public void WithStartAndLength(int bufferLength, int start, int spanLength) |
|||
{ |
|||
using (Buffer<TestStructs.Foo> buffer = Configuration.Default.MemoryManager.Allocate<TestStructs.Foo>(bufferLength)) |
|||
{ |
|||
Span<TestStructs.Foo> span = buffer.Slice(start, spanLength); |
|||
|
|||
Assert.SpanPointsTo(span, buffer, start); |
|||
Assert.Equal(span.Length, spanLength); |
|||
} |
|||
} |
|||
} |
|||
|
|||
[Fact] |
|||
public void UnPinAndTakeArrayOwnership() |
|||
{ |
|||
TestStructs.Foo[] data = null; |
|||
using (Buffer<TestStructs.Foo> buffer = Configuration.Default.MemoryManager.Allocate<TestStructs.Foo>(42)) |
|||
{ |
|||
data = buffer.TakeArrayOwnership(); |
|||
Assert.True(buffer.IsDisposedOrLostArrayOwnership); |
|||
} |
|||
|
|||
Assert.NotNull(data); |
|||
Assert.True(data.Length >= 42); |
|||
} |
|||
|
|||
public class Pin |
|||
{ |
|||
[Fact] |
|||
public void ReturnsPinnedPointerToTheBeginningOfArray() |
|||
{ |
|||
using (Buffer<TestStructs.Foo> buffer = Configuration.Default.MemoryManager.Allocate<TestStructs.Foo>(42)) |
|||
{ |
|||
TestStructs.Foo* actual = (TestStructs.Foo*)buffer.Pin(); |
|||
fixed (TestStructs.Foo* expected = buffer.Array) |
|||
{ |
|||
Assert.Equal(expected, actual); |
|||
} |
|||
} |
|||
} |
|||
|
|||
[Fact] |
|||
public void SecondCallReturnsTheSamePointer() |
|||
{ |
|||
using (Buffer<TestStructs.Foo> buffer = Configuration.Default.MemoryManager.Allocate<TestStructs.Foo>(42)) |
|||
{ |
|||
IntPtr ptr1 = buffer.Pin(); |
|||
IntPtr ptr2 = buffer.Pin(); |
|||
|
|||
Assert.Equal(ptr1, ptr2); |
|||
} |
|||
} |
|||
|
|||
[Fact] |
|||
public void WhenCalledOnDisposedBuffer_ThrowsInvalidOperationException() |
|||
{ |
|||
Buffer<TestStructs.Foo> buffer = Configuration.Default.MemoryManager.Allocate<TestStructs.Foo>(42); |
|||
buffer.Dispose(); |
|||
|
|||
Assert.Throws<InvalidOperationException>(() => buffer.Pin()); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
Loading…
Reference in new issue