VNFs/DPPD-PROX/helper-scripts/dpi/resultprocessor.py

   1 #!/bin/env python
   2
   3 ##
   4 ## Copyright (c) 2010-2017 Intel Corporation
   5 ##
   6 ## Licensed under the Apache License, Version 2.0 (the "License");
   7 ## you may not use this file except in compliance with the License.
   8 ## You may obtain a copy of the License at
   9 ##
  10 ##     http://www.apache.org/licenses/LICENSE-2.0
  11 ##
  12 ## Unless required by applicable law or agreed to in writing, software
  13 ## distributed under the License is distributed on an "AS IS" BASIS,
  14 ## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15 ## See the License for the specific language governing permissions and
  16 ## limitations under the License.
  17 ##
  18
  19 from sutstatsconsfile import *
  20 from tsstatsconsfile import *
  21 from csvwriter import *
  22
  23 class TestResult:
  24     class Times:
  25         def __init__(self):
  26             self.serie = []
  27         def addTime(self, val):
  28             self.serie.append(val)
  29         def getTime(self, i):
  30             return self.serie[i]
  31
  32     def __init__(self, testSystemCount):
  33         self.rates = None;
  34         self.tsStatsDump = [];
  35         self.tsTimes = [];
  36         for i in range(testSystemCount):
  37             self.tsStatsDump.append("");
  38             self.tsTimes.append(TestResult.Times());
  39
  40         self.sutStatsDump = None;
  41         self.sutTime = TestResult.Times();
  42
  43     def getTSCount(self):
  44         return len(self.tsTimes)
  45
  46     def setTSStatsDump(self, filePaths):
  47         self.tsStatsDump = filePaths;
  48
  49     def setSUTStatsDump(self, filePath):
  50         self.sutStatsDump = filePath;
  51
  52     def getTSStatsDump(self):
  53         return self.tsStatsDump;
  54
  55     def getSUTStatsDump(self):
  56         return self.sutStatsDump;
  57
  58     def addTimeTS(self, times):
  59         for i in range(len(times)):
  60             self.tsTimes[i].addTime(times[i])
  61
  62     def addTimeSUT(self, time):
  63         self.sutTime.addTime(time);
  64
  65
  66 class ResultProcessor:
  67     def __init__(self, testResult):
  68         self._testResults = testResult;
  69
  70     def process(self):
  71         self._readStatsConsLogs();
  72         self._mergeTsStats();
  73         self._calcSetupRate();
  74
  75     def percentHandled(self):
  76         converged_tsc = self._testResults.sutTime.getTime(1) - self._testResults.sutTime.getTime(0)
  77         end_tsc = self._testResults.sutTime.getTime(2) - self._testResults.sutTime.getTime(0)
  78
  79         converged = converged_tsc/Decimal(self._sutHz)
  80         end = end_tsc/Decimal(self._sutHz);
  81
  82         rx_converged = -1
  83         tx_converged = -1
  84         rx_end = -1
  85         tx_end = -1
  86
  87         for entry in self._sutStats:
  88             timeStamp = entry[3]
  89             if (rx_converged == -1):
  90                 if (timeStamp > converged):
  91                     rx_converged = entry[0]
  92                     tx_converged = entry[1] - entry[2]
  93                 else:
  94                     continue;
  95             else:
  96                 if (timeStamp > end):
  97                     rx_end = entry[0]
  98                     tx_end = entry[1] - entry[2]
  99                     break;
 100         return (tx_end - tx_converged)/Decimal(rx_end - rx_converged)
 101
 102     def toFile(self, fileName):
 103         outFile = CsvWriter();
 104
 105         outFile.open(fileName)
 106
 107         for entry in self._sutStats:
 108             timeStamp = round(entry[3], 3);
 109             rx = entry[0]
 110             tx = entry[1]
 111             drop = entry[2]
 112
 113             outFile.write([timeStamp, rx, tx, drop, "", ""])
 114
 115         for entry in self._tsStats:
 116             timeStamp = round(entry[-1], 3);
 117             connections = entry[0]
 118             setupRate = entry[3]
 119             outFile.write([timeStamp,"","","", connections, setupRate]);
 120         outFile.close();
 121
 122     def _readStatsConsLogs(self):
 123         print "Reading SUT stats"
 124         self._sutStats = self._readSutStats();
 125         print "Reading TS stats"
 126         self._tsAllStats = self._readAllTSStats();
 127
 128     def _mergeTsStats(self):
 129         # The first test system is the reference system. The totals
 130         # will be accumulated by repeatedly taking the closest
 131         # available data from other systems
 132         ret = []
 133         for entry in self._tsAllStats[0]:
 134             ret.append(entry)
 135
 136         interSampleTime = ret[1][-1] - ret[0][-1];
 137
 138         mergedSampleCount = 0;
 139         if (len(self._tsAllStats) == 1):
 140             mergedSampleCount = len(ret)
 141
 142         for i in range(0, len(self._tsAllStats) - 1):
 143             prev = 0;
 144             for entry in ret:
 145                 timeStamp = entry[-1]
 146                 found = False;
 147
 148                 for idx in range(prev, len(self._tsAllStats[i])):
 149                     diff = abs(self._tsAllStats[i][idx][-1] - timeStamp)
 150                     if (diff < interSampleTime):
 151                         found = True;
 152                         prev = idx;
 153                         break;
 154
 155                 if (found):
 156                     entry[0] += self._tsAllStats[i][prev][0]
 157                     entry[1] += self._tsAllStats[i][prev][1]
 158                     mergedSampleCount += 1;
 159                 else:
 160                     break;
 161
 162         self._tsStats = ret[0: mergedSampleCount];
 163
 164     def _calcSetupRate(self):
 165         for i in range(0, len(self._tsStats)):
 166             prevCreated = 0
 167             prevTime = 0
 168             if (i > 0):
 169                 prevCreated = self._tsStats[i - 1][1];
 170                 prevTime = self._tsStats[i - 1][-1];
 171             curCreated = self._tsStats[i][1];
 172             curTime = self._tsStats[i][-1];
 173
 174             setupRate = (curCreated - prevCreated)/(curTime - prevTime)
 175
 176             self._tsStats[i].append(setupRate);
 177
 178
 179     def _readSutStats(self):
 180         ret = []
 181         fileName = self._testResults.getSUTStatsDump();
 182         beg = self._testResults.sutTime.getTime(0);
 183         f = SutStatsConsFile(fileName, beg);
 184         entry = f.readNext();
 185         self._sutHz = f.getHz();
 186         while (entry is not None):
 187             ret.append(entry);
 188             entry = f.readNext();
 189         f.close();
 190         return ret;
 191
 192     def _readAllTSStats(self):
 193         stats = []
 194         for i in range(self._testResults.getTSCount()):
 195             fileName = self._testResults.getTSStatsDump()[i]
 196             beg = self._testResults.tsTimes[i].getTime(0)
 197             tsStat = self._readTSStats(fileName, beg)
 198             stats.append(tsStat);
 199         return stats;
 200
 201     def _readTSStats(self, fileName, beg):
 202         ret = []
 203         f = TSStatsConsFile(fileName, beg)
 204
 205         entry = f.readNext()
 206         while (entry is not None):
 207             ret.append(entry);
 208             entry = f.readNext();
 209         f.close()
 210         return ret;