VNFs/DPPD-PROX/helper-scripts/dpi/proxdpitester.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 prox import *
  20 from remotesystem import *
  21 from time import *
  22 from decimal import *
  23 from timeseriespoint import *
  24
  25 class TestParameters:
  26     def __init__(self, max_setup_rate, total_connections, ss):
  27         self.max_setup_rate = max_setup_rate;
  28         self.total_connections = total_connections;
  29         self.ss = ss;
  30
  31     def toString(self):
  32         ret = ""
  33         ret += "\tMaximum setup rate          = %d\n" % self.max_setup_rate
  34         ret += "\tTotal number of connections = %d\n" % self.total_connections
  35         ret += "\tSpeed scaling               = %s\n" % str(self.ss)
  36         return ret;
  37
  38     def getPerSystem(self, count):
  39         msr = self.max_setup_rate / count
  40         cnn = self.total_connections / count
  41         return TestParameters(msr, cnn, self.ss);
  42
  43     def getConnections(self):
  44         return self.total_connections;
  45
  46 class ProxDpiTester(Prox):
  47     TENGIGABITBYTESPERSECOND = 1250000000
  48
  49     def __init__(self, ts, testParam, ID):
  50         super(ProxDpiTester, self).__init__(ts)
  51
  52         self._sc = None
  53         self._lastTot = None
  54         self._prevTot = None;
  55         self._prevBytesClient = None
  56         self._lastBytesClient = None
  57         self._prevBytesTxMeassurement = None
  58         self._lastBytesTxMeassurement = None
  59
  60         self._setDefaultArguments();
  61         self._setMsr(testParam.max_setup_rate)
  62         self._setConnections(testParam.total_connections);
  63         self._setSpeedScaling(testParam.ss);
  64         self._setID(ID);
  65
  66     def _setDefaultArguments(self):
  67         self.addArgument("-e")
  68         self.addArgument("-t")
  69         self.addArgument("-k")
  70         self.addArgument("-d")
  71         self.addArgument("-r 0.01");
  72
  73     def _setMsr(self, msr):
  74         self.addArgument("-q max_setup_rate=" + str(msr))
  75
  76     def _setConnections(self, connections):
  77         self.addArgument("-q connections=" + str(connections))
  78
  79     def _setID(self, ID):
  80         self.addArgument("-q test_system_id=" + str(ID))
  81
  82     def _setSpeedScaling(self, ss):
  83         self.addArgument("-q ss=" + str(ss))
  84
  85     def _querySetup2(self):
  86         self._query_client_ports();
  87         self._query_server_ports();
  88         self._query_cores();
  89
  90     def _query_client_ports(self):
  91         self._client_ports = []
  92         for i in range(0, len(self._ports), 2):
  93             self._client_ports.append(self._ports[i]);
  94
  95     def _query_server_ports(self):
  96         self._server_ports = []
  97         for i in range(1, len(self._ports), 2):
  98             self._server_ports.append(self._ports[i]);
  99
 100     def _query_cores(self):
 101         self._query_ld();
 102         self._query_servers();
 103         self._query_clients();
 104
 105     def _query_ld(self):
 106         self._ld = self._get_core_list("$all_ld");
 107
 108     def _query_servers(self):
 109         self._servers = self._get_core_list("$all_servers")
 110
 111     def _query_clients(self):
 112         self._clients = self._get_core_list("$all_clients")
 113
 114     def _get_core_list(self, var):
 115         ret = []
 116         result = self._send("echo " + var)._recv();
 117         for e in result.split(","):
 118             ret += [e];
 119         return ret;
 120
 121     def start_all_ld(self):
 122         self._send("start $all_ld");
 123
 124     def start_all_workers(self):
 125         self._send("start $all_workers");
 126
 127     def stop_all_ld(self):
 128         self._send("stop $all_ld");
 129
 130     def stop_all_workers(self):
 131         self._send("stop $all_workers");
 132
 133     def update_stats(self):
 134         if (self._sc is None):
 135             self._sc = StatsCmd(self)
 136             self._sc.add(self._buildTotalConnectionsCmd())
 137             self._sc.add(self._buildReTXCmd())
 138             self._sc.add(self._buildIerrorsCmd())
 139             self._sc.add(self._buildBytesPerPortCmd(self._client_ports, "rx"));
 140
 141         self._sc.sendRecv()
 142
 143         self._updateTotalConnections(self._sc.getResult(0))
 144         self._updateReTX(self._sc.getResult(1))
 145         self._updateIerrors(self._sc.getResult(2))
 146         self._update_rates_client_ports(self._sc.getResult(3));
 147
 148     def _buildTotalConnectionsCmd(self):
 149         cmd = "l4gen(%s).tsc" % str(self._clients[0])
 150
 151         for core in self._clients:
 152             if (len(cmd) > 0):
 153                 cmd += ","
 154             cmd += "l4gen(%s).created,l4gen(%s).finished" % (str(core), str(core))
 155         return cmd;
 156
 157     def _updateTotalConnections(self, rep):
 158         instant = Decimal(int(rep[0]) - self._beg)/self._hz
 159         rep = rep[1:]
 160         tot = 0;
 161         for i in range(0,len(rep), 2):
 162             tot += int(rep[i]) - int(rep[i + 1]);
 163
 164         prev = self._lastTot;
 165         last = TimeSeriesPoint(tot, instant);
 166
 167         if (prev == None):
 168             prev = last;
 169
 170         self._prevTot = prev
 171         self._lastTot = last;
 172
 173     def _buildReTXCmd(self):
 174         cmd = ""
 175         for core in self._clients + self._servers:
 176             if (len(cmd) > 0):
 177                 cmd += ","
 178             cmd += "l4gen(%s).retx" % str(core)
 179         return cmd;
 180
 181     def _updateReTX(self, rep):
 182         retx = 0;
 183         for i in rep:
 184             retx += int(i);
 185         self._retx = retx;
 186
 187     def _updateIerrors(self, rep):
 188         self._ierrors = self._parseIerrorsReply(rep)
 189
 190     def get_total_connections(self):
 191         return self._lastTot.getValue()
 192
 193     def getCurrentSetupRate(self):
 194         return int(self._lastTot.getRateOfChange(self._prevTot));
 195
 196     def get_total_retx(self):
 197         return self._retx
 198
 199     def get_rates_client_ports(self):
 200         return self._calcLinkUtilization(self._prevBytesClient, self._lastBytesClient);
 201
 202     def getIerrorsCached(self):
 203         return self._ierrors;
 204
 205     def _update_rates_client_ports(self, rep):
 206         prevBytes = self._lastBytesClient
 207         lastBytes = self._parseTimeSeries(rep);
 208
 209         if (prevBytes == None):
 210             prevBytes = lastBytes;
 211
 212         self._prevBytesClient = prevBytes;
 213         self._lastBytesClient = lastBytes;
 214
 215     def _getBytesPerPort(self, ports, rxOrTx):
 216         sc = StatsCmd(self);
 217         sc.add(self._buildBytesPerPortCmd(ports, rxOrTx))
 218         sc.sendRecv();
 219
 220         rep = sc.getResult(0);
 221
 222         return self._parseTimeSeries(rep);
 223
 224     def _buildBytesPerPortCmd(self, ports, rxOrTx):
 225         cmd = ""
 226         for port in ports:
 227             if (len(cmd) > 0):
 228                 cmd += ","
 229             cmd += "port(%s).%s.bytes,port(%s).tsc" % (str(port), rxOrTx, str(port));
 230         return cmd
 231
 232     def tx_rate_meassurement(self):
 233         prev = self._lastBytesTxMeassurement
 234         last = self._getBytesPerPort(self._server_ports, "tx");
 235
 236         if (prev == None):
 237             prev = last;
 238
 239         self._prevBytesTxMeassurement = prev
 240         self._lastBytesTxMeassurement = last
 241
 242         return self._calcLinkUtilization(prev, last);
 243
 244     def _parseTimeSeries(self, rep):
 245         ret = []
 246         for i in range(0, len(rep), 2):
 247             val = int(rep[0])
 248             instant = Decimal(int(rep[1]) - self._beg)/self._hz
 249             ret.append(TimeSeriesPoint(val, instant));
 250         return ret;
 251
 252     def _calcLinkUtilization(self, prev, last):
 253         ret = []
 254         for i in range(0, len(prev)):
 255             bytesPerSecond = last[i].getRateOfChange(prev[i]);
 256             linkFraction = Decimal(bytesPerSecond)/self.TENGIGABITBYTESPERSECOND
 257             ret.append(round(linkFraction,2));
 258         return ret;