def retrieve(self):
totals = {}
for stat in self._statistics:
for key, value in stat.iteritems():
totals[key] = totals.get(key, 0) + value
if totals:
first = self._statistics[0]
current_time = time.time()
totals['elapsed'] = current_time - first['timestamp']
totals['count'] = len(self._statistics)
elements_per_second = totals['elements'] / totals['elapsed']
bits_per_second = elements_per_second * self._bitsPerElement
avg_queue_depth = totals['queueDepth'] / totals['count']
calls_per_sec = totals['count'] / totals['elapsed']
time_since_last_call = current_time - self._statistics[-1][
'timestamp']
bursts_per_second = totals['bursts'] / totals['elapsed']
bursts_per_push = totals['bursts'] / float(totals['count'])
elements_per_burst = totals['elements'] / float(totals['bursts'])
average_latency = totals['delay'] / totals['count']
else:
elements_per_second = 0.0
bits_per_second = 0.0
calls_per_sec = 0.0
avg_queue_depth = 0.0
time_since_last_call = 0.0
bursts_per_second = 0.0
bursts_per_push = 0.0
elements_per_burst = 0.0
average_latency = 0.0
# To be filled in by caller
stream_ids = []
# Add burst-specific stats to keywords
burst_stats = [('BURSTS_PER_SECOND', bursts_per_second),
('BURSTS_PER_PUSH', bursts_per_push),
('ELEMENTS_PER_BURST', elements_per_burst),
('AVERAGE_LATENCY', average_latency)]
self._addKeywords(burst_stats, totals)
keywords = [CF.DataType(k, any.to_any(v)) for k, v in burst_stats]
return BULKIO.PortStatistics(self._name, elements_per_second,
bits_per_second, calls_per_sec,
stream_ids, avg_queue_depth,
time_since_last_call, keywords)
def retrieve(self):
if not self.enabled:
return
retVal = []
for entry in self.receivedStatistics:
runningStats = BULKIO.PortStatistics(portName=self.port_ref.name,averageQueueDepth=-1,elementsPerSecond=-1,bitsPerSecond=-1,callsPerSecond=-1,streamIDs=[],timeSinceLastCall=-1,keywords=[])
listPtr = (self.receivedStatistics_idx[entry] + 1) % self.historyWindow # don't count the first set of data, since we're looking at change in time rather than absolute time
frontTime = self.receivedStatistics[entry][(self.receivedStatistics_idx[entry] - 1) % self.historyWindow].secs
backTime = self.receivedStatistics[entry][self.receivedStatistics_idx[entry]].secs
totalData = 0.0
queueSize = 0.0
streamIDs = []
while (listPtr != self.receivedStatistics_idx[entry]):
totalData += self.receivedStatistics[entry][listPtr].elements
queueSize += self.receivedStatistics[entry][listPtr].queueSize
streamIDptr = 0
foundstreamID = False
while (streamIDptr != len(streamIDs)):
if (streamIDs[streamIDptr] == self.receivedStatistics[entry][listPtr].streamID):
foundstreamID = True
break
streamIDptr += 1
if (not foundstreamID):
streamIDs.append(self.receivedStatistics[entry][listPtr].streamID)
listPtr += 1
listPtr = listPtr % self.historyWindow
currentTime = time.time()
totalTime = currentTime - backTime
if totalTime == 0:
totalTime = 1e6
receivedSize = len(self.receivedStatistics[entry])
runningStats.bitsPerSecond = (totalData * self.bitSize) / totalTime
runningStats.elementsPerSecond = totalData/totalTime
runningStats.averageQueueDepth = queueSize / receivedSize
runningStats.callsPerSecond = float((receivedSize - 1)) / totalTime
runningStats.streamIDs = streamIDs
runningStats.timeSinceLastCall = currentTime - frontTime
usesPortStat = BULKIO.UsesPortStatistics(connectionId=entry, statistics=runningStats)
retVal.append(usesPortStat)
return retVal
def retrieve(self):
if not self.enabled:
return None
self.runningStats = BULKIO.PortStatistics(portName=self.port_ref.name, averageQueueDepth=-1, elementsPerSecond=-1, bitsPerSecond=-1, callsPerSecond=-1, streamIDs=[], timeSinceLastCall=-1, keywords=[])
listPtr = (self.receivedStatistics_idx + 1) % self.historyWindow # don't count the first set of data, since we're looking at change in time rather than absolute time
frontTime = self.receivedStatistics[(self.receivedStatistics_idx - 1) % self.historyWindow].secs
backTime = self.receivedStatistics[self.receivedStatistics_idx].secs
totalData = 0.0
queueSize = 0.0
streamIDs = []
while (listPtr != self.receivedStatistics_idx):
totalData += self.receivedStatistics[listPtr].elements
queueSize += self.receivedStatistics[listPtr].queueSize
streamIDptr = 0
foundstreamID = False
while (streamIDptr != len(streamIDs)):
if (streamIDs[streamIDptr] == self.receivedStatistics[listPtr].streamID):
foundstreamID = True
break
streamIDptr += 1
if (not foundstreamID):
streamIDs.append(self.receivedStatistics[listPtr].streamID)
listPtr += 1
listPtr = listPtr%self.historyWindow
receivedSize = len(self.receivedStatistics)
currentTime = time.time()
totalTime = currentTime - backTime
if totalTime == 0:
totalTime = 1e6
self.runningStats.bitsPerSecond = (totalData * self.bitSize) / totalTime
self.runningStats.elementsPerSecond = totalData / totalTime
self.runningStats.averageQueueDepth = queueSize / receivedSize
self.runningStats.callsPerSecond = float((receivedSize - 1)) / totalTime
self.runningStats.streamIDs = streamIDs
self.runningStats.timeSinceLastCall = currentTime - frontTime
if not self.flushTime == None:
flushTotalTime = currentTime - self.flushTime
self.runningStats.keywords = [CF.DataType(id="timeSinceLastFlush", value=CORBA.Any(CORBA.TC_double, flushTotalTime))]
return self.runningStats
