public void ReadDataFromAFile()
{
string fileName = @"c:\temp\Tulsa Bank 1 LTC 1.d2";
DateTime start = DateTime.Parse("4/17/2013 10:38 AM");
DateTime stop = DateTime.Parse("4/17/2013 10:38 AM");
HistorianKey key = new HistorianKey();
HistorianValue value = new HistorianValue();
using (SortedTreeFile file = SortedTreeFile.OpenFile(fileName, isReadOnly: true))
using (SortedTreeTable <HistorianKey, HistorianValue> table = file.OpenTable <HistorianKey, HistorianValue>())
using (SortedTreeTableReadSnapshot <HistorianKey, HistorianValue> snapshot = table.BeginRead())
{
SortedTreeScannerBase <HistorianKey, HistorianValue> scanner = snapshot.GetTreeScanner();
HistorianKey seekKey = new HistorianKey();
seekKey.TimestampAsDate = start;
seekKey.PointID = 3142023;
scanner.SeekToKey(seekKey);
while (scanner.Read(key, value) && key.TimestampAsDate <= stop)
{
Console.WriteLine("{0}, {1}, {2}",
key.TimestampAsDate.ToString(), key.PointID, value.AsString);
}
}
}
/// <summary>
/// Gets if the specified file is being.
/// MUST be called from a synchronized context.
/// </summary>
/// <param name="sortedTree"></param>
/// <returns></returns>
private bool InternalIsFileBeingUsed(SortedTreeTable <TKey, TValue> sortedTree)
{
return(m_allSnapshots.Select(snapshot => snapshot.Tables)
.Where(tables => tables != null)
.Any(tables => tables
.Any(summary => summary != null && summary.SortedTreeTable == sortedTree)));
}
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 TestFile()
{
// FilePath "C:\\Temp\\Historian\\635287587300536177-Stage1-d559e63e-d938-46a9-8d57-268f7c8ba194.d2" string
//635329017197429979-Stage1-38887e11-4097-4937-b269-ce4037157691.d2
//using (var file = SortedTreeFile.OpenFile(@"C:\Temp\Historian\635287587300536177-Stage1-d559e63e-d938-46a9-8d57-268f7c8ba194.d2", true))
using (SortedTreeFile file = SortedTreeFile.OpenFile(@"C:\Archive\635329017197429979-Stage1-38887e11-4097-4937-b269-ce4037157691.d2", true))
//using (var file = SortedTreeFile.OpenFile(@"C:\Temp\Historian\635255664136496199-Stage2-6e758046-b2af-40ff-ae4e-85cd0c0e4501.d2", true))
using (SortedTreeTable <HistorianKey, HistorianValue> table = file.OpenTable <HistorianKey, HistorianValue>())
using (SortedTreeTableReadSnapshot <HistorianKey, HistorianValue> reader = table.BeginRead())
{
SortedTreeScannerBase <HistorianKey, HistorianValue> scanner = reader.GetTreeScanner();
scanner.SeekToStart();
scanner.TestSequential().Count();
HistorianKey key = new HistorianKey();
HistorianValue value = new HistorianValue();
int x = 0;
scanner.Peek(key, value);
while (scanner.Read(key, value) && x < 10000)
{
System.Console.WriteLine(key.PointID);
x++;
scanner.Peek(key, value);
}
scanner.Count();
}
}
public void TestCompressed()
{
int count = 10000000;
Stopwatch sw = new Stopwatch();
using (SortedTreeFile af = SortedTreeFile.CreateInMemory())
using (SortedTreeTable <AmiKey, AmiValue> table = af.OpenOrCreateTable <AmiKey, AmiValue>(EncodingDefinition.FixedSizeCombinedEncoding))
{
using (SortedTreeTableEditor <AmiKey, AmiValue> edit = table.BeginEdit())
{
sw.Start();
AmiKey key = new AmiKey();
AmiValue value = new AmiValue();
for (int x = 0; x < count; x++)
{
key.Timestamp = (uint)x;
edit.AddPoint(key, value);
}
edit.Commit();
sw.Stop();
Console.WriteLine(af.ArchiveSize / 1024.0 / 1024.0);
Console.WriteLine(count / sw.Elapsed.TotalSeconds / 1000000);
}
}
}
public void EnduranceTest()
{
HistorianKey key = new HistorianKey();
HistorianValue value = new HistorianValue();
using (SortedTreeTable <HistorianKey, HistorianValue> target = SortedTreeFile.CreateInMemory().OpenOrCreateTable <HistorianKey, HistorianValue>(EncodingDefinition.FixedSizeCombinedEncoding))
{
for (uint x = 0; x < 100; x++)
{
using (SortedTreeTableEditor <HistorianKey, HistorianValue> fileEditor = target.BeginEdit())
{
for (int y = 0; y < 10; y++)
{
key.Timestamp = x;
key.PointID = x;
value.Value1 = x;
value.Value3 = x;
fileEditor.AddPoint(key, value);
x++;
}
fileEditor.Commit();
}
Assert.AreEqual(target.FirstKey.Timestamp, 0);
Assert.AreEqual(target.LastKey.Timestamp, x - 1);
}
}
}
private void StartStream(object args)
{
HistorianKey key = new HistorianKey();
HistorianValue value = new HistorianValue();
using (HistorianClient client = new HistorianClient("127.0.0.1", 54996))
using (ClientDatabaseBase <HistorianKey, HistorianValue> database = client.GetDatabase <HistorianKey, HistorianValue>(string.Empty))
{
using (SortedTreeTable <HistorianKey, HistorianValue> file = SortedTreeFile.OpenFile(@"H:\OGE 2009.d2", isReadOnly: true).OpenOrCreateTable <HistorianKey, HistorianValue>(EncodingDefinition.FixedSizeCombinedEncoding))
{
using (SortedTreeTableReadSnapshot <HistorianKey, HistorianValue> read = file.BeginRead())
{
SortedTreeScannerBase <HistorianKey, HistorianValue> scan = read.GetTreeScanner();
scan.SeekToStart();
long count = 0;
while (scan.Read(key, value))
{
count++;
database.Write(key, value);
if ((count % 10) == 1)
{
Thread.Sleep(1);
}
}
}
}
}
}
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 WriteFile()
{
HistorianKey key = new HistorianKey();
HistorianValue value = new HistorianValue();
if (File.Exists("c:\\temp\\ArchiveTestFileBig.d2"))
{
File.Delete("c:\\temp\\ArchiveTestFileBig.d2");
}
//using (var af = ArchiveFile.CreateInMemory(CompressionMethod.TimeSeriesEncoded))
using (SortedTreeFile af = SortedTreeFile.CreateFile("c:\\temp\\ArchiveTestFileBig.d2"))
using (SortedTreeTable <HistorianKey, HistorianValue> af2 = af.OpenOrCreateTable <HistorianKey, HistorianValue>(EncodingDefinition.FixedSizeCombinedEncoding))
{
Random r = new Random(3);
for (ulong v1 = 1; v1 < 36; v1++)
{
using (var edit = af2.BeginEdit())
{
for (ulong v2 = 1; v2 < 86000; v2++)
{
key.Timestamp = v1 * 2342523;
key.PointID = v2;
value.Value1 = (ulong)r.Next();
value.Value3 = 0;
edit.AddPoint(key, value);
}
edit.Commit();
}
af2.Count();
}
af2.Count();
}
}
public void TestSmall()
{
HistorianKey key = new HistorianKey();
HistorianValue value = new HistorianValue();
using (SortedTreeFile af = SortedTreeFile.CreateInMemory())
using (SortedTreeTable <HistorianKey, HistorianValue> file = af.OpenOrCreateTable <HistorianKey, HistorianValue>(EncodingDefinition.FixedSizeCombinedEncoding))
{
using (SortedTreeTableEditor <HistorianKey, HistorianValue> edit = file.BeginEdit())
{
for (int x = 0; x < 10000000; x++)
{
key.Timestamp = (ulong)x;
edit.AddPoint(key, value);
}
edit.Commit();
}
using (SortedTreeTableReadSnapshot <HistorianKey, HistorianValue> read = file.BeginRead())
using (SortedTreeScannerBase <HistorianKey, HistorianValue> scan = read.GetTreeScanner())
{
int count = 0;
scan.SeekToStart();
while (scan.Read(key, value))
{
count++;
}
System.Console.WriteLine(count.ToString());
}
}
}
void AddDataTerminal(SortedTreeTable <HistorianKey, HistorianValue> table, ulong pointID, DateTime startTime, TimeSpan stepTime, ulong startValue, ulong stepValue, int count)
{
using (SortedTreeTableEditor <HistorianKey, HistorianValue> edit = table.BeginEdit())
{
HistorianKey key = new HistorianKey();
HistorianValue value = new HistorianValue();
key.SetMin();
ulong t = (ulong)startTime.Ticks;
ulong v = startValue;
while (count > 0)
{
count--;
key.Timestamp = t;
key.PointID = pointID;
value.Value1 = v;
edit.AddPoint(key, value);
t += (ulong)stepTime.Ticks;
v += stepValue;
}
edit.Commit();
}
}
SortedTreeTable <HistorianKey, HistorianValue> CreateTable()
{
SortedTreeFile file = SortedTreeFile.CreateInMemory();
SortedTreeTable <HistorianKey, HistorianValue> table = file.OpenOrCreateTable <HistorianKey, HistorianValue>(EncodingDefinition.FixedSizeCombinedEncoding);
return(table);
}
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 RollbackChangesToAFile()
{
string fileName = @"C:\Temp\ArchiveFile.d2";
HistorianKey key = new HistorianKey();
HistorianValue value = new HistorianValue();
using (SortedTreeFile file = SortedTreeFile.OpenFile(fileName, isReadOnly: false))
using (SortedTreeTable <HistorianKey, HistorianValue> table = file.OpenOrCreateTable <HistorianKey, HistorianValue>(EncodingDefinition.FixedSizeCombinedEncoding))
{
using (SortedTreeTableEditor <HistorianKey, HistorianValue> editor = table.BeginEdit())
{
key.TimestampAsDate = DateTime.Now.AddDays(-1);
key.PointID = 234;
value.AsString = "Add Me";
editor.AddPoint(key, value);
editor.Commit();
}
using (SortedTreeTableEditor <HistorianKey, HistorianValue> editor = table.BeginEdit())
{
key.Timestamp = 31;
value.AsString = "But Not Me";
editor.AddPoint(key, value);
editor.Rollback(); //These changes will not be written to the disk
}
}
ReadDataFromAFile();
}
private TestResults TestRandom(int pageSize, uint count)
{
//StringBuilder sb = new StringBuilder();
Random R = new Random(1);
HistorianKey key = new HistorianKey();
HistorianValue value = new HistorianValue();
DiskIoSession.ReadCount = 0;
DiskIoSession.WriteCount = 0;
Stats.ChecksumCount = 0;
DiskIoSession.Lookups = 0;
DiskIoSession.CachedLookups = 0;
Stopwatch sw = new Stopwatch();
sw.Start();
using (SortedTreeFile af = SortedTreeFile.CreateInMemory(blockSize: pageSize))
using (SortedTreeTable <HistorianKey, HistorianValue> af2 = af.OpenOrCreateTable <HistorianKey, HistorianValue>(EncodingDefinition.FixedSizeCombinedEncoding))
{
uint pointPairs = count / 5000;
for (uint i = 0; i < pointPairs; i++)
{
uint max = i * 5000 + 5000;
using (var edit = af2.BeginEdit())
{
for (ulong x = i * 5000; x < max; x++)
{
key.Timestamp = (uint)R.Next();
key.PointID = 2 * x;
value.Value3 = 3 * x;
value.Value1 = 4 * x;
//if ((x % 100) == 0)
// sb.AppendLine(x + "," + DiskIoSession.ReadCount + "," + DiskIoSession.WriteCount);
//if (x == 1000)
// DiskIoSession.BreakOnIO = true;
edit.AddPoint(key, value);
//edit.AddPoint(uint.MaxValue - x, 2 * x, 3 * x, 4 * x);
}
edit.Commit();
}
}
//long cnt = af.Count();
}
sw.Stop();
//File.WriteAllText(@"C:\temp\" + pageSize + ".csv",sb.ToString());
return(new TestResults()
{
PageSize = pageSize,
Rate = (float)(count / sw.Elapsed.TotalSeconds / 1000000),
ReadCount = DiskIoSession.ReadCount,
WriteCount = DiskIoSession.WriteCount,
ChecksumCount = Stats.ChecksumCount,
Lookups = DiskIoSession.Lookups,
CachedLookups = DiskIoSession.CachedLookups
});
}
public void ReadFromAFileWhileWritingToIt()
{
HistorianKey key = new HistorianKey();
HistorianValue value = new HistorianValue();
string fileName = @"C:\Temp\ArchiveFile.d2";
using (SortedTreeFile file = SortedTreeFile.OpenFile(fileName, isReadOnly: false))
using (SortedTreeTable <HistorianKey, HistorianValue> table = file.OpenTable <HistorianKey, HistorianValue>())
{
using (SortedTreeTableEditor <HistorianKey, HistorianValue> writer = table.BeginEdit())
using (SortedTreeTableReadSnapshot <HistorianKey, HistorianValue> reader = table.BeginRead())
{
SortedTreeScannerBase <HistorianKey, HistorianValue> scanner = reader.GetTreeScanner();
scanner.SeekToStart();
while (scanner.Read(key, value))
{
key.Timestamp++;
value.Value1++;
writer.AddPoint(key, value);
}
writer.Commit();
}
}
ReadDataFromAFile();
}
/// <summary>
/// Determines if the provided file is currently in use
/// by any resource.
/// </summary>
/// <param name="sortedTree"> file to search for.</param>
/// <returns></returns>
public bool IsFileBeingUsed(SortedTreeTable <TKey, TValue> sortedTree)
{
lock (m_syncRoot)
{
return(InternalIsFileBeingUsed(sortedTree));
}
}
private void TestFile(int pageSize, string fileName)
{
HistorianKey key = new HistorianKey();
HistorianValue value = new HistorianValue();
key.Timestamp = 1;
if (File.Exists(fileName))
{
File.Delete(fileName);
}
Stopwatch sw = new Stopwatch();
sw.Start();
using (SortedTreeTable <HistorianKey, HistorianValue> af = SortedTreeFile.CreateFile(fileName, blockSize: pageSize).OpenOrCreateTable <HistorianKey, HistorianValue>(EncodingDefinition.FixedSizeCombinedEncoding))
using (SortedTreeTableEditor <HistorianKey, HistorianValue> edit = af.BeginEdit())
{
for (uint x = 0; x < 1000000; x++)
{
key.PointID = x;
edit.AddPoint(key, value);
}
edit.Commit();
}
sw.Stop();
System.Console.WriteLine("Size: " + pageSize + " Rate: " + (1 / sw.Elapsed.TotalSeconds).ToString());
}
public void GetBits()
{
HistorianKey key = new HistorianKey();
HistorianValue value = new HistorianValue();
StringBuilder sb = new StringBuilder();
sb.AppendLine("Higher Bits, Bucket Number, Count, FloatValue");
using (SortedTreeFile file = SortedTreeFile.OpenFile(@"C:\Archive\635184227258021940-Stage2-8b835d6a-8299-45bb-9624-d4a470e4abe1.d2", true))
using (SortedTreeTable <HistorianKey, HistorianValue> table = file.OpenTable <HistorianKey, HistorianValue>())
using (SortedTreeTableReadSnapshot <HistorianKey, HistorianValue> reader = table.BeginRead())
using (SortedTreeScannerBase <HistorianKey, HistorianValue> scan = reader.GetTreeScanner())
{
int count = 0;
scan.SeekToStart();
while (scan.Read(key, value))
{
count++;
}
for (int x = 1; x < 24; x++)
{
scan.SeekToStart();
int[] bucket = MeasureBits(scan, x);
Write(sb, bucket, x, count);
}
}
Console.WriteLine(sb.ToString());
}
public void TestBulkRolloverFile()
{
Stats.LookupKeys = 0;
DiskIoSession.ReadCount = 0;
DiskIoSession.WriteCount = 0;
Stats.ChecksumCount = 0;
DiskIoSession.Lookups = 0;
DiskIoSession.CachedLookups = 0;
long cnt;
Stopwatch sw = new Stopwatch();
sw.Start();
//using (SortedTreeTable<HistorianKey, HistorianValue> af = SortedTreeFile.CreateInMemory(4096).OpenOrCreateTable<HistorianKey, HistorianValue>(SortedTree.FixedSizeNode))
using (SortedTreeTable <HistorianKey, HistorianValue> af = SortedTreeFile.CreateInMemory(blockSize: 4096).OpenOrCreateTable <HistorianKey, HistorianValue>(HistorianFileEncodingDefinition.TypeGuid))
{
using (SortedTreeTableEditor <HistorianKey, HistorianValue> edit = af.BeginEdit())
{
edit.AddPoints(new PointStreamSequentialPoints(1, 20000000));
edit.Commit();
}
sw.Stop();
cnt = af.Count();
System.Console.WriteLine(cnt);
}
System.Console.WriteLine((float)(20 / sw.Elapsed.TotalSeconds));
}
public void GetDifference()
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("Bucket Number, Count");
using (SortedTreeFile file = SortedTreeFile.OpenFile(@"C:\Unison\GPA\Codeplex\openHistorian\Main\Build\Output\Release\Applications\openHistorian\Archive\635293583194231435-Stage2-0ef36dcc-4264-498f-b194-01b2043a9231.d2", true))
using (SortedTreeTable <HistorianKey, HistorianValue> table = file.OpenTable <HistorianKey, HistorianValue>())
using (SortedTreeTableReadSnapshot <HistorianKey, HistorianValue> reader = table.BeginRead())
using (SortedTreeScannerBase <HistorianKey, HistorianValue> scan = reader.GetTreeScanner())
{
HistorianKey key1 = new HistorianKey();
HistorianKey key2 = new HistorianKey();
HistorianValue value = new HistorianValue();
int count = 0;
scan.SeekToStart();
while (scan.Read(key1, value))
{
count++;
}
int[] bucket = new int[130];
scan.SeekToStart();
while (true)
{
if (!scan.Read(key1, value))
{
break;
}
if (key1.Timestamp == key2.Timestamp)
{
int diff = Math.Abs((int)(key1.PointID - key2.PointID));
diff = Math.Min(129, diff);
bucket[diff]++;
}
if (!scan.Read(key2, value))
{
break;
}
if (key1.Timestamp == key2.Timestamp)
{
int diff = Math.Abs((int)(key1.PointID - key2.PointID));
diff = Math.Min(129, diff);
bucket[diff]++;
}
}
for (uint x = 0; x < bucket.Length; x++)
{
sb.AppendLine(x.ToString() + "," + (bucket[x] / (double)count * 100.0).ToString("0.00"));
}
}
Console.WriteLine(sb.ToString());
}
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 static long Count(this SortedTreeTable <HistorianKey, HistorianValue> stream)
{
using (SortedTreeTableReadSnapshot <HistorianKey, HistorianValue> read = stream.BeginRead())
{
SortedTreeScannerBase <HistorianKey, HistorianValue> scan = read.GetTreeScanner();
scan.SeekToStart();
return(scan.Count());
}
}
/// <summary>
/// Creates a snapshot summary of a table.
/// </summary>
/// <param name="table">the table to take the read snapshot of.</param>
public ArchiveTableSummary(SortedTreeTable <TKey, TValue> table)
{
m_firstKey = new TKey();
m_lastKey = new TKey();
m_sortedTreeTable = table;
m_activeSnapshotInfo = table.AcquireReadSnapshot();
table.FirstKey.CopyTo(m_firstKey);
table.LastKey.CopyTo(m_lastKey);
m_fileId = m_sortedTreeTable.BaseFile.Snapshot.Header.ArchiveId;
}
/// <summary>
/// Queues the supplied file as one that needs to be disposed when no longer in use.
/// MUST be called from a synchronized context.
/// </summary>
/// <param name="file"></param>
void AddFileToDispose(SortedTreeTable <TKey, TValue> file)
{
if (!InternalIsFileBeingUsed(file))
{
file.BaseFile.Dispose();
return;
}
m_filesToDispose.Add(file);
m_processRemovals.Start(1000);
}
/// <summary>
/// Adds an archive file to the list with the given state information.
/// </summary>
/// <param name="sortedTree">archive table to add</param>
public override void Add(SortedTreeTable <TKey, TValue> sortedTree)
{
if (m_disposed)
{
throw new ObjectDisposedException(GetType().FullName);
}
ArchiveTableSummary <TKey, TValue> summary = new ArchiveTableSummary <TKey, TValue>(sortedTree);
m_list.m_fileSummaries.Add(sortedTree.ArchiveId, summary);
}
public void AddPointTest()
{
using (SortedTreeTable <HistorianKey, HistorianValue> target = SortedTreeFile.CreateInMemory().OpenOrCreateTable <HistorianKey, HistorianValue>(EncodingDefinition.FixedSizeCombinedEncoding))
{
using (SortedTreeTableEditor <HistorianKey, HistorianValue> fileEditor = target.BeginEdit())
{
fileEditor.AddPoint(new HistorianKey(), new HistorianValue());
fileEditor.Commit();
}
}
}
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();
}
void AddData(SortedTreeTable <HistorianKey, HistorianValue> table, ulong start, ulong step, ulong count)
{
using (SortedTreeTableEditor <HistorianKey, HistorianValue> edit = table.BeginEdit())
{
HistorianKey key = new HistorianKey();
HistorianValue value = new HistorianValue();
for (ulong v = start; v < start + step * count; v += step)
{
key.SetMin();
key.PointID = v;
edit.AddPoint(key, value);
}
edit.Commit();
}
}
/// <summary>
/// Queues the supplied file as a file that needs to be deleted.
/// MUST be called from a synchronized context.
/// </summary>
/// <param name="file"></param>
void AddFileToDelete(SortedTreeTable <TKey, TValue> file)
{
if (file.BaseFile.IsMemoryFile)
{
AddFileToDispose(file);
return;
}
if (!InternalIsFileBeingUsed(file))
{
file.BaseFile.Delete();
return;
}
m_listLog.AddFileToDelete(file.ArchiveId);
m_filesToDelete.Add(file);
m_processRemovals.Start(1000);
}
void AddDataTerminal(SortedTreeTable<HistorianKey, HistorianValue> table, ulong pointID, DateTime startTime, TimeSpan stepTime, ulong startValue, ulong stepValue, int count)
{
using (var edit = table.BeginEdit())
{
var key = new HistorianKey();
var value = new HistorianValue();
key.SetMin();
var t = (ulong)startTime.Ticks;
var v = startValue;
while (count > 0)
{
count--;
key.Timestamp = t;
key.PointID = pointID;
value.Value1 = v;
edit.AddPoint(key, value);
t += (ulong)stepTime.Ticks;
v += stepValue;
}
edit.Commit();
}
}
void AddData(SortedTreeTable<HistorianKey, HistorianValue> table, DateTime startTime, TimeSpan stepTime, int countTime, ulong startPoint, ulong stepPoint, ulong countPoint)
{
using (var edit = table.BeginEdit())
{
var key = new HistorianKey();
var value = new HistorianValue();
key.SetMin();
var stepTimeTicks = (ulong)stepTime.Ticks;
var stopTime = (ulong)(startTime.Ticks + countTime * stepTime.Ticks);
for (ulong t = (ulong)startTime.Ticks; t < stopTime; t += stepTimeTicks)
{
for (ulong v = startPoint; v < startPoint + stepPoint * countPoint; v += stepPoint)
{
key.Timestamp = t;
key.PointID = v;
edit.AddPoint(key, value);
}
}
edit.Commit();
}
}
void AddData(SortedTreeTable<HistorianKey, HistorianValue> table, ulong start, ulong step, ulong count)
{
using (var edit = table.BeginEdit())
{
var key = new HistorianKey();
var value = new HistorianValue();
for (ulong v = start; v < start + step * count; v += step)
{
key.SetMin();
key.PointID = v;
edit.AddPoint(key, value);
}
edit.Commit();
}
}