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();
}
/// <summary>
/// Creates a new in memory archive file.
/// </summary>
/// <param name="blockSize">The number of bytes per block in the file.</param>
/// <param name="flags">Flags to write to the file</param>
public static SortedTreeFile CreateInMemory(int blockSize = 4096, params Guid[] flags)
{
SortedTreeFile file = new SortedTreeFile();
file.m_filePath = string.Empty;
file.m_fileStructure = TransactionalFileStructure.CreateInMemory(blockSize, flags);
return(file);
}
/// <summary>
/// Creates an archive file.
/// </summary>
/// <param name="file">the path for the file.</param>
/// <param name="blockSize">The number of bytes per block in the file.</param>
/// <param name="flags">Flags to write to the file</param>
public static SortedTreeFile CreateFile(string file, int blockSize = 4096, params Guid[] flags)
{
SortedTreeFile af = new SortedTreeFile();
file = Path.GetFullPath(file);
af.m_filePath = file;
af.m_fileStructure = TransactionalFileStructure.CreateFile(file, blockSize, flags);
return(af);
}
/// <summary>
/// Creates a SortedTreeTable
/// </summary>
/// <param name="fileStructure"></param>
/// <param name="fileName"></param>
/// <param name="baseFile"></param>
internal SortedTreeTable(TransactionalFileStructure fileStructure, SubFileName fileName, SortedTreeFile baseFile)
{
BaseFile = baseFile;
m_fileName = fileName;
m_fileStructure = fileStructure;
m_firstKey = new TKey();
m_lastKey = new TKey();
using (SortedTreeTableReadSnapshot <TKey, TValue> snapshot = BeginRead())
{
snapshot.GetKeyRange(m_firstKey, m_lastKey);
}
}
/// <summary>
/// Opens an archive file.
/// </summary>
/// <param name="file"></param>
/// <param name="isReadOnly"></param>
/// <returns></returns>
public static SortedTreeFile OpenFile(string file, bool isReadOnly)
{
SortedTreeFile af = new SortedTreeFile();
file = Path.GetFullPath(file);
af.m_filePath = file;
af.m_fileStructure = TransactionalFileStructure.OpenFile(file, isReadOnly);
if (af.m_fileStructure.Snapshot.Header.ArchiveType != FileType)
{
throw new Exception("Archive type is unknown");
}
return(af);
}
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 Test()
{
Assert.AreEqual(Globals.MemoryPool.AllocatedBytes, 0L);
//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.CreateRandom());
BinaryStream bs = new BinaryStream(fs);
bs.Write((byte)1);
bs.Dispose();
fs.Dispose();
edit.CommitAndDispose();
}
{
ReadSnapshot read = service.Snapshot;
SubFileStream f1 = read.OpenFile(0);
BinaryStream bs1 = new BinaryStream(f1);
if (bs1.ReadUInt8() != 1)
{
throw new Exception();
}
using (TransactionalEdit edit = service.BeginEdit())
{
SubFileStream f2 = edit.OpenFile(0);
BinaryStream bs2 = new BinaryStream(f2);
if (bs2.ReadUInt8() != 1)
{
throw new Exception();
}
bs2.Write((byte)3);
bs2.Dispose();
} //rollback should be issued;
if (bs1.ReadUInt8() != 0)
{
throw new Exception();
}
bs1.Dispose();
{
ReadSnapshot read2 = service.Snapshot;
SubFileStream f2 = read2.OpenFile(0);
BinaryStream bs2 = new BinaryStream(f2);
if (bs2.ReadUInt8() != 1)
{
throw new Exception();
}
if (bs2.ReadUInt8() != 0)
{
throw new Exception();
}
bs2.Dispose();
}
}
using (TransactionalEdit edit = service.BeginEdit())
{
SubFileStream f2 = edit.OpenFile(0);
BinaryStream bs2 = new BinaryStream(f2);
bs2.Write((byte)13);
bs2.Write((byte)23);
bs2.Dispose();
edit.RollbackAndDispose();
} //rollback should be issued;
}
}
finally
{
//System.IO.File.Delete(file);
}
Assert.AreEqual(Globals.MemoryPool.AllocatedBytes, 0L);
Assert.IsTrue(true);
}
internal SortedTreeTableSnapshotInfo(TransactionalFileStructure fileStructure, SubFileName fileName)
{
m_fileName = fileName;
m_fileStructure = fileStructure;
m_currentTransaction = m_fileStructure.Snapshot;
}
