private static void TestSequential(int count)
{
BitArray array = new BitArray(true, count);
for (int x = 0; x < count; x++)
{
if (!array.GetBit(x))
throw new Exception("each bit should be set");
}
array = new BitArray(false, count);
for (int x = 0; x < count; x++)
{
if (array.GetBit(x))
throw new Exception("each bit should be cleared");
}
for (int x = 0; x < count; x++)
{
array.SetBit(x);
if (!array.GetBit(x))
throw new Exception("each bit should be cleared");
array.ClearBit(x);
if (array.GetBit(x))
throw new Exception("each bit should be cleared");
array.SetBit(x);
if (array.FindClearedBit() != (x == count - 1 ? -1 : x + 1))
throw new Exception();
}
}
/// <summary>
/// Frees a block of memory
/// </summary>
/// <param name="address">The address</param>
public static unsafe void Free(void *address)
{
uint bit = (uint)address / 0x1000;
mutex.Lock();
bitmap.ClearBit((int)bit);
mutex.Unlock();
}
private static void TestSequentialInv(int count)
{
BitArray array = new BitArray(false, count);
for (int x = 0; x < count; x++)
{
if (array.GetBit(x))
{
throw new Exception("each bit should be cleared");
}
}
array = new BitArray(true, count);
for (int x = 0; x < count; x++)
{
if (!array.GetBit(x))
{
throw new Exception("each bit should be set");
}
}
for (int x = 0; x < count; x++)
{
array.ClearBit(x);
if (array.GetBit(x))
{
throw new Exception("each bit should be cleared");
}
array.SetBit(x);
if (!array.GetBit(x))
{
throw new Exception("each bit should be cleared");
}
array.ClearBit(x);
if (array.FindSetBit() != (x == count - 1 ? -1 : x + 1))
{
throw new Exception();
}
}
}
/// <summary>
/// Requests a new block from the buffer pool.
/// </summary>
/// <param name="index">the index identifier of the block</param>
/// <param name="addressPointer">the address to the start of the block</param>
/// <exception cref="OutOfMemoryException">Thrown if the list is full</exception>
public bool TryGetNextPage(out int index, out IntPtr addressPointer)
{
lock (m_syncRoot)
{
if (m_disposed)
{
throw new ObjectDisposedException(GetType().FullName);
}
index = m_isPageFree.FindSetBit();
if (index < 0)
{
index = -1;
addressPointer = IntPtr.Zero;
return(false);
}
m_usedPageCount++;
m_isPageFree.ClearBit(index);
int allocationIndex = index >> m_pagesPerMemoryBlockShiftBits;
int blockOffset = index & m_pagesPerMemoryBlockMask;
Memory block = m_memoryBlocks[allocationIndex];
if (block == null)
{
Log.Publish(MessageLevel.Warning, MessageFlags.BugReport, "Memory Block inside Memory Pool is null. Possible race condition.");
throw new NullReferenceException("Memory Block is null");
}
if (block.Address == IntPtr.Zero)
{
Log.Publish(MessageLevel.Warning, MessageFlags.BugReport, "Memory Block inside Memory Pool was released prematurely. Possible race condition.");
throw new NullReferenceException("Memory Block is null");
}
addressPointer = block.Address + blockOffset * PageSize;
index++;
return(true);
}
}
public void BitArray()
{
MemoryPoolTest.TestMemoryLeak();
Stopwatch sw1 = new Stopwatch();
Stopwatch sw2 = new Stopwatch();
Stopwatch sw3 = new Stopwatch();
Stopwatch sw4 = new Stopwatch();
Stopwatch sw5 = new Stopwatch();
Stopwatch sw6 = new Stopwatch();
const int count = 20 * 1024 * 1024;
//20 million, That's like 120GB of 64KB pages
BitArray array = new BitArray(false, count);
sw1.Start();
for (int x = 0; x < count; x++)
{
array.SetBit(x);
}
sw1.Stop();
sw2.Start();
for (int x = 0; x < count; x++)
{
array.SetBit(x);
}
sw2.Stop();
sw3.Start();
for (int x = 0; x < count; x++)
{
array.ClearBit(x);
}
sw3.Stop();
sw4.Start();
for (int x = 0; x < count; x++)
{
array.ClearBit(x);
}
sw4.Stop();
sw5.Start();
for (int x = 0; x < count; x++)
{
if (array.GetBitUnchecked(x))
{
throw new Exception();
}
}
sw5.Stop();
//for (int x = 0; x < count -1; x++)
//{
// array.SetBit(x);
//}
sw6.Start();
for (int x = 0; x < count; x++)
{
array.SetBit(array.FindClearedBit());
}
sw6.Stop();
System.Console.WriteLine("Set Bits: " + (count / sw1.Elapsed.TotalSeconds / 1000000).ToString("0.0 MPP"));
System.Console.WriteLine("Set Bits Again: " + (count / sw2.Elapsed.TotalSeconds / 1000000).ToString("0.0 MPP"));
System.Console.WriteLine("Clear Bits: " + (count / sw3.Elapsed.TotalSeconds / 1000000).ToString("0.0 MPP"));
System.Console.WriteLine("Clear Bits Again: " + (count / sw4.Elapsed.TotalSeconds / 1000000).ToString("0.0 MPP"));
System.Console.WriteLine("Get Bits: " + (count / sw5.Elapsed.TotalSeconds / 1000000).ToString("0.0 MPP"));
System.Console.WriteLine("Find Cleared Bit (All bits cleared): " + (count / sw6.Elapsed.TotalSeconds / 1000000).ToString("0.0 MPP"));
MemoryPoolTest.TestMemoryLeak();
}
public void BitArray()
{
MemoryPoolTest.TestMemoryLeak();
Stopwatch sw1 = new Stopwatch();
Stopwatch sw2 = new Stopwatch();
Stopwatch sw3 = new Stopwatch();
Stopwatch sw4 = new Stopwatch();
Stopwatch sw5 = new Stopwatch();
Stopwatch sw6 = new Stopwatch();
const int count = 20 * 1024 * 1024;
//20 million, That's like 120GB of 64KB pages
BitArray array = new BitArray(false, count);
sw1.Start();
for (int x = 0; x < count; x++)
{
array.SetBit(x);
}
sw1.Stop();
sw2.Start();
for (int x = 0; x < count; x++)
{
array.SetBit(x);
}
sw2.Stop();
sw3.Start();
for (int x = 0; x < count; x++)
{
array.ClearBit(x);
}
sw3.Stop();
sw4.Start();
for (int x = 0; x < count; x++)
{
array.ClearBit(x);
}
sw4.Stop();
sw5.Start();
for (int x = 0; x < count; x++)
{
if (array.GetBitUnchecked(x))
throw new Exception();
}
sw5.Stop();
//for (int x = 0; x < count -1; x++)
//{
// array.SetBit(x);
//}
sw6.Start();
for (int x = 0; x < count; x++)
{
array.SetBit(array.FindClearedBit());
}
sw6.Stop();
System.Console.WriteLine("Set Bits: " + (count / sw1.Elapsed.TotalSeconds / 1000000).ToString("0.0 MPP"));
System.Console.WriteLine("Set Bits Again: " + (count / sw2.Elapsed.TotalSeconds / 1000000).ToString("0.0 MPP"));
System.Console.WriteLine("Clear Bits: " + (count / sw3.Elapsed.TotalSeconds / 1000000).ToString("0.0 MPP"));
System.Console.WriteLine("Clear Bits Again: " + (count / sw4.Elapsed.TotalSeconds / 1000000).ToString("0.0 MPP"));
System.Console.WriteLine("Get Bits: " + (count / sw5.Elapsed.TotalSeconds / 1000000).ToString("0.0 MPP"));
System.Console.WriteLine("Find Cleared Bit (All bits cleared): " + (count / sw6.Elapsed.TotalSeconds / 1000000).ToString("0.0 MPP"));
MemoryPoolTest.TestMemoryLeak();
}