public void FillNativeArray()
{
SafeArray <T> nativeArray = GetValue <SafeArray <T> >("nativeArray");
T fill = GetValue <T>("fill");
nativeArray.Fill(fill);
}
public void ArithmeticMultiplyCleanup()
{
InfoThis();
int index = GM <T> .Rng.Next(0, ArraySize);
SafeArray <T> nativeArray = GetValue <SafeArray <T> >("nativeArray");
T[] managedArray = GetValue <T[]>("managedArray");
T mul = GetValue <T>("mul");
T fill = GetValue <T>("fill");
T val = GM <T> .Multiply(fill, mul);
if (!nativeArray[index].Equals(val))
{
Log.WriteLineError($"Native array at index {index} is {nativeArray[index]} not {val}.");
throw new Exception();
}
else if (!managedArray[index].Equals(val))
{
Log.WriteLineError($"Managed array at index {index} is {managedArray[index]} not {val}.");
throw new Exception();
}
managedArray = null;
nativeArray.Release();
RemoveValue("managedArray");
RemoveValue("nativeArray");
RemoveValue("fill");
RemoveValue("mul");
}
public UDTTests()
{
Employees = new SafeArray <TestUDT>(1024 * 1024);
for (int i = 0; i < Employees.Length; i++)
{
Employees[i] = TestUDT.MakeTestRecord(JemUtil.Rng);
}
}
public void ArithmeticMultiplyNativeArray()
{
T mul = GetValue <T>("mul");
T fill = GetValue <T>("fill");
SafeArray <T> array = GetValue <SafeArray <T> >("nativeArray");
array.Fill(fill);
array.VectorMultiply(mul);
}
public void GlobalSetup()
{
managedArray = new T[ArraySize];
nativeArray = new SafeArray <T>(ArraySize);
fill = GetArrayFillValue();
mul = GetArrayMulValue();
Console.WriteLine("Managed array fill value is {0}.", fill);
Console.WriteLine("Multiply factor is {0}", mul);
}
public void FragmentNativeHeap()
{
Info($"Dirty decay time: {Jem.GetMallCtlSInt64("arenas.dirty_decay_ms")} ms");
int largeBlockSize = InitialLargeBlockSize;
SafeArray <FixedBuffer <T> > smallBlocks = new SafeArray <FixedBuffer <T> >(LoopCount);
int i = 0;
FixedBuffer <T> bigBlock = default;
try
{
for (i = 0; i < LoopCount; i++)
{
bigBlock = new FixedBuffer <T>(largeBlockSize);
FixedBuffer <T> smallBlock = new FixedBuffer <T>(SmallBlockSize);
int j = JemUtil.Rng.Next(0, ArraySize);
T r = GM <T> .Random();
smallBlock[j] = r;
smallBlocks[i] = smallBlock;
if (!smallBlocks[i][j].Equals(r))
{
throw new Exception($"Cannot validate small block at index {i}.");
}
if (!bigBlock.Free())
{
throw new Exception("Cannot free bigBlock.");
}
largeBlockSize = largeBlockSize + (1 * 1024 * 1024);
}
this.SetStatistic($"{nameof(FragmentNativeHeap)}_WorkingSet", JemUtil.PrintBytes(JemUtil.ProcessWorkingSet));
this.SetStatistic($"{nameof(FragmentNativeHeap)}_JemResident", JemUtil.PrintBytes(Jem.ResidentBytes));
this.SetStatistic($"{nameof(FragmentNativeHeap)}_PrivateMemory", JemUtil.PrintBytes(JemUtil.ProcessPrivateMemory));
this.SetStatistic($"{nameof(FragmentNativeHeap)}_JemAllocated", JemUtil.PrintBytes(Jem.AllocatedBytes));
foreach (FixedBuffer <T> b in smallBlocks)
{
if (!b.Free())
{
throw new Exception($"Cannot free small block at index {i}.");
}
}
}
catch (OutOfMemoryException)
{
Info(Jem.MallocStats);
Error($"Out-of-Memory at index {i} with large block size {largeBlockSize}.");
foreach (FixedBuffer <T> b in smallBlocks)
{
b.Free();
}
throw;
}
finally
{
GC.Collect();
}
}
public void FillNativeArrayWithCreate()
{
SafeArray <T> nativeArray = new SafeArray <T>(ArraySize);
T fill = GetValue <T>("fill");
nativeArray.Fill(fill);
nativeArray.Release();
nativeArray.Close();
nativeArray = null;
}
public void CanVectorizedMultiply()
{
SafeArray <uint> a = new SafeArray <uint>(8, 1, 2, 3, 4, 5, 6, 7, 8);
SafeArray <int> b = new SafeArray <int>(8, 111, 22, 345, 40888, 3, 777, 99, 6);
a.VectorMultiply(2);
Assert.Equal(2u, a[0]);
Assert.Equal(8u, a[3]);
Assert.Equal(16u, a[7]);
b.VectorMultiply(6);
Assert.Equal(666, b[0]);
}
static MethodDefinitionName MakeAssertNotNull()
{
return(MethodDefinitionName.FromTypeMethod(
0,
Type_Assert.Definition,
true,
"NotNull",
SafeArray.Empty <string>(),
SystemTypes.Void.SerializableName,
new ParameterDefinitionName(SystemTypes.Object.SerializableName, "condition", 0, false, ParameterDirection.ByValueOrRef)
));
}
public void CanConvertToVector()
{
SafeArray <uint> a = new SafeArray <uint>(8, 1, 11, 94, 5, 0, 0, 0, 8);
Vector <uint> v = a.AcquireAsSingleVector();
Assert.Equal(a[0], v[0]);
Assert.Equal(a[3], v[3]);
Assert.Equal(a[7], v[7]);
SafeArray <uint> a2 = new SafeArray <uint>(12, 11, 112, 594, 65, 0, 0, 0, 8, 14, 90, 2, 8);
Vector <uint> v2 = a2.AcquireSliceAsVector(2);
Assert.Equal(594u, v2[0]);
}
public void FillSetup()
{
InfoThis();
T fill = GM <T> .Random();
Info($"Array fill value is {fill}.");
SetValue("fill", fill);
SetValue("managedArray", new T[ArraySize]);
SafeArray <T> nativeArray = new SafeArray <T>(ArraySize);
nativeArray.Acquire();
SetValue("nativeArray", new SafeArray <T>(ArraySize));
}
private FixedBuffer <int> Mandelbrotv1Unmanaged()
{
SafeArray <Vector <float> > Vectors = new SafeArray <Vector <float> >(8); // New unmanaged array of vectors
FixedBuffer <int> output = new FixedBuffer <int>(((int)Mandelbrot_Width * (int)Mandelbrot_Height)); //New unmanaged array for bitmap output
Span <float> VectorSpan = Vectors.GetSpan <float>(); //Lets us write to individual vector elements
Span <Vector2> Vector2Span = Vectors.GetSpan <Vector2>(); //Lets us read to individual vectors
VectorSpan[0] = -2f;
VectorSpan[1] = -1f;
VectorSpan[2] = 1f;
VectorSpan[3] = 1f;
VectorSpan[4] = Mandelbrot_Width;
VectorSpan[5] = Mandelbrot_Height;
ref Vector2 C0 = ref Vector2Span[0];
public void CanConstructSafeArray()
{
SafeArray <int> a = new SafeArray <int>(500);
a[1] = 1000;
Assert.Equal(1000, a[1]);
a.Acquire();
Assert.Equal(1000, a[1]);
a.Acquire();
a.Release();
Assert.Equal(1000, a[1]);
a.Release();
Assert.Equal(1000, a[1]);
a.Close();
Assert.True(a.IsClosed);
Assert.Throws <ObjectDisposedException>(() => a[1] == 1000);
//int r = a[(2,3)]
}
public void CleanupFillArray()
{
Info(nameof(CleanupFillArray));
T[] managedArray = GetValue <T[]>("managedArray");
SafeArray <T> nativeArray = GetValue <SafeArray <T> >("nativeArray");
T fill = GetValue <T>("fill");
int index = GM <T> .Rng.Next(0, ArraySize);
if (!nativeArray[index].Equals(managedArray[index]))
{
Log.WriteLineError($"Native array at index {index} is {nativeArray[index]} not {fill}.");
throw new Exception();
}
nativeArray.Release();
managedArray = null;
RemoveValue("managedArray");
RemoveValue("nativeArray");
RemoveValue("fill");
}
public void ArithmeticMutiplyGlobalSetup()
{
InfoThis();
(T mul, T fill) = GM <T> .RandomMultiplyFactorAndValue();
SafeArray <T> na = new SafeArray <T>(ArraySize);
T[] ma = new T[ArraySize];
Info($"Array fill value is {fill}.");
Info($"Array mul value is {mul}.");
na.Fill(fill);
for (int i = 0; i < ma.Length; i++)
{
ma[i] = fill;
}
na.Acquire();
SetValue("fill", fill);
SetValue("mul", mul);
SetValue("managedArray", ma);
SetValue("nativeArray", na);
}
public TCPClientData(uint maxCount)
{
RecvList = new SafeArray <TCPRecvData>(maxCount);
SendList = new SafeArray <byte[]>(maxCount);
}
public TestClass()
{
Ids = new SafeArray <int>(5);
Instances = new SafeArray <MyClass>(5);
}
public void CreateNativeArray()
{
SafeArray <T> array = new SafeArray <T>(ArraySize);
}
