private int GetLevel(DeviceStats deviceStats, int reportDay)
{
int reportDayIndex = reportDay - 1;
double measurementsReceived = deviceStats.MeasurementsReceived[reportDayIndex];
double measurementsExpected = deviceStats.MeasurementsExpected[reportDayIndex];
if (measurementsExpected == 0.0D)
{
return(-1);
}
if (measurementsReceived >= (m_level4Threshold * measurementsExpected) / 100.0D)
{
return(4);
}
if (measurementsReceived >= (m_level3Threshold * measurementsExpected) / 100.0D)
{
return(3);
}
if (measurementsReceived > 0.0D)
{
return(2);
}
if (deviceStats.MeasurementsReceived.Skip(reportDay - Month).Take(ReportDays).Any(receivedStat => receivedStat > 0.0D))
{
return(1);
}
return(0);
}
private void ResetAndInit()
{
Log.Notice("Resetting device {0}", PciAddress);
//Sec 4.6.3.1 - Disable all interrupts
SetReg(IxgbeDefs.EIMC, 0x7FFFFFFF);
//Sec 4.6.3.2 - Global reset (software + link)
SetReg(IxgbeDefs.CTRL, IxgbeDefs.CTRL_RST_MASK);
WaitClearReg(IxgbeDefs.CTRL, IxgbeDefs.CTRL_RST_MASK);
//Wait 0.01 seconds for reset
Thread.Sleep(10);
//Sec 4.6.3.1 - Disable interrupts again after reset
SetReg(IxgbeDefs.EIMC, 0x7FFFFFFF);
Log.Notice("Initializing device {0}", PciAddress);
//Sec 4.6.3 - Wait for EEPROM auto read completion
WaitSetReg(IxgbeDefs.EEC, IxgbeDefs.EEC_ARD);
//Sec 4.6.3 - Wait for DMA initialization to complete
WaitSetReg(IxgbeDefs.RDRXCTL, IxgbeDefs.RDRXCTL_DMAIDONE);
//Sec 4.6.4 - Init link (auto negotiation)
InitLink();
//Sec 4.6.5 - Statistical counters
//Reset-on-read registers, just read them once
var stats = new DeviceStats();
ReadStats(ref stats);
//Sec 4.6.7 - Init Rx
InitRx();
//Sec 4.6.8 - Init Tx
InitTx();
//Start each Rx/Tx queue
for (int i = 0; i < RxQueues.Length; i++)
{
StartRxQueue(i);
}
for (int i = 0; i < TxQueues.Length; i++)
{
StartTxQueue(i);
}
//Skipping last step from 4.6.3
SetPromisc(true);
WaitForLink();
}
public override void ReadStats(ref DeviceStats stats)
{
uint rxPackets = GetReg(IxgbeDefs.GPRC);
uint txPackets = GetReg(IxgbeDefs.GPTC);
ulong rxBytes = GetReg(IxgbeDefs.GORCL) + (((ulong)GetReg(IxgbeDefs.GORCH)) << 32);
ulong txBytes = GetReg(IxgbeDefs.GOTCL) + (((ulong)GetReg(IxgbeDefs.GOTCH)) << 32);
stats.RxPackets += rxPackets;
stats.TxPackets += txPackets;
stats.RxBytes += rxBytes;
stats.TxBytes += txBytes;
}
public unsafe Forwarder(string pci1, string pci2)
{
GCSettings.LatencyMode = GCLatencyMode.SustainedLowLatency;
if (String.IsNullOrEmpty(pci1) || String.IsNullOrEmpty(pci2))
{
Log.Error("Please provide two pci addresses");
Environment.Exit(1);
}
var dev1 = new IxgbeDevice(pci1, 1, 1);
var dev2 = new IxgbeDevice(pci2, 1, 1);
// TODO: switch to C# 7.3 and replace with Span<PacketBuffer> buffers = stackalloc PacketBuffer[BatchSize];
var buffersArray = stackalloc PacketBuffer[BatchSize];
var buffers = new Span <PacketBuffer>(buffersArray, BatchSize);
ulong counter = 0;
var stopWatch = new Stopwatch();
var stats1 = new DeviceStats(dev1);
var stats1Old = new DeviceStats(dev1);
var stats2 = new DeviceStats(dev2);
var stats2Old = new DeviceStats(dev2);
stopWatch.Start();
while (true)
{
Forward(dev1, 0, dev2, 0, buffers);
Forward(dev2, 0, dev1, 0, buffers);
stats1.Reset();
stats1Old.Reset();
stats2.Reset();
stats2Old.Reset();
//Periodically measure time
if (((counter++ % 500000) == 0) && stopWatch.ElapsedMilliseconds > 1000)
{
stopWatch.Stop();
var nanos = stopWatch.ElapsedTicks;
dev1.ReadStats(ref stats1);
stats1.PrintStatsDiff(ref stats1Old, (ulong)nanos);
stats1Old = stats1;
if (dev1 != dev2)
{
dev2.ReadStats(ref stats2);
stats2.PrintStatsDiff(ref stats2Old, (ulong)nanos);
stats2Old = stats2;
}
counter = 0;
stopWatch.Restart();
}
}
}
public unsafe PacketGenerator(string pciAddr)
{
InitMempool();
var dev = new IxgbeDevice(pciAddr, 1, 1);
// TODO: switch to C# 7.3 and replace with Span<PacketBuffer> buffers = stackalloc PacketBuffer[BatchSize];
var buffersArray = stackalloc PacketBuffer[BatchSize];
var buffers = new Span <PacketBuffer>(buffersArray, BatchSize);
var statsOld = new DeviceStats(dev);
var statsNew = new DeviceStats(dev);
ulong counter = 0;
var stopWatch = new Stopwatch();
stopWatch.Start();
int seqNum = 0;
while (true)
{
var batchCount = _mempool.GetPacketBuffers(buffers);
var batch = buffers.Slice(0, batchCount);
foreach (var buf in batch)
{
buf.WriteData(PacketSize - 4, seqNum++);
}
dev.TxBatchBusyWait(0, batch);
if ((counter++ & 0xFFF) == 0 && stopWatch.ElapsedMilliseconds > 100)
{
stopWatch.Stop();
var nanos = stopWatch.ElapsedTicks;
dev.ReadStats(ref statsNew);
statsNew.PrintStatsDiff(ref statsOld, (ulong)nanos);
statsOld = statsNew;
counter = 0;
stopWatch.Restart();
}
}
}
internal DeviceStats loadDeviceStats(DateTime fromdate, String fromtime, DateTime todate, String totime, string deviceid, string roomname, bool loadroommap, bool loadheathmap, double xlen, double ylen, double htresolution, double filteruncertainity)
{
DeviceStats ds = new DeviceStats();
if (loadheathmap)
{
ds.heatmap = new int[(int)(htresolution * xlen) + 1, (int)(htresolution * ylen) + 1];
}
if (loadroommap)
{
ds.roommap.Add("__OVERALL__", 0);
}
ds.timeperday = new Double[(int)todate.Subtract(fromdate).TotalDays + 1];
String query;
if (loadroommap)
{
query = "select xpos,ypos,tm,roomname,uncertainty from devicespositions where identifier=@identifier and tm>=@tmstart and tm<=@tmend and roomname not in (select roomname from rooms where archived=True) order by tm asc";
}
else
{
query = "select xpos,ypos,tm,roomname,uncertainty from devicespositions where identifier=@identifier and tm>=@tmstart and tm<=@tmend and roomname=@roomname and outmovement=false order by tm asc";
}
DateTime pre = DateTime.MinValue;
using (ConnectionHandle conn = new ConnectionHandle(connectionpool, connectionstring, false))
{
try
{
if (!connectioncheck(conn))
{
throw new Exception("Connection is not open");
}
using (var cmd = new NpgsqlCommand(query, conn.conn))
{
if (!loadroommap)
{
cmd.Parameters.AddWithValue("roomname", roomname);
}
addParameters(cmd,
"identifier", deviceid,
"tmstart", new DateTime(fromdate.Year, fromdate.Month, fromdate.Day, Convert.ToInt32(fromtime.Split(':')[0]), Convert.ToInt32(fromtime.Split(':')[1]), 0),
"tmend", new DateTime(todate.Year, todate.Month, todate.Day, Convert.ToInt32(totime.Split(':')[0]), Convert.ToInt32(totime.Split(':')[1]), 0));
using (var reader = cmd.ExecuteReader())
{
while (reader.Read())
{
if (loadheathmap && reader.GetDouble(4) < filteruncertainity)
{
int xpos = (int)(htresolution * reader.GetDouble(0));
int ypos = (int)(htresolution * reader.GetDouble(1));
if (xpos < ds.heatmap.GetLength(0) && ypos < ds.heatmap.GetLength(1))
{
ds.heatmap[xpos, ypos] += 1;
}
}
if (loadroommap)
{
ds.roommap["__OVERALL__"] += 1;
String room = reader.GetString(3);
if (!ds.roommap.ContainsKey(room))
{
ds.roommap.Add(room, 0);
}
ds.roommap[room] += 1;
}
DateTime detectiontime = reader.GetDateTime(2);
if (detectiontime.Subtract(pre).TotalMinutes < 15)
{
ds.timeperday[(int)detectiontime.Subtract(fromdate).TotalDays] += detectiontime.Subtract(pre).TotalMinutes;
}
else if (ds.timeperday[(int)detectiontime.Subtract(fromdate).TotalDays] == 0)
{
ds.timeperday[(int)detectiontime.Subtract(fromdate).TotalDays] = 0.001;
}
ds.pingsperhour[detectiontime.Hour * 6 + detectiontime.Minute / 10]++;
pre = detectiontime;
}
}
}
}
catch (Exception ex)
{
pre = DateTime.MinValue;
manageDbException(ex, conn.conn, true);
}
}
return(pre != DateTime.MinValue?ds:null);
}
// Reads statistics from the archive and stores them in a format that can
// be easily manipulated to determine which devices belong in which levels.
private void ReadStatistics()
{
Dictionary<string, DeviceStats> deviceStatsLookup = new Dictionary<string, DeviceStats>();
DateTime startTime;
DateTime endTime;
ArchiveLocator locator;
Dictionary<MetadataRecord, IEnumerable<IDataPoint>> measurementsReceived;
Dictionary<MetadataRecord, IEnumerable<IDataPoint>> measurementsExpected;
Dictionary<MetadataRecord, IEnumerable<IDataPoint>> dataQualityErrors;
Dictionary<MetadataRecord, IEnumerable<IDataPoint>> timeQualityErrors;
MetadataRecord dataQualityRecord;
MetadataRecord timeQualityRecord;
DeviceStats deviceStats;
string signalReference;
string deviceName;
int index;
// Create the statistics reader for reading statistics from the archive
using (StatisticsReader statisticsReader = new StatisticsReader())
{
// Create the archive locator to
// determine the location of the archive
locator = new ArchiveLocator()
{
ArchiveLocation = m_archiveLocation,
ArchiveLocationName = "Statistics",
ArchiveName = "STAT"
};
endTime = m_reportDate + TimeSpan.FromDays(1);
startTime = endTime - TimeSpan.FromDays(ReportDays);
// Set up and open the statistics reader
statisticsReader.StartTime = startTime;
statisticsReader.EndTime = endTime;
statisticsReader.ArchiveFilePath = locator.ArchiveFilePath;
statisticsReader.Open();
measurementsReceived = statisticsReader.Read("PMU", 4);
measurementsExpected = statisticsReader.Read("PMU", 5);
dataQualityErrors = statisticsReader.Read("PMU", 1);
timeQualityErrors = statisticsReader.Read("PMU", 2);
// Determine which devices in the archive have stats for both measurements received and measurements expected
foreach (Tuple<MetadataRecord, MetadataRecord> tuple in measurementsReceived.Keys.Join(measurementsExpected.Keys, GetDeviceName, GetDeviceName, Tuple.Create))
{
signalReference = tuple.Item1.Synonym1;
deviceName = GetDeviceName(tuple.Item1);
// Ignore statistics that were calculated by an intermediate gateway
if (!signalReference.StartsWith("LOCAL$") && signalReference.Contains("LOCAL$"))
continue;
// Make sure LOCAL$ statistics take precedence over other statistics calculated for the same device
if (deviceStatsLookup.ContainsKey(deviceName) && !signalReference.StartsWith("LOCAL$"))
continue;
dataQualityRecord = dataQualityErrors.Keys.FirstOrDefault(record => GetDeviceName(record) == deviceName);
timeQualityRecord = timeQualityErrors.Keys.FirstOrDefault(record => GetDeviceName(record) == deviceName);
// Create arrays to hold the total sum of the stats for each day being reported
deviceStats = new DeviceStats()
{
Name = deviceName,
DataQualityErrors = new double[ReportDays],
TimeQualityErrors = new double[ReportDays],
MeasurementsReceived = new double[ReportDays],
MeasurementsExpected = new double[ReportDays]
};
if ((object)dataQualityRecord != null)
{
// Calculate the total data quality errors for each day being reported
foreach (IDataPoint dataPoint in dataQualityErrors[dataQualityRecord])
{
index = (dataPoint.Time.ToDateTime() - startTime).Days;
if (index >= 0 && index < ReportDays)
deviceStats.DataQualityErrors[index] += dataPoint.Value;
}
}
if ((object)timeQualityRecord != null)
{
// Calculate the total time quality errors for each day being reported
foreach (IDataPoint dataPoint in timeQualityErrors[timeQualityRecord])
{
index = (dataPoint.Time.ToDateTime() - startTime).Days;
if (index >= 0 && index < ReportDays)
deviceStats.TimeQualityErrors[index] += dataPoint.Value;
}
}
// Calculate the total measurements received for each day being reported
foreach (IDataPoint dataPoint in measurementsReceived[tuple.Item1])
{
index = (dataPoint.Time.ToDateTime() - startTime).Days;
if (index >= 0 && index < ReportDays)
deviceStats.MeasurementsReceived[index] += dataPoint.Value;
}
// Calculate the total measurements expected for each day being reported
foreach (IDataPoint dataPoint in measurementsExpected[tuple.Item2])
{
index = (dataPoint.Time.ToDateTime() - startTime).Days;
if (index >= 0 && index < ReportDays)
deviceStats.MeasurementsExpected[index] += dataPoint.Value;
}
// Store the calculated stats per device
deviceStatsLookup[deviceName] = deviceStats;
}
}
// Store the statistics data to be used in the report
m_deviceStatsList = deviceStatsLookup.Values.ToList();
}
private int GetLevel(DeviceStats deviceStats, int reportDay)
{
int reportDayIndex = reportDay - 1;
double measurementsReceived = deviceStats.MeasurementsReceived[reportDayIndex];
double measurementsExpected = deviceStats.MeasurementsExpected[reportDayIndex];
if (measurementsExpected == 0.0D)
return -1;
if (measurementsReceived >= (m_level4Threshold * measurementsExpected) / 100.0D)
return 4;
if (measurementsReceived >= (m_level3Threshold * measurementsExpected) / 100.0D)
return 3;
if (measurementsReceived > 0.0D)
return 2;
if (deviceStats.MeasurementsReceived.Skip(reportDay - Month).Take(ReportDays).Any(receivedStat => receivedStat > 0.0D))
return 1;
return 0;
}
private void ReadCompletenessData()
{
Dictionary <string, DeviceStats> deviceStatsLookup = new Dictionary <string, DeviceStats>();
DateTime startTime;
DateTime endTime;
Dictionary <MetadataRecord, IEnumerable <IDataPoint> > measurementsReceived;
Dictionary <MetadataRecord, IEnumerable <IDataPoint> > measurementsExpected;
List <DeviceStats>[] todaysStats;
List <DeviceStats>[] yesterdaysStats;
string signalReference;
string deviceName;
int index;
// Create the statistics reader for reading statistics from the archive
using (StatisticsReader statisticsReader = new StatisticsReader())
{
endTime = DateTime.Today.AddDays(1.0D); // Tomorrow
startTime = endTime - TimeSpan.FromDays(ReportDays);
// Set up and open the statistics reader
statisticsReader.StartTime = startTime;
statisticsReader.EndTime = endTime;
statisticsReader.ArchiveFilePath = FilePath.GetAbsolutePath("Statistics\\stat_archive.d");
statisticsReader.Open();
measurementsReceived = statisticsReader.Read("PMU", 4);
measurementsExpected = statisticsReader.Read("PMU", 5);
// Determine which devices in the archive have stats for both measurements received and measurements expected
foreach (Tuple <MetadataRecord, MetadataRecord> tuple in measurementsReceived.Keys.Join(measurementsExpected.Keys, GetDeviceName, GetDeviceName, Tuple.Create))
{
DeviceStats deviceStats;
signalReference = tuple.Item1.Synonym1;
deviceName = GetDeviceName(tuple.Item1);
// Ignore statistics that were calculated by an intermediate gateway
if (!signalReference.StartsWith("LOCAL$") && signalReference.Contains("LOCAL$"))
{
continue;
}
// Make sure LOCAL$ statistics take precedence over other statistics calculated for the same device
if (deviceStatsLookup.ContainsKey(deviceName) && !signalReference.StartsWith("LOCAL$"))
{
continue;
}
// Create arrays to hold the total sum of the stats for each day being reported
deviceStats = new DeviceStats()
{
Name = deviceName,
MeasurementsReceived = new double[ReportDays],
MeasurementsExpected = new double[ReportDays]
};
// Calculate the total measurements received for each day being reported
foreach (IDataPoint dataPoint in measurementsReceived[tuple.Item1])
{
index = (dataPoint.Time.ToDateTime() - startTime).Days;
if (index >= 0 && index < ReportDays)
{
deviceStats.MeasurementsReceived[index] += dataPoint.Value;
}
}
// Calculate the total measurements expected for each day being reported
foreach (IDataPoint dataPoint in measurementsExpected[tuple.Item2])
{
index = (dataPoint.Time.ToDateTime() - startTime).Days;
if (index >= 0 && index < ReportDays)
{
deviceStats.MeasurementsExpected[index] += dataPoint.Value;
}
}
// Store the calculated stats per device
deviceStatsLookup[deviceName] = deviceStats;
}
}
// Store the statistics data to be used in the UI
m_deviceStatsList = deviceStatsLookup.Values.ToList();
todaysStats = GetLevels(ReportDays);
yesterdaysStats = GetLevels(ReportDays - 1);
Dispatcher.BeginInvoke(new Action(() =>
{
int total = yesterdaysStats[0].Count + yesterdaysStats[1].Count + yesterdaysStats[2].Count + yesterdaysStats[3].Count + yesterdaysStats[4].Count;
CreateGridTextItem(1, 1, HorizontalAlignment.Right, yesterdaysStats[4].Count.ToString(), CompletenessGrid);
CreateGridTextItem(2, 1, HorizontalAlignment.Right, yesterdaysStats[3].Count.ToString(), CompletenessGrid);
CreateGridTextItem(3, 1, HorizontalAlignment.Right, yesterdaysStats[2].Count.ToString(), CompletenessGrid);
CreateGridTextItem(4, 1, HorizontalAlignment.Right, yesterdaysStats[1].Count.ToString(), CompletenessGrid);
CreateGridTextItem(5, 1, HorizontalAlignment.Right, yesterdaysStats[0].Count.ToString(), CompletenessGrid);
CreateGridTextItem(7, 1, HorizontalAlignment.Right, total.ToString(), CompletenessGrid);
total = todaysStats[0].Count + todaysStats[1].Count + todaysStats[2].Count + todaysStats[3].Count + todaysStats[4].Count;
CreateGridTextItem(1, 2, HorizontalAlignment.Right, todaysStats[4].Count.ToString(), CompletenessGrid);
CreateGridTextItem(2, 2, HorizontalAlignment.Right, todaysStats[3].Count.ToString(), CompletenessGrid);
CreateGridTextItem(3, 2, HorizontalAlignment.Right, todaysStats[2].Count.ToString(), CompletenessGrid);
CreateGridTextItem(4, 2, HorizontalAlignment.Right, todaysStats[1].Count.ToString(), CompletenessGrid);
CreateGridTextItem(5, 2, HorizontalAlignment.Right, todaysStats[0].Count.ToString(), CompletenessGrid);
CreateGridTextItem(7, 2, HorizontalAlignment.Right, total.ToString(), CompletenessGrid);
}));
}
