public void CouldAllocateAndDropAboveSystemMemory()
{
// Test that PM is forcefully finalized
Settings.PrivateMemoryPerCorePoolSize = 1024 * 1024;
GCSettings.LatencyMode = GCLatencyMode.SustainedLowLatency;
for (int i = 0; i < 100; i++)
{
var pm = PrivateMemory <long> .Create(1 * 1024 * 1024);
Task.Run(async() =>
{
await Task.Yield();
pm.CounterRef |= AtomicCounter.Disposed;
pm.Free(true);
GC.SuppressFinalize(pm);
}).Wait();
// GC.AddMemoryPressure(1 * 1024 * 1024);
// pm.Dispose();
// GC.Collect();
}
Console.WriteLine("Done");
}
public void CouldCreateDisposePrivateMemory()
{
var count = TestUtils.GetBenchCount();
var init = PrivateMemory <byte> .Create(64 * 1024);
PrivateMemory <byte>[] items = new PrivateMemory <byte> [count];
for (int _ = 0; _ < 20; _++)
{
using (Benchmark.Run("CreateDispose", count))
{
for (int i = 0; i < count; i++)
{
items[i] = PrivateMemory <byte> .Create(64 * 1024);
items[i].Dispose();
}
}
//
// using (Benchmark.Run("Dispose", count))
// {
// for (int i = 0; i < count; i++)
// {
// items[i].Dispose();
// }
// }
}
init.Dispose();
Benchmark.Dump();
// Mem.Collect(true);
Mem.StatsPrint();
}
public void MemoryAccessBench()
{
var count = (int)TestUtils.GetBenchCount(500_000_000);
var rm = PrivateMemory <int> .Create(count);
for (int i = 0; i < count; i++)
{
rm.Vec.DangerousGetRef <int>(i) = i;
}
for (int r = 0; r < 10; r++)
{
MemoryAccessViaPointer(rm);
MemoryAccessVecViaFieldDangerous(rm);
MemoryAccessVecViaLocalDangerous(rm);
MemoryAccessVecViaLocalUnsafe(rm);
MemoryAccessVecViaHelperUnsafe(rm);
MemoryAccessVecViaDbHelperUnsafe(rm);
MemoryAccessVecViaDbHelperDangerous(rm);
MemoryAccessVecViaDbHelperUnsafeGetRef(rm);
MemoryAccessVecViaDbVecUnsafe(rm);
MemoryAccessVecViaDbVecPointer(rm);
MemoryAccessVecViaDbVecDangerous(rm);
MemoryAccessVecViaDbVecStorageUnsafe(rm);
MemoryAccessVecViaDbVecStorageDangerous(rm);
}
Benchmark.Dump();
rm.Dispose();
}
public void MemoryFieldBench()
{
var count = (int)4 * 1024; // TestUtils.GetBenchCount(1_000_000);
var rm = PrivateMemory <int> .Create(count);
var arr = new int[count];
DataBlockLike db = new DataBlockLike {
Rm = rm, Vec = rm.GetVec().AsVec(), RetainedVec = RetainedVec.Create(rm, 0, rm.Length, true), Length = rm.Length
};
for (int i = 0; i < count; i++)
{
db.RetainedVec.UnsafeWriteUnaligned((IntPtr)i, i);
arr[i] = i;
}
for (int r = 0; r < 10; r++)
{
MemoryFieldBench_Field(rm);
MemoryFieldBench_CreateMem(rm);
}
Benchmark.Dump();
rm.Dispose();
}
public void CtorDoesntThrowsOnBadLength()
{
var length = -1;
using var pm = PrivateMemory <byte> .Create(-1);
Assert.AreEqual((int)Mem.GoodSize((UIntPtr)Settings.MIN_POOLED_BUFFER_LEN), pm.Length);
Console.WriteLine(pm.Length);
}
public void CtorLengthEqualsToGoodSize()
{
// using var pm1 = PrivateMemory<byte>.Create(160);
for (int length = 16; length < 1024 * 1024; length += 128)
{
using var pm = PrivateMemory <Size5> .Create(length);
// Assert.AreEqual(Mem.GoodSize((UIntPtr) BitUtil.Align(length, 64)), pm.Length);
Console.WriteLine($"{length:N0} -> {Mem.GoodSize((UIntPtr) length)} -> {pm.Length:N0} -> {pm.Length * Unsafe.SizeOf<Size5>():N0}");
}
}
public static RetainableMemory <long> CreateFilledRM(int capacity)
{
var rm = PrivateMemory <long> .Create(capacity);
var vec = rm.GetVec();
for (long i = 0; i < rm.Length; i++)
{
vec.UnsafeSetUnaligned((IntPtr)i, i);
}
return(rm);
}
public unsafe void SetUp()
{
var rng = new Random();
_count = Count;
_idx = rng.Next(_count / 4, _count / 2);
_idxLong = _idx;
_rm = PrivateMemory <int> .Create(_count);
_arr = new int[_count];
_db = new DataBlockLike
{
Rm = _rm, Vec = _rm.GetVec().AsVec(), RetainedVec = RetainedVec.Create(_rm, 0, _rm.Length, true), Length = _rm.Length, arr = _arr, Ptr = (int *)_rm.Pointer
};
_vec = _rm.GetVec().AsVec();
for (int i = 0; i < _count; i++)
{
_db.RetainedVec.UnsafeWriteUnaligned((IntPtr)i, i + 1);
_arr[i] = i + 1;
}
}
public void MemoryAccessBench()
{
var count = (int)4 * 1024; // TestUtils.GetBenchCount(1_000_000);
var rm = PrivateMemory <int> .Create(count);
var arr = new int[count];
DataBlockLike db = new DataBlockLike {
Rm = rm, Vec = rm.GetVec().AsVec(), RetainedVec = RetainedVec.Create(rm, 0, rm.Length, true), Length = rm.Length
};
for (int i = 0; i < count; i++)
{
db.RetainedVec.UnsafeWriteUnaligned((IntPtr)i, i);
arr[i] = i;
}
for (int r = 0; r < 10; r++)
{
Sum(rm);
MemoryAccessViaPointer(rm);
MemoryAccessViaArray(rm, arr);
// MemoryAccessVecViaMemSpan(rm);
// MemoryAccessVecViaLocalDangerous(rm);
// MemoryAccessVecViaLocalUnsafe(rm);
MemoryAccessVecViaDbVecUnsafe(rm);
MemoryAccessVecViaDbVecStorageRead(rm);
// MemoryAccessVecViaDbVecUnsafeX(rm);
MemoryAccessVecViaDbVecPointer(rm);
// MemoryAccessVecViaDbVecDangerous(rm);
MemoryAccessVecViaDbVecStorageUnsafe(rm);
MemoryAccessVecViaDbVecStorageDangerous(rm);
Thread.Sleep(100);
}
Benchmark.Dump();
rm.Dispose();
}
public void RingVecIndexing()
{
var count = (int)TestUtils.GetBenchCount(128 * 1024, 128);
var rm = PrivateMemory <int> .Create(count);
var rv = RetainedVec.Create(rm, 0, rm.Length, true);
for (int i = 0; i < count; i++)
{
rv.UnsafeWriteUnaligned((IntPtr)i, i);
}
for (int r = 0; r < 10; r++)
{
RingVecUtilIndexToOffset(rm);
DirectPointer(rm);
Modulo(rm);
Binary(rm);
}
Benchmark.Dump();
rm.Dispose();
}
public void CouldSerializeVectorStorage()
{
var rng = new Random(42);
var count = 100_000;
var arr = new SmallDecimal[count];
var r = PrivateMemory <SmallDecimal> .Create(count);
var vec = r.GetVec();
vec[0] = new SmallDecimal(1000 * 1.0, 4);
for (int i = 1; i < count; i++)
{
vec[i] = vec[i - 1] + new SmallDecimal((double)vec[i - 1] * (0.02 + -0.04 * rng.NextDouble()), 4);
}
var vs = RetainedVec.Create(r, 0, r.Length);
var vsT = new RetainedVec <SmallDecimal>(vs);
var payload = count * Unsafe.SizeOf <double>() + 4;
foreach (SerializationFormat format in ((SerializationFormat[])Enum.GetValues(typeof(SerializationFormat))).OrderBy(e => e.ToString()))
{
var len = BinarySerializer.SizeOf(in vsT, out var rm, format);
var destination = BufferPool.Retain(len);
var destinationDb = new DirectBuffer(destination);
var len1 = BinarySerializer.Write(in vsT, destinationDb, rm, format);
Assert.AreEqual(destination.Length, destinationDb.Length);
Assert.AreEqual(len, len1);
var flags = destinationDb.Read <VersionAndFlags>(0);
Assert.AreEqual(format, flags.SerializationFormat);
var header = destinationDb.Read <DataTypeHeader>(0);
Assert.AreEqual(TypeEnum.Array, header.TEOFS.TypeEnum);
Assert.AreEqual(TypeEnum.SmallDecimal, header.TEOFS1.TypeEnum);
Assert.AreEqual(Unsafe.SizeOf <SmallDecimal>(), header.TEOFS1.Size);
var len2 = BinarySerializer.Read(destinationDb, out RetainedVec <SmallDecimal> value);
Assert.AreEqual(destination.Length, destinationDb.Length);
Assert.AreEqual(len, len2);
Assert.AreEqual(vs.Vec.Length, value.Storage.Vec.Length);
for (int i = 0; i < count; i++)
{
SmallDecimal left;
SmallDecimal right;
if ((left = vs.Vec.DangerousGetUnaligned <SmallDecimal>(i)) != (right = value.Storage.Vec.DangerousGetUnaligned <SmallDecimal>(i)))
{
Console.WriteLine("Not equals");
}
}
Assert.IsTrue(vs.Vec.Slice(0, vs.Vec.Length).AsSpan <SmallDecimal>().SequenceEqual(value.Storage.Vec.Slice(0, value.Storage.Vec.Length).AsSpan <SmallDecimal>()));
Console.WriteLine($"{format} len: {len:N0} x{Math.Round((double) payload / len, 2)}");
destination.Dispose();
value.Storage.Dispose();
}
vs.Dispose();
}