4 ## Copyright (c) 2010-2017 Intel Corporation
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
10 ## http://www.apache.org/licenses/LICENSE-2.0
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.
20 from remotesystem import *
23 from timeseriespoint import *
26 def __init__(self, max_setup_rate, total_connections, ss):
27 self.max_setup_rate = max_setup_rate;
28 self.total_connections = total_connections;
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)
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);
43 def getConnections(self):
44 return self.total_connections;
46 class ProxDpiTester(Prox):
47 TENGIGABITBYTESPERSECOND = 1250000000
49 def __init__(self, ts, testParam, ID):
50 super(ProxDpiTester, self).__init__(ts)
55 self._prevBytesClient = None
56 self._lastBytesClient = None
57 self._prevBytesTxMeassurement = None
58 self._lastBytesTxMeassurement = None
60 self._setDefaultArguments();
61 self._setMsr(testParam.max_setup_rate)
62 self._setConnections(testParam.total_connections);
63 self._setSpeedScaling(testParam.ss);
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");
73 def _setMsr(self, msr):
74 self.addArgument("-q max_setup_rate=" + str(msr))
76 def _setConnections(self, connections):
77 self.addArgument("-q connections=" + str(connections))
80 self.addArgument("-q test_system_id=" + str(ID))
82 def _setSpeedScaling(self, ss):
83 self.addArgument("-q ss=" + str(ss))
85 def _querySetup2(self):
86 self._query_client_ports();
87 self._query_server_ports();
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]);
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]);
100 def _query_cores(self):
102 self._query_servers();
103 self._query_clients();
106 self._ld = self._get_core_list("$all_ld");
108 def _query_servers(self):
109 self._servers = self._get_core_list("$all_servers")
111 def _query_clients(self):
112 self._clients = self._get_core_list("$all_clients")
114 def _get_core_list(self, var):
116 result = self._send("echo " + var)._recv();
117 for e in result.split(","):
121 def start_all_ld(self):
122 self._send("start $all_ld");
124 def start_all_workers(self):
125 self._send("start $all_workers");
127 def stop_all_ld(self):
128 self._send("stop $all_ld");
130 def stop_all_workers(self):
131 self._send("stop $all_workers");
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"));
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));
148 def _buildTotalConnectionsCmd(self):
149 cmd = "l4gen(%s).tsc" % str(self._clients[0])
151 for core in self._clients:
154 cmd += "l4gen(%s).created,l4gen(%s).finished" % (str(core), str(core))
157 def _updateTotalConnections(self, rep):
158 instant = Decimal(int(rep[0]) - self._beg)/self._hz
161 for i in range(0,len(rep), 2):
162 tot += int(rep[i]) - int(rep[i + 1]);
164 prev = self._lastTot;
165 last = TimeSeriesPoint(tot, instant);
171 self._lastTot = last;
173 def _buildReTXCmd(self):
175 for core in self._clients + self._servers:
178 cmd += "l4gen(%s).retx" % str(core)
181 def _updateReTX(self, rep):
187 def _updateIerrors(self, rep):
188 self._ierrors = self._parseIerrorsReply(rep)
190 def get_total_connections(self):
191 return self._lastTot.getValue()
193 def getCurrentSetupRate(self):
194 return int(self._lastTot.getRateOfChange(self._prevTot));
196 def get_total_retx(self):
199 def get_rates_client_ports(self):
200 return self._calcLinkUtilization(self._prevBytesClient, self._lastBytesClient);
202 def getIerrorsCached(self):
203 return self._ierrors;
205 def _update_rates_client_ports(self, rep):
206 prevBytes = self._lastBytesClient
207 lastBytes = self._parseTimeSeries(rep);
209 if (prevBytes == None):
210 prevBytes = lastBytes;
212 self._prevBytesClient = prevBytes;
213 self._lastBytesClient = lastBytes;
215 def _getBytesPerPort(self, ports, rxOrTx):
217 sc.add(self._buildBytesPerPortCmd(ports, rxOrTx))
220 rep = sc.getResult(0);
222 return self._parseTimeSeries(rep);
224 def _buildBytesPerPortCmd(self, ports, rxOrTx):
229 cmd += "port(%s).%s.bytes,port(%s).tsc" % (str(port), rxOrTx, str(port));
232 def tx_rate_meassurement(self):
233 prev = self._lastBytesTxMeassurement
234 last = self._getBytesPerPort(self._server_ports, "tx");
239 self._prevBytesTxMeassurement = prev
240 self._lastBytesTxMeassurement = last
242 return self._calcLinkUtilization(prev, last);
244 def _parseTimeSeries(self, rep):
246 for i in range(0, len(rep), 2):
248 instant = Decimal(int(rep[1]) - self._beg)/self._hz
249 ret.append(TimeSeriesPoint(val, instant));
252 def _calcLinkUtilization(self, prev, last):
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));