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 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); var master = CreateTable(); var table1 = CreateTable(); AddData(master, 100, 100, 100); AddData(table1, 100, 100, 100); using (var editor = list.AcquireEditLock()) { editor.Add(table1); } 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(); 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 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 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(); SortedTreeTable <HistorianKey, HistorianValue> master = CreateTable(); SortedTreeTable <HistorianKey, HistorianValue> table1 = CreateTable(); SortedTreeTable <HistorianKey, HistorianValue> table2 = CreateTable(); AddData(master, 100, 100, 100); AddData(table1, 100, 100, 100); AddData(table2, 100, 100, 100); using (ArchiveListEditor <HistorianKey, HistorianValue> editor = list.AcquireEditLock()) { editor.Add(table1); editor.Add(table2); } 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(); 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 RunMemoryStreamTest() { MemoryPoolTest.TestMemoryLeak(); MemoryPoolStream ms = new MemoryPoolStream(); BinaryStream bs = new BinaryStream(ms); Run(bs, false); ms.Dispose(); MemoryPoolTest.TestMemoryLeak(); }
public void Test1() { MemoryPoolTest.TestMemoryLeak(); Test(0); Test(1); Test(2); Test(100); Test(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 Test2() { MemoryPoolTest.TestMemoryLeak(); TestWithRenumber(0); TestWithRenumber(1); TestWithRenumber(2); TestWithRenumber(100); TestWithRenumber(1000); 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 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 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 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 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 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 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 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 BenchmarkThreeFiles() { 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(); SortedTreeTable <HistorianKey, HistorianValue> table3 = CreateTable(); AddData(table1, 100, 100, Max / 3); AddData(table2, 101, 100, Max / 3); AddData(table3, 102, 100, Max / 3); using (ArchiveListEditor <HistorianKey, HistorianValue> editor = list.AcquireEditLock()) { editor.Add(table1); editor.Add(table2); editor.Add(table3); } 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 ConsoleTest2() { 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); } } SeekFilterBase <HistorianKey> filter = TimestampSeekFilter.CreateFromIntervalData <HistorianKey>(start.AddMinutes(-100), 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 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 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 TestLargeArray() { MemoryPoolTest.TestMemoryLeak(); TestArray(new NullableLargeArray <int>()); MemoryPoolTest.TestMemoryLeak(); }