public void BenchmarkTwoFiles()
{
MemoryPoolTest.TestMemoryLeak();
const int Max = 1000000;
ArchiveList <HistorianKey, HistorianValue> list = new ArchiveList <HistorianKey, HistorianValue>(null);
HistorianKey key = new HistorianKey();
HistorianValue value = new HistorianValue();
SortedTreeTable <HistorianKey, HistorianValue> table1 = CreateTable();
SortedTreeTable <HistorianKey, HistorianValue> table2 = CreateTable();
AddData(table1, 100, 100, Max / 2);
AddData(table2, 101, 100, Max / 2);
using (ArchiveListEditor <HistorianKey, HistorianValue> editor = list.AcquireEditLock())
{
editor.Add(table1);
editor.Add(table2);
}
SequentialReaderStream <HistorianKey, HistorianValue> sequencer = new SequentialReaderStream <HistorianKey, HistorianValue>(list);
DebugStopwatch sw = new DebugStopwatch();
double sec = sw.TimeEvent(() =>
{
SequentialReaderStream <HistorianKey, HistorianValue> scanner = sequencer;
while (scanner.Read(key, value))
{
}
});
System.Console.WriteLine(Max / sec / 1000000);
list.Dispose();
MemoryPoolTest.TestMemoryLeak();
}
public void TestOneFile()
{
HistorianKey key1 = new HistorianKey();
HistorianKey key2 = new HistorianKey();
HistorianValue value1 = new HistorianValue();
HistorianValue value2 = new HistorianValue();
Logger.Console.Verbose = VerboseLevel.All;
MemoryPoolTest.TestMemoryLeak();
ArchiveList <HistorianKey, HistorianValue> list = new ArchiveList <HistorianKey, HistorianValue>(null);
SortedTreeTable <HistorianKey, HistorianValue> master = CreateTable();
SortedTreeTable <HistorianKey, HistorianValue> table1 = CreateTable();
AddData(master, 100, 100, 100);
AddData(table1, 100, 100, 100);
using (ArchiveListEditor <HistorianKey, HistorianValue> editor = list.AcquireEditLock())
{
editor.Add(table1);
}
using (SortedTreeTableReadSnapshot <HistorianKey, HistorianValue> masterRead = master.BeginRead())
{
SortedTreeScannerBase <HistorianKey, HistorianValue> masterScan = masterRead.GetTreeScanner();
masterScan.SeekToStart();
TreeStreamSequential <HistorianKey, HistorianValue> masterScanSequential = masterScan.TestSequential();
using (SequentialReaderStream <HistorianKey, HistorianValue> sequencer = new SequentialReaderStream <HistorianKey, HistorianValue>(list))
{
TreeStreamSequential <HistorianKey, HistorianValue> scanner = sequencer.TestSequential();
int count = 0;
while (scanner.Read(key1, value1))
{
count++;
if (!masterScanSequential.Read(key2, value2))
{
throw new Exception();
}
if (!key1.IsEqualTo(key2))
{
throw new Exception();
}
if (!value1.IsEqualTo(value2))
{
throw new Exception();
}
}
if (masterScan.Read(key2, value2))
{
throw new Exception();
}
}
}
list.Dispose();
master.Dispose();
MemoryPoolTest.TestMemoryLeak();
}
public void BenchmarkRawFile()
{
MemoryPoolTest.TestMemoryLeak();
const int Max = 1000000;
HistorianKey key = new HistorianKey();
HistorianValue value = new HistorianValue();
SortedTreeTable <HistorianKey, HistorianValue> master = CreateTable();
AddData(master, 100, 100, Max);
DebugStopwatch sw = new DebugStopwatch();
using (SortedTreeTableReadSnapshot <HistorianKey, HistorianValue> masterRead = master.BeginRead())
{
double sec = sw.TimeEvent(() =>
{
SortedTreeScannerBase <HistorianKey, HistorianValue> scanner = masterRead.GetTreeScanner();
scanner.SeekToStart();
while (scanner.Read(key, value))
{
}
});
System.Console.WriteLine(Max / sec / 1000000);
}
master.Dispose();
MemoryPoolTest.TestMemoryLeak();
}
public void TestSequentialWriteAmplification()
{
MemoryPoolTest.TestMemoryLeak();
double size;
Stats.ChecksumCount = 0;
DiskIoSession.WriteCount = 0;
DiskIoSession.ReadCount = 0;
using (TransactionalFileStructure file = TransactionalFileStructure.CreateInMemory(4096))
using (TransactionalEdit edit = file.BeginEdit())
using (SubFileStream stream = edit.CreateFile(SubFileName.CreateRandom()))
using (BinaryStream bs = new BinaryStream(stream))
{
Stats.ChecksumCount = 0;
DiskIoSession.WriteCount = 0;
DiskIoSession.ReadCount = 0;
//Write 8 million
for (long s = 0; s < 1000000; s++)
{
bs.Write(s);
}
size = bs.Position / 4096.0;
}
System.Console.WriteLine("Read: " + (DiskIoSession.ReadCount / size).ToString("0.0"));
System.Console.WriteLine("Write: " + (DiskIoSession.WriteCount / size).ToString("0.0"));
System.Console.WriteLine("Checksums: " + (Stats.ChecksumCount / size).ToString("0.0"));
MemoryPoolTest.TestMemoryLeak();
}
public void Test()
{
MemoryPoolTest.TestMemoryLeak();
int x = 0;
ResourceQueue <string> queue = new ResourceQueue <string>(() => (x++).ToString(), 3, 4);
x = 10;
Assert.AreEqual(queue.Dequeue(), "0");
Assert.AreEqual(queue.Dequeue(), "1");
Assert.AreEqual(queue.Dequeue(), "2");
Assert.AreEqual(queue.Dequeue(), "10");
Assert.AreEqual(queue.Dequeue(), "11");
queue.Enqueue("0");
queue.Enqueue("1");
Assert.AreEqual(queue.Dequeue(), "0");
queue.Enqueue("3");
Assert.AreEqual(queue.Dequeue(), "1");
Assert.AreEqual(queue.Dequeue(), "3");
Assert.AreEqual(queue.Dequeue(), "12");
queue.Enqueue("1");
queue.Enqueue("2");
queue.Enqueue("3");
queue.Enqueue("4");
queue.Enqueue("5");
Assert.AreEqual(queue.Dequeue(), "1");
Assert.AreEqual(queue.Dequeue(), "2");
Assert.AreEqual(queue.Dequeue(), "3");
Assert.AreEqual(queue.Dequeue(), "4");
Assert.AreEqual(queue.Dequeue(), "13");
MemoryPoolTest.TestMemoryLeak();
}
public void ConsoleTest3()
{
MemoryPoolTest.TestMemoryLeak();
ArchiveList <HistorianKey, HistorianValue> list = new ArchiveList <HistorianKey, HistorianValue>(null);
DateTime start = DateTime.Now.Date;
for (int x = 0; x < 3; x++)
{
SortedTreeTable <HistorianKey, HistorianValue> table1 = CreateTable();
AddDataTerminal(table1, (ulong)x, start, new TimeSpan(TimeSpan.TicksPerSecond), (ulong)(1000 * x), 1, 60 * 60);
using (ArchiveListEditor <HistorianKey, HistorianValue> editor = list.AcquireEditLock())
{
editor.Add(table1);
}
}
for (int x = 0; x < 3; x++)
{
SortedTreeTable <HistorianKey, HistorianValue> table1 = CreateTable();
AddDataTerminal(table1, (ulong)x, start, new TimeSpan(TimeSpan.TicksPerSecond), (ulong)(1000 * x), 1, 60 * 60);
using (ArchiveListEditor <HistorianKey, HistorianValue> editor = list.AcquireEditLock())
{
editor.Add(table1);
}
}
SeekFilterBase <HistorianKey> filter = TimestampSeekFilter.CreateFromIntervalData <HistorianKey>(start, start.AddMinutes(10), new TimeSpan(TimeSpan.TicksPerSecond * 60), new TimeSpan(TimeSpan.TicksPerSecond));
SequentialReaderStream <HistorianKey, HistorianValue> sequencer = new SequentialReaderStream <HistorianKey, HistorianValue>(list, null, filter);
SortedList <DateTime, FrameData> frames = sequencer.GetFrames();
WriteToConsole(frames);
list.Dispose();
MemoryPoolTest.TestMemoryLeak();
}
public void TestTwoIdenticalFiles()
{
MemoryPoolTest.TestMemoryLeak();
ArchiveList <HistorianKey, HistorianValue> list = new ArchiveList <HistorianKey, HistorianValue>(null);
HistorianKey key1 = new HistorianKey();
HistorianKey key2 = new HistorianKey();
HistorianValue value1 = new HistorianValue();
HistorianValue value2 = new HistorianValue();
var master = CreateTable();
var table1 = CreateTable();
var table2 = CreateTable();
AddData(master, 100, 100, 100);
AddData(table1, 100, 100, 100);
AddData(table2, 100, 100, 100);
using (var editor = list.AcquireEditLock())
{
editor.Add(table1);
editor.Add(table2);
}
using (var masterRead = master.BeginRead())
{
var masterScan = masterRead.GetTreeScanner();
masterScan.SeekToStart();
var masterScanSequential = masterScan.TestSequential();
using (var sequencer = new SequentialReaderStream <HistorianKey, HistorianValue>(list))
{
var scanner = sequencer.TestSequential();
while (scanner.Read(key1, value1))
{
if (!masterScanSequential.Read(key2, value2))
{
throw new Exception();
}
if (!key1.IsEqualTo(key2))
{
throw new Exception();
}
if (!value1.IsEqualTo(value2))
{
throw new Exception();
}
}
if (masterScan.Read(key2, value2))
{
throw new Exception();
}
}
}
list.Dispose();
master.Dispose();
MemoryPoolTest.TestMemoryLeak();
}
public void Test1()
{
MemoryPoolTest.TestMemoryLeak();
Test(0);
Test(1);
Test(2);
Test(100);
Test(1000);
MemoryPoolTest.TestMemoryLeak();
}
public void Test2()
{
MemoryPoolTest.TestMemoryLeak();
TestWithRenumber(0);
TestWithRenumber(1);
TestWithRenumber(2);
TestWithRenumber(100);
TestWithRenumber(1000);
MemoryPoolTest.TestMemoryLeak();
}
public void Benchmark()
{
MemoryPoolTest.TestMemoryLeak();
Benchmark(0, "Direct\t");
Benchmark(AddressesPerBlock - 1, "Single\t");
Benchmark(AddressesPerBlock * AddressesPerBlock - 1, "Double\t");
Benchmark(AddressesPerBlock * AddressesPerBlock * AddressesPerBlock - 1, "Triple\t");
Benchmark(AddressesPerBlock * AddressesPerBlock * AddressesPerBlock * AddressesPerBlock - 1, "Last\t");
MemoryPoolTest.TestMemoryLeak();
}
public void RunMemoryStreamTest()
{
MemoryPoolTest.TestMemoryLeak();
MemoryPoolStream ms = new MemoryPoolStream();
BinaryStream bs = new BinaryStream(ms);
Run(bs, false);
ms.Dispose();
MemoryPoolTest.TestMemoryLeak();
}
public void Test1()
{
MemoryPoolTest.TestMemoryLeak();
DebugStopwatch sw = new DebugStopwatch();
for (int max = 10; max < 10000; max *= 2)
{
Action add1 = () =>
{
SortedList <int, int> list = new SortedList <int, int>();
for (int x = 0; x < max; x++)
{
list.Add(x, x);
}
};
Action add2 = () =>
{
List <int> keys = new List <int>(max);
List <int> values = new List <int>(max);
for (int x = 0; x < max; x++)
{
keys.Add(x);
values.Add(x);
}
var sl = SortedListConstructor.Create(keys, values);
};
//var makeList = new SortedListConstructorUnsafe<int, int>();
//Action add3 = () =>
//{
// List<int> keys = new List<int>(max);
// List<int> values = new List<int>(max);
// for (int x = 0; x < max; x++)
// {
// keys.Add(x);
// values.Add(x);
// }
// var sl = makeList.Create(keys, values);
// //var sl = SortedListConstructor.CreateUnsafe(keys, values);
//};
System.Console.WriteLine("Old Method " + max + " " + sw.TimeEvent(add1) * 1000000);
System.Console.WriteLine("New Method " + max + " " + sw.TimeEvent(add2) * 1000000);
//Console.WriteLine("Unsafe Method " + max + " " + sw.TimeEvent(add3) * 1000000);
MemoryPoolTest.TestMemoryLeak();
}
}
public void BenchmarkRealisticSamples()
{
MemoryPoolTest.TestMemoryLeak();
const int Max = 1000000;
const int FileCount = 1000;
ArchiveList <HistorianKey, HistorianValue> list = new ArchiveList <HistorianKey, HistorianValue>(null);
DateTime start = DateTime.Now.Date;
HistorianKey key = new HistorianKey();
HistorianValue value = new HistorianValue();
for (int x = 0; x < FileCount; x++)
{
SortedTreeTable <HistorianKey, HistorianValue> table1 = CreateTable();
AddData(table1, start.AddMinutes(2 * x), new TimeSpan(TimeSpan.TicksPerSecond), 60, 100, 1, Max / 60 / FileCount);
using (ArchiveListEditor <HistorianKey, HistorianValue> editor = list.AcquireEditLock())
{
editor.Add(table1);
}
}
SeekFilterBase <HistorianKey> filter = TimestampSeekFilter.CreateFromIntervalData <HistorianKey>(start, start.AddMinutes(2 * FileCount), new TimeSpan(TimeSpan.TicksPerSecond * 2), new TimeSpan(TimeSpan.TicksPerMillisecond));
SequentialReaderStream <HistorianKey, HistorianValue> sequencer = new SequentialReaderStream <HistorianKey, HistorianValue>(list, null, filter);
DebugStopwatch sw = new DebugStopwatch();
int xi = 0;
double sec = sw.TimeEvent(() =>
{
SequentialReaderStream <HistorianKey, HistorianValue> scanner = sequencer;
while (scanner.Read(key, value))
{
xi++;
}
});
System.Console.WriteLine(Max / sec / 1000000);
//TreeKeyMethodsBase<HistorianKey>.WriteToConsole();
//TreeValueMethodsBase<HistorianValue>.WriteToConsole();
//Console.WriteLine("KeyMethodsBase calls");
//for (int x = 0; x < 23; x++)
//{
// Console.WriteLine(TreeKeyMethodsBase<HistorianKey>.CallMethods[x] + "\t" + ((TreeKeyMethodsBase<HistorianKey>.Method)(x)).ToString());
//}
//Console.WriteLine("ValueMethodsBase calls");
//for (int x = 0; x < 5; x++)
//{
// Console.WriteLine(TreeValueMethodsBase<HistorianValue>.CallMethods[x] + "\t" + ((TreeValueMethodsBase<HistorianValue>.Method)(x)).ToString());
//}
list.Dispose();
MemoryPoolTest.TestMemoryLeak();
}
public void BitArray()
{
MemoryPoolTest.TestMemoryLeak();
Random rand = new Random();
int seed = rand.Next();
TestSequential(rand.Next(30));
TestSequentialInv(rand.Next(30));
TestSequential(rand.Next(100000) + 10);
TestSequentialInv(rand.Next(100000) + 10);
TestRandom(seed);
Assert.IsTrue(true);
MemoryPoolTest.TestMemoryLeak();
}
public void Test1()
{
MemoryPoolTest.TestMemoryLeak();
TcpListener listener = new TcpListener(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 42134));
listener.Start();
TcpClient client = new TcpClient();
client.Connect(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 42134));
TcpClient server = listener.AcceptTcpClient();
var c = new NetworkBinaryStream(client.Client);
var s = new NetworkBinaryStream(server.Client);
Random r = new Random();
int seed = r.Next();
Random sr = new Random(seed);
Random cr = new Random(seed);
for (int x = 0; x < 2000; x++)
{
for (int y = 0; y < x; y++)
{
int val = sr.Next();
c.Write(val);
c.Write((byte)val);
}
c.Flush();
for (int y = 0; y < x; y++)
{
int val = cr.Next();
if (val != s.ReadInt32())
{
throw new Exception("Error");
}
if ((byte)val != s.ReadUInt8())
{
throw new Exception("Error");
}
}
}
server.Close();
client.Close();
listener.Stop();
MemoryPoolTest.TestMemoryLeak();
}
public void Test3()
{
MemoryPoolTest.TestMemoryLeak();
ResourceQueueCollection <int, string> queue = new ResourceQueueCollection <int, string>(() => 3.ToString(), 3, 3);
Assert.AreEqual("3", queue[1].Dequeue());
Assert.AreEqual("3", queue[250].Dequeue());
Assert.AreEqual("3", queue[999].Dequeue());
queue[250].Enqueue("0");
Assert.AreEqual("3", queue[250].Dequeue());
Assert.AreEqual("3", queue[250].Dequeue());
Assert.AreEqual("0", queue[250].Dequeue());
Assert.AreEqual("3", queue[250].Dequeue());
MemoryPoolTest.TestMemoryLeak();
}
public static void TestMethod1()
{
MemoryPoolTest.TestMemoryLeak();
int blockSize = 128;
IndexMapper map = new IndexMapper(blockSize);
CheckValues check = new CheckValues(blockSize);
uint lastAddress = (uint)Math.Min(uint.MaxValue, (long)check.BlocksPerPage * (long)check.BlocksPerPage * (long)check.BlocksPerPage * (long)check.BlocksPerPage - 1);
//this line is to shortcut so the test is less comprehensive.
for (uint x = 0; x <= lastAddress; x++)
{
map.MapPosition(x);
check.Check(map, x);
}
MemoryPoolTest.TestMemoryLeak();
}
public void Test()
{
MemoryPoolTest.TestMemoryLeak();
Assert.AreEqual(Globals.MemoryPool.AllocatedBytes, 0L);
FileHeaderBlock header = FileHeaderBlock.CreateNew(4096);
header = header.CloneEditable();
header.CreateNewFile(SubFileName.CreateRandom());
header.CreateNewFile(SubFileName.CreateRandom());
header.CreateNewFile(SubFileName.CreateRandom());
header.IsReadOnly = true;
FileHeaderBlock header2 = FileHeaderBlock.Open(header.GetBytes());
CheckEqual(header2, header);
Assert.AreEqual(Globals.MemoryPool.AllocatedBytes, 0L);
//verify they are the same;
MemoryPoolTest.TestMemoryLeak();
}
public void Test1()
{
MemoryPoolTest.TestMemoryLeak();
MemoryPoolFile file = new MemoryPoolFile(Globals.MemoryPool);
BinaryStreamIoSessionBase session = file.CreateIoSession();
BlockArguments blockArguments = new BlockArguments();
blockArguments.IsWriting = true;
blockArguments.Position = 10000000;
session.GetBlock(blockArguments);
System.Console.WriteLine("Get Block\t" + StepTimer.Time(10, () =>
{
blockArguments.Position = 100000;
session.GetBlock(blockArguments);
blockArguments.Position = 200000;
session.GetBlock(blockArguments);
blockArguments.Position = 300000;
session.GetBlock(blockArguments);
blockArguments.Position = 400000;
session.GetBlock(blockArguments);
blockArguments.Position = 500000;
session.GetBlock(blockArguments);
blockArguments.Position = 600000;
session.GetBlock(blockArguments);
blockArguments.Position = 700000;
session.GetBlock(blockArguments);
blockArguments.Position = 800000;
session.GetBlock(blockArguments);
blockArguments.Position = 900000;
session.GetBlock(blockArguments);
blockArguments.Position = 1000000;
session.GetBlock(blockArguments);
}));
file.Dispose();
MemoryPoolTest.TestMemoryLeak();
}
public void TestSubFileStream()
{
const int BlockSize = 256;
MemoryPoolTest.TestMemoryLeak();
//string file = Path.GetTempFileName();
//System.IO.File.Delete(file);
try
{
//using (FileSystemSnapshotService service = FileSystemSnapshotService.CreateFile(file))
using (TransactionalFileStructure service = TransactionalFileStructure.CreateInMemory(BlockSize))
{
using (TransactionalEdit edit = service.BeginEdit())
{
SubFileStream fs = edit.CreateFile(SubFileName.Empty);
BinaryStream bs = new BinaryStream(fs);
for (int x = 0; x < 20000000; x++)
{
bs.Write(1L);
}
bs.Position = 0;
BinaryStreamBenchmark.Run(bs, false);
bs.Dispose();
fs.Dispose();
edit.CommitAndDispose();
}
}
}
finally
{
//System.IO.File.Delete(file);
}
MemoryPoolTest.TestMemoryLeak();
}
public void TestCounts()
{
MemoryPoolTest.TestMemoryLeak();
BitArray bit = new BitArray(true, 1000);
for (int x = 0; x < 1000; x++)
{
Assert.AreEqual(1000, bit.Count);
Assert.AreEqual(1000, bit.SetCount);
Assert.AreEqual(0, bit.ClearCount);
bit[x] = true;
}
for (int x = 0; x < 1000; x++)
{
Assert.AreEqual(1000, bit.Count);
Assert.AreEqual(1000 - x, bit.SetCount);
Assert.AreEqual(x, bit.ClearCount);
bit[x] = false;
}
for (int x = 0; x < 1000; x++)
{
Assert.AreEqual(1000, bit.Count);
Assert.AreEqual(0, bit.SetCount);
Assert.AreEqual(1000, bit.ClearCount);
bit[x] = false;
}
for (int x = 0; x < 1000; x++)
{
Assert.AreEqual(1000, bit.Count);
Assert.AreEqual(x, bit.SetCount);
Assert.AreEqual(1000 - x, bit.ClearCount);
bit[x] = true;
}
MemoryPoolTest.TestMemoryLeak();
}
public void Test()
{
MemoryPoolTest.TestMemoryLeak();
const int count = 1000;
MemoryStream ms = new MemoryStream();
ms.Write(new byte[100000], 0, 100000);
ms.Write(new byte[100000], 0, 100000);
ms.Position = 0;
BinaryStreamWrapper bs = new BinaryStreamWrapper(ms, false);
Stopwatch sw = new Stopwatch();
//DateTime b = DateTime.UtcNow;
long b = 10;
//Guid b = Guid.NewGuid() ;
for (int x2 = 0; x2 < count; x2++)
{
bs.Position = 0;
for (int x = 0; x < count; x++)
{
bs.Write(b);
bs.Write(b);
bs.Write(b);
bs.Write(b);
bs.Write(b);
bs.Write(b);
bs.Write(b);
bs.Write(b);
bs.Write(b);
bs.Write(b);
}
}
sw.Start();
for (int x2 = 0; x2 < count; x2++)
{
bs.Position = 0;
for (int x = 0; x < count; x++)
{
bs.Write(b);
bs.Write(b);
bs.Write(b);
bs.Write(b);
bs.Write(b);
bs.Write(b);
bs.Write(b);
bs.Write(b);
bs.Write(b);
bs.Write(b);
//bs.ReadDecimal();
//bs.ReadDecimal();
//bs.ReadDecimal();
//bs.ReadDecimal();
//bs.ReadDecimal();
//bs.ReadDecimal();
//bs.ReadDecimal();
//bs.ReadDecimal();
//bs.ReadDecimal();
//bs.ReadDecimal();
//bs.ReadInt64();
//bs.ReadInt64();
//bs.ReadInt64();
//bs.ReadInt64();
//bs.ReadInt64();
//bs.ReadInt64();
//bs.ReadInt64();
//bs.ReadInt64();
//bs.ReadInt64();
//bs.ReadInt64();
//bs.ReadInt32();
//bs.ReadInt32();
//bs.ReadInt32();
//bs.ReadInt32();
//bs.ReadInt32();
//bs.ReadInt32();
//bs.ReadInt32();
//bs.ReadInt32();
//bs.ReadInt32();
//bs.ReadInt32();
//bs.ReadInt16();
//bs.ReadInt16();
//bs.ReadInt16();
//bs.ReadInt16();
//bs.ReadInt16();
//bs.ReadInt16();
//bs.ReadInt16();
//bs.ReadInt16();
//bs.ReadInt16();
//bs.ReadInt16();
//bs.ReadByte();
//bs.ReadByte();
//bs.ReadByte();
//bs.ReadByte();
//bs.ReadByte();
//bs.ReadByte();
//bs.ReadByte();
//bs.ReadByte();
//bs.ReadByte();
//bs.ReadByte();
//bs.Write7Bit(b);
//bs.Write7Bit(b);
//bs.Write7Bit(b);
//bs.Write7Bit(b);
//bs.Write7Bit(b);
//bs.Write7Bit(b);
//bs.Write7Bit(b);
//bs.Write7Bit(b);
//bs.Write7Bit(b);
//bs.Write7Bit(b);
}
}
sw.Stop();
Assert.IsTrue(true);
ms.Dispose();
MemoryPoolTest.TestMemoryLeak();
//MessageBox.Show((count * count * 10 / sw.Elapsed.TotalSeconds / 1000000).ToString());
}
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 TestLargeArray()
{
MemoryPoolTest.TestMemoryLeak();
TestArray(new NullableLargeArray <int>());
MemoryPoolTest.TestMemoryLeak();
}
