public void Benchmark_ReadWrite()
{
Int64 size = 100 * 1000000;
using (SmartPtr p = UnmanagedMemory.AllocHGlobalExSmartPtr(size))
{
string fileName = Path.GetTempFileName();
if (File.Exists(fileName))
{
File.Delete(fileName);
}
DateTime start = DateTime.Now;
using (BinaryWriter w = new BinaryWriter(File.Open(fileName, FileMode.CreateNew, FileAccess.Write)))
{
UnmanagedMemory.Write(w, p, size);
}
double time = (DateTime.Now - start).TotalSeconds;
Console.WriteLine("{0:#,#} bytes written to disk in {1:0.00000} s, {2:#,#} b/s", size, time, size / time);
start = DateTime.Now;
using (BinaryReader r = new BinaryReader(File.Open(fileName, FileMode.Open, FileAccess.Read)))
{
UnmanagedMemory.Read(r, p, size);
}
time = (DateTime.Now - start).TotalSeconds;
Console.WriteLine("{0:#,#} bytes read from disk in {1:0.00000} s, {2:#,#} b/s", size, time, size / time);
File.Delete(fileName);
}
}
public void Test_Convert()
{
SmartPtr ptr = UnmanagedMemory.AllocHGlobalExSmartPtr(1);
UInt32 * pUInt32 = (UInt32 *)ptr;
Assert.IsTrue((UInt32 *)ptr.Ptr.ToPointer() == pUInt32);
}
private void Allocate(long nodesCount, int nodeByteSize)
{
_nodesCount = nodesCount;
_nodesByteSize = nodesCount * nodeByteSize;
_depthPtr = UnmanagedMemory.AllocHGlobalExSmartPtr(NodesCount);
_depths = (byte *)_depthPtr;
_nodesPtr = UnmanagedMemory.AllocHGlobalExSmartPtr(_nodesByteSize);
}
static CardSetEvaluator()
{
_LutCardMaskPtr = UnmanagedMemory.AllocHGlobalExSmartPtr(StdDeck.Descriptor.Size * sizeof(UInt64));
pLutCardMask = (UInt64 *)_LutCardMaskPtr;
for (int i = 0; i < StdDeck.Descriptor.Size; ++i)
{
pLutCardMask[i] = StdDeck.Descriptor.CardSets[i].bits;
}
}
void DoTestSetMemory(int byteSize, byte value)
{
using (SmartPtr p = UnmanagedMemory.AllocHGlobalExSmartPtr(byteSize))
{
UnmanagedMemory.SetMemory(p.Ptr, byteSize, value);
for (int i = 0; i < byteSize; ++i)
{
Assert.AreEqual(value, ((byte *)p)[i]);
}
}
}
public void Test_AutoFreeMemory()
{
for (int i = 0; i < 100; ++i)
{
SmartPtr p = UnmanagedMemory.AllocHGlobalExSmartPtr(1000000000);
unsafe
{
// To prevent optimizing away.
((byte *)p)[0] = 1;
}
// Ensure releasing of the pointer.
p = null;
}
}
static LutEvaluator7()
{
string fileName = LutPath;
Exception exception = null;
try
{
using (FileStream file = File.Open(fileName, FileMode.Open, FileAccess.Read, FileShare.Read))
{
using (BinaryReader r = new BinaryReader(file))
{
BdsVersion version = new BdsVersion();
version.Read(r);
UInt32 formatId = r.ReadUInt32();
UInt32 lutSize = r.ReadUInt32();
UInt32 lutByteSize = lutSize * 4;
_lutPtr = UnmanagedMemory.AllocHGlobalExSmartPtr(lutByteSize);
pLut = (UInt32 *)_lutPtr;
UnmanagedMemory.Read(r, _lutPtr, lutByteSize);
}
}
}
catch (Exception e)
{
exception = e;
}
if (exception != null)
{
if (_lutPtr != null)
{
_lutPtr.Dispose();
_lutPtr = null;
}
pLut = (UInt32 *)IntPtr.Zero.ToPointer();
// If IO error occured leave the class uninitialized. This is a normal case for table generation.
// If the application tries to use an uninitialized class, an exception will be thrown somewhere.
// Otherwise rethrow the exception.
if (!(exception is IOException))
{
throw exception;
}
}
}
void DoTestReadWrite(IntPtr p, Int64 size)
{
MemoryStream ms = new MemoryStream();
BinaryWriter w = new BinaryWriter(ms);
UnmanagedMemory.Write(w, p, size);
byte[] buffer = ms.ToArray();
ms = new MemoryStream(buffer);
using (SmartPtr p1 = UnmanagedMemory.AllocHGlobalExSmartPtr(size))
{
BinaryReader r = new BinaryReader(ms);
UnmanagedMemory.Read(r, p1.Ptr, size);
byte *pBytes = (byte *)p;
byte *pBytes1 = (byte *)p1;
for (Int64 i = 0; i < size; ++i)
{
Assert.AreEqual(pBytes[i], pBytes1[i], String.Format("Values differ at pos {0}, size {1}", i, size));
}
p1.Dispose();
}
}
public void Test_ReadWrite_Random()
{
int rngSeed = DateTime.Now.Millisecond;
Console.WriteLine("Rng seed {0}", rngSeed);
Random rng = new Random(rngSeed);
for (int r = 0; r < 1000; ++r)
{
int byteSize = rng.Next(0, 10000);
using (SmartPtr p = UnmanagedMemory.AllocHGlobalExSmartPtr(byteSize))
{
byte *pBytes = (byte *)p;
for (Int64 i = 0; i < byteSize; ++i)
{
pBytes[i] = (byte)rng.Next(0, 256);
}
DoTestReadWrite(p, byteSize);
}
}
}