private static int SizeOf(VectorStorage value, out RetainedMemory <byte> temporaryBuffer,
SerializationFormat format = default,
Timestamp timestamp = default)
{
return(BinarySerializer.SizeOf(new VectorStorage <T>(value), out temporaryBuffer,
format, timestamp));
}
private IEnumerable <DirectBuffer> AsEnumerable(ReadOnlyTransaction txn, RetainedMemory <byte> key)
{
if (((int)OpenFlags & (int)DbFlags.DuplicatesSort) == 0)
{
throw new InvalidOperationException("AsEnumerable overload with key parameter should only be provided for dupsorted dbs");
}
try
{
var key1 = new DirectBuffer(key.GetSpan());
DirectBuffer value = default;
using (var c = OpenReadOnlyCursor(txn))
{
if (c.TryGet(ref key1, ref value, CursorGetOption.SetKey) &&
c.TryGet(ref key1, ref value, CursorGetOption.FirstDuplicate))
{
yield return(value);
while (c.TryGet(ref key1, ref value, CursorGetOption.NextDuplicate))
{
yield return(value);
}
}
}
}
finally
{
key.Dispose();
}
}
private static int Write(VectorStorage value,
ref DirectBuffer pinnedDestination,
RetainedMemory <byte> temporaryBuffer = default,
SerializationFormat format = default,
Timestamp timestamp = default)
{
return(BinarySerializer.Write(new VectorStorage <T>(value), ref pinnedDestination,
temporaryBuffer, format, timestamp));
}
public void CannotRetainDisposed(Func <int, RetainableMemory <byte> > factory)
{
var memory = factory(32 * 1024);
((IDisposable)memory).Dispose();
Assert.Throws <ObjectDisposedException>(() => { var _ = memory.Retain(); });
Assert.Throws <ObjectDisposedException>(() => { var _ = new RetainedMemory <byte>(memory, 0, memory.Length, false); });
}
internal static DirectBuffer ToDirectBuffer(this RetainedMemory <byte> rm)
{
if (!rm.IsPinned)
{
ThrowHelper.ThrowInvalidOperationException("Cannot create DirectBuffer from RetainedMemory because it is not pinned.");
}
return(new DirectBuffer(rm));
}
public static int SizeOf(T value, out RetainedMemory <byte> temporaryBuffer, out bool withPadding)
{
// offset 16 to allow writing header + length + ts without copy
Debug.Assert(DataTypeHeader.Size + 4 + 8 == 16);
Debug.Assert(BinarySerializer.BC_PADDING == 16);
temporaryBuffer = JsonSerializer.SerializeToRetainedMemory(value, BinarySerializer.BC_PADDING);
withPadding = true;
return(temporaryBuffer.Length - BinarySerializer.BC_PADDING);
}
public static bool TryGetArray(this RetainedMemory <byte> rm, out ArraySegment <byte> segment)
{
// throw new NotImplementedException("What about R-edM start & length!?"); // TODO fix & test
if (MemoryMarshal.TryGetArray(rm.Memory, out segment))
{
segment = new ArraySegment <byte>(segment.Array, segment.Offset + rm._start, rm.Length);
return(true);
}
return(false);
}
public int SizeOf(VectorStorage <T> value, out RetainedMemory <byte> temporaryBuffer, out bool withPadding)
{
if (value.Storage.Stride != 1 || !TypeHelper <T> .IsFixedSize)
{
ThrowHelper.ThrowNotSupportedException();
}
temporaryBuffer = default;
withPadding = default;
return(4 + value.Storage.Length * Unsafe.SizeOf <T>());
}
public void CannotRetainDisposed()
{
var path = TestUtils.GetPath();
var pool = new SharedMemoryPool(path, 10 * 1024, (Wpid)1, rmMaxBufferLength: SharedMemoryPool.RmMaxPoolBufferLength);
var memory = pool.RentMemory(32 * 1024);
((IDisposable)memory).Dispose();
Assert.Throws <ObjectDisposedException>(() => { var _ = memory.Retain(); });
Assert.Throws <ObjectDisposedException>(() => { var _ = new RetainedMemory <byte>(memory, 0, memory.Length, false); });
pool.Dispose();
}
public void CouldCreateRetainedMemoryFromArray()
{
var array = new byte[100];
using var rm = new RetainedMemory <byte>(array);
using var rmc = rm.Clone(10);
GC.Collect(2, GCCollectionMode.Forced, true);
GC.WaitForPendingFinalizers();
GC.Collect(2, GCCollectionMode.Forced, true);
GC.WaitForPendingFinalizers();
rmc.GetSpan()[1] = 1;
Assert.AreEqual(1, array[11]);
}
public void OffsetsAreOk()
{
var array = new byte[100];
using var rm = new RetainedMemory <byte>(ArrayMemory <byte> .Create(array, 50, 50, true), 25, 25, true);
// 85 - 95
using var rmc = rm.Clone(10, 10);
GC.Collect(2, GCCollectionMode.Forced, true);
GC.WaitForPendingFinalizers();
GC.Collect(2, GCCollectionMode.Forced, true);
GC.WaitForPendingFinalizers();
rmc.GetSpan()[5] = 1;
Assert.AreEqual(1, array[90]);
}
public void ThreadStaticBufferVsSharedPool()
{
//Case | MOPS | Elapsed | GC0 | GC1 | GC2 | Memory
// ------------------------------------------ -| --------:| ---------:| ------:| ------:| ------:| --------:
//Direct ArrayPool with StaticBufferSize +1 | 37.04 | 27 ms | 0.0 | 0.0 | 0.0 | 0.008 MB
//Threadlocal | 34.48 | 29 ms | 0.0 | 0.0 | 0.0 | 0.008 MB
// Direct ArrayPool with StaticBufferSize | 34.48 | 29 ms | 0.0 | 0.0 | 0.0 | 0.008 MB
// GetBuffer via pool | 12.20 | 82 ms | 0.0 | 0.0 | 0.0 | 0.008 MB
// GC StaticBufferSize + 1 | 1.49 | 673 ms | 2610.0 | 0.0 | 0.0 | 5.798 MB
// GC StaticBufferSize | 1.48 | 675 ms | 2610.0 | 0.0 | 0.0 | 5.795 MB
for (int r = 0; r < 10; r++)
{
int count = (int)TestUtils.GetBenchCount(1_000_000);
var sum = 0L;
//using (Benchmark.Run("ThreadStatic", count))
//{
// for (var i = 0; i < count; i++)
// {
// var wrapper = BufferPool.StaticBuffer;
// // using (var wrapper = BufferPool.StaticBufferMemory)
// {
// var s = wrapper.Memory.Span;
// s[0] = 123;
// sum += s[0] + s[1];
// }
// }
// Assert.IsTrue(sum > 0);
//}
using (Benchmark.Run("BP.Retain", count))
{
sum = 0L;
for (var i = 0; i < count; i++)
{
using (var wrapper = BufferPool.Retain(Settings.LARGE_BUFFER_LIMIT))
{
var s = wrapper.Memory.Span;
s[0] = 123;
sum += s[0] + s[1];
}
}
Assert.IsTrue(sum > 0);
}
using (Benchmark.Run("BP.RetainTemp", count))
{
sum = 0L;
for (var i = 0; i < count; i++)
{
using (var wrapper = BufferPool.RetainTemp(Settings.LARGE_BUFFER_LIMIT))
{
var s = wrapper.Memory.Span;
s[0] = 123;
sum += s[0] + s[1];
}
}
Assert.IsTrue(sum > 0);
}
using (Benchmark.Run("RMP", count))
{
sum = 0L;
for (var i = 0; i < count; i++)
{
using (var wrapper = BufferPool.PinnedArrayMemoryPool.RentMemory(Settings.LARGE_BUFFER_LIMIT))
{
var s = wrapper.Memory.Span;
s[0] = 123;
sum += s[0] + s[1];
}
}
Assert.IsTrue(sum > 0);
}
using (Benchmark.Run("RM([])", count))
{
sum = 0L;
for (var i = 0; i < count; i++)
{
var arr = BufferPool <byte> .Rent(Settings.LARGE_BUFFER_LIMIT);
using (var wrapper = new RetainedMemory <byte>(arr))
{
var s = wrapper.Memory.Span;
s[0] = 123;
sum += s[0] + s[1];
}
BufferPool <byte> .Return(arr);
}
Assert.IsTrue(sum > 0);
}
using (Benchmark.Run("ArrayPool", count))
{
sum = 0L;
for (var i = 0; i < count; i++)
{
var buffer = BufferPool <byte> .Rent(Settings.LARGE_BUFFER_LIMIT);
buffer[0] = 123;
sum += buffer[0] + buffer[1];
BufferPool <byte> .Return(buffer, false);
}
Assert.IsTrue(sum > 0);
}
using (Benchmark.Run("GC", count))
{
sum = 0L;
for (var i = 0; i < count; i++)
{
var buffer = new byte[Settings.LARGE_BUFFER_LIMIT];
buffer[0] = 123;
sum += buffer[0] + buffer[1];
}
Assert.IsTrue(sum > 0);
}
}
Benchmark.Dump($"BufferPool benchmark");
}
public int SizeOf(TElement[] value, out RetainedMemory <byte> temporaryBuffer, out bool withPadding)
{
temporaryBuffer = default;
withPadding = default;
return(4 + value.Length * SizeOf <TElement>());
}
internal static DirectBuffer ToDirectBuffer(this RetainedMemory <byte> rm)
{
return(new DirectBuffer(rm));
}
public static bool TryGetArray(this RetainedMemory <byte> rm, out ArraySegment <byte> segment)
{
return(MemoryMarshal.TryGetArray(rm.Memory, out segment));
}
public static int SizeOfRaw <T>(T value, out RetainedMemory <byte> temporaryBuffer, out bool withPadding,
bool isBinary = false)
{
return(SizeOfRaw(in value, out temporaryBuffer, out withPadding, isBinary));
}
public unsafe (bool, long) InsertTest(long a, long b, RetainedMemory <byte> rawData)
{
const int aColumn = 1;
const int bColumn = 2;
const int dataColumn = 3;
try
{
var sw = new SpinWait();
// TODO serialize before bind because we need to release temp buffer
InsertTestQuery.Bind((binder, tuple) =>
{
var blobSize = tuple.rawData.Length;
var ptr = (IntPtr)tuple.rawData.Pointer;
Debug.Assert(blobSize > 0);
int rc;
if ((rc = binder.BindInt64(aColumn, tuple.a)) != 0)
{
ThrowHelper.FailFast("Cannot bind chunk.StreamId: " + rc);
}
if ((rc = binder.BindInt64(bColumn, tuple.b)) != 0)
{
ThrowHelper.FailFast("Cannot bind chunk.FirstVersion: " + rc);
}
if ((rc = binder.BindBlob(dataColumn, ptr, blobSize)) != 0)
{
ThrowHelper.FailFast("Cannot bind chunk blob: " + rc);
}
}, (a, b, rawData));
RETRY:
// var rcBegin = BeginConcurrentQuery.RawStep((hasRow, reader, st) => true, (object)null, out _);
// Console.WriteLine("rcBegin: " + rcBegin);
RETRY_TEST:
var rcTest = InsertTestQuery.RawStep((hasRow, reader, state) =>
{
if (hasRow)
{
ThrowHelper.FailFast("InsertChunk should not return rows");
}
return(reader.Changes() == 1, reader.LastRowId());
}, (object)null, out var result);
//if (rcTest != Spreads.SQLite.Interop.Constants.SQLITE_DONE)
//{
// Console.WriteLine("rcTest: " + rcTest);
//}
RETRY_COMMIT:
// var rcCommit = CommitQuery.RawStep((hasRow, reader, st) => true, (object)null, out _);
if (rcTest != Spreads.SQLite.Interop.Constants.SQLITE_DONE)
{
// Console.WriteLine(rcCommit);
sw.SpinOnce();
goto RETRY_TEST;
////// Console.WriteLine(rcTest);
//if (rcCommit == Spreads.SQLite.Interop.Constants.SQLITE_BUSY_SNAPSHOT)
//{
// // Console.WriteLine("SQLITE_BUSY_SNAPSHOT");
//}
//else
//{
// //Console.WriteLine("RETRY");
// sw.SpinOnce();
// // Console.WriteLine(rcCommit);
// goto RETRY_COMMIT;
//}
//////// Console.WriteLine("NOT DONE: " + rcTest);
//Rollback();
//BeginConcurrentQuery.Reset();
//TestQuery.Reset();
//CommitQuery.Reset();
//sw.SpinOnce();
//goto RETRY;
}
return(result);
}
catch (Exception ex)
{
ThrowHelper.FailFast("Cannot insert chunk: " + ex);
return(false, 0);
}
finally
{
InsertTestQuery.ClearAndReset();
//BeginConcurrentQuery.Reset();
//CommitQuery.Reset();
}
}
int IBinaryConverter <T> .SizeOf(T value, out RetainedMemory <byte> temporaryBuffer, out bool withPadding)
{
return(SizeOf(value, out temporaryBuffer, out withPadding));
}
public int SizeOf(MyPocoWithConvertor value, out RetainedMemory <byte> temporaryBuffer, out bool withPadding)
{
throw new NotImplementedException();
}
public int SizeOf(SampleStruct value, out RetainedMemory <byte> temporaryBuffer, out bool withPadding)
{
temporaryBuffer = default;
withPadding = default;
return(4);
}
