--- /dev/null
+#!/usr/bin/python
+# -*- coding: utf8 -*-
+# author: wly
+# date: 2015-09-19
+# see license for license details
+
+import time
+import argparse
+import logging
+
+from vstf.controller.sw_perf import model
+from vstf.common import perfmark as mark
+import vstf.common.constants as cst
+from vstf.rpc_frame_work.rpc_producer import Server
+from vstf.controller.settings.flows_settings import FlowsSettings
+from vstf.controller.settings.tool_settings import ToolSettings
+from vstf.controller.settings.perf_settings import PerfSettings
+from vstf.controller.sw_perf.perf_provider import PerfProvider, get_agent_dict
+from vstf.controller.sw_perf.flow_producer import FlowsProducer
+from vstf.controller.settings.tester_settings import TesterSettings
+from vstf.controller.fabricant import Fabricant
+
+LOG = logging.getLogger(__name__)
+
+
+class Performance(object):
+ def __init__(self, conn, provider):
+ self._provider = provider
+ self._conn = conn
+ self._init()
+
+ def _init(self):
+ self._senders = []
+ self._receivers = []
+ self._watchers = []
+ self._cpuwatcher = None
+
+ def create(self, tool, tpro):
+ self._init()
+ agents = self._provider.get_cleaners(tool, tpro)
+ LOG.info(agents)
+ for agent in agents:
+ cleaner = Fabricant(agent, self._conn)
+ cleaner.clean_all_namespace()
+
+ for tester_info in self._provider.get_testers:
+ dst = tester_info["agent"]
+ params = tester_info["params"]
+ LOG.info(tester_info)
+ driver_mgr = Fabricant(dst, self._conn)
+ ret = driver_mgr.install_drivers(drivers=params["drivers"])
+ LOG.info(ret)
+
+ self.create_namespace(tool)
+ self.create_senders(tool, tpro)
+ self.create_receivers(tool, tpro)
+ self.create_watchers(tool)
+ self.create_cpuwatcher()
+
+ def destory(self, tool):
+ self.clear_namespace(tool)
+
+ def create_namespace(self, tool):
+ devices = self._provider.get_namespaces(tool)
+ agents = get_agent_dict(devices)
+ LOG.info(agents)
+ for device in devices:
+ dst = device["agent"]
+ params = device["params"]
+ if not agents[dst]:
+ model.NetDeviceMgr.clear(dst, self._conn)
+ agents[dst] = True
+
+ model.NetDeviceMgr.add(dst, self._conn, params)
+
+ def clear_namespace(self, tool):
+ devices = self._provider.get_namespaces(tool)
+ for device in devices:
+ dst = device["agent"]
+ params = device["params"]
+ model.NetDeviceMgr.remove(dst, self._conn, params)
+
+ def create_senders(self, tool, tpro):
+ sender_infos = self._provider.get_senders(tool, tpro)
+ LOG.info(sender_infos)
+ for sender_info in sender_infos:
+ dst = sender_info["agent"]
+ params = sender_info["params"]
+ send = model.Sender(dst, self._conn, tool, params)
+ self._senders.append(send)
+
+ def create_receivers(self, tool, tpro):
+ receiver_infos = self._provider.get_receivers(tool, tpro)
+ LOG.info(receiver_infos)
+ for receiver_info in receiver_infos:
+ dst = receiver_info["agent"]
+ params = receiver_info["params"]
+ receive = model.Receiver(dst, self._conn, tool, params)
+ self._receivers.append(receive)
+
+ def create_watchers(self, tool):
+ watcher_infos = self._provider.get_watchers(tool)
+ LOG.info(watcher_infos)
+ for watcher_info in watcher_infos:
+ dst = watcher_info["agent"]
+ params = watcher_info["params"]
+ watch = model.NicWatcher(dst, self._conn, params)
+ self._watchers.append(watch)
+
+ def create_cpuwatcher(self):
+ watcher_info = self._provider.get_cpuwatcher
+ LOG.info(watcher_info)
+ dst = watcher_info["agent"]
+ self._cpuwatcher = model.CpuWatcher(dst, self._conn)
+
+ def start_receivers(self, **kwargs):
+ for receiver in self._receivers:
+ receiver.start(**kwargs)
+
+ def start_senders(self, pktsize, **kwargs):
+ for sender in self._senders:
+ sender.start(pktsize, **kwargs)
+
+ def start_watchers(self):
+ for watcher in self._watchers:
+ watcher.start()
+
+ def stop_receivers(self):
+ for receiver in self._receivers:
+ receiver.stop()
+
+ def stop_senders(self):
+ for sender in self._senders:
+ sender.stop()
+
+ def stop_watchers(self):
+ for watcher in self._watchers:
+ watcher.stop()
+
+ def start_cpuwatcher(self):
+ if self._cpuwatcher:
+ self._cpuwatcher.start()
+
+ def stop_cpuwatcher(self):
+ if self._cpuwatcher:
+ self._cpuwatcher.stop()
+
+ def getlimitspeed(self, ptype, size):
+ return 0
+
+ def affctl(self):
+ ctl = self._provider.get_cpu_affctl
+ LOG.info(ctl)
+ driver_mgr = Fabricant(ctl["agent"], self._conn)
+ ret = driver_mgr.affctl_load(policy=ctl["params"]["policy"])
+ LOG.info(ret)
+
+ def run_pre_affability_settings(self, tool, tpro, pktsize, **kwargs):
+ LOG.info("run_pre_affability_settings start")
+ self.create(tool, tpro)
+ self.start_receivers()
+ self.start_senders(pktsize, **kwargs)
+ self.affctl()
+ time.sleep(2)
+ self.stop_senders()
+ self.stop_receivers()
+ self.destory(tool)
+ LOG.info("run_pre_affability_settings end")
+
+ def run_bandwidth_test(self, tool, tpro, pktsize, **kwargs):
+ LOG.info("run_bandwidth_test ")
+ self.create(tool, tpro)
+ self.start_receivers()
+ self.start_senders(pktsize, **kwargs)
+ time.sleep(self._provider.wait_balance(tool))
+ self.start_watchers()
+ self.start_cpuwatcher()
+ time.sleep(self._provider.duration(tool))
+ self.stop_watchers()
+ self.stop_cpuwatcher()
+ self.stop_senders()
+ self.stop_receivers()
+ self.destory(tool)
+ LOG.info("run_bandwidth_test end")
+
+ def run_latency_test(self, tool, tpro, pktsize, **kwargs):
+ LOG.info("run_latency_test start")
+ self.create(tool, tpro)
+ self.start_receivers()
+ self.start_senders(pktsize, **kwargs)
+ time.sleep(self._provider.duration(tool))
+ self.stop_senders()
+ self.stop_receivers()
+ self.destory(tool)
+ LOG.info("run_latency_test end")
+
+ def run(self, tool, protocol, ttype, sizes, affctl=False):
+ result = {}
+ if affctl:
+ pre_tpro = protocol + "_bw"
+ size = sizes[0]
+ self.run_pre_affability_settings(tool, pre_tpro, size, ratep=0)
+
+ for size in sizes:
+ if ttype in ['throughput', 'frameloss']:
+ realspeed = self.getlimitspeed(ttype, size)
+ bw_tpro = protocol + "_bw"
+ bw_type = ttype
+ self.run_bandwidth_test(tool, bw_tpro, size, ratep=realspeed)
+ bw_result = self.result(tool, bw_type)
+
+ lat_tool = "qperf"
+ lat_type = 'latency'
+ lat_tpro = protocol + '_lat'
+ self.run_latency_test(lat_tool, lat_tpro, size, ratep=realspeed)
+ lat_result = self.result(tool, lat_type)
+ LOG.info(bw_result)
+ LOG.info(lat_result)
+ lat_result.pop('OfferedLoad')
+ bw_result.update(lat_result)
+ result[size] = bw_result
+
+ elif ttype in ['latency']:
+ lat_tpro = protocol + '_lat'
+ lat_type = ttype
+ self.run_latency_test(tool, lat_tpro, size, ratep=None)
+ lat_result = self.result(tool, lat_type)
+ result[size] = lat_result
+ else:
+ raise Exception("error:protocol type:%s" % (ttype))
+ return result
+
+ def result(self, tool, ttype):
+ if ttype in {'throughput', 'frameloss'}:
+ record = {
+ mark.rxCount: 0,
+ mark.txCount: 0,
+ mark.bandwidth: 0,
+ mark.offLoad: 100.0,
+ mark.mppsGhz: 0,
+ mark.percentLoss: 0,
+ mark.avgLatency: 0,
+ mark.maxLatency: 0,
+ mark.minLatency: 0,
+ mark.rxMbps:0,
+ mark.txMbps:0
+ }
+
+ cpu_data = self._cpuwatcher.result()
+ print self._cpuwatcher, cpu_data
+ if cpu_data:
+ cpu_usage = cpu_data['cpu_num'] * (100 - cpu_data['idle'])
+ cpu_mhz = cpu_data['cpu_mhz']
+ record[mark.cpu] = round(cpu_usage, cst.CPU_USAGE_ROUND)
+ record[mark.duration] = self._provider.duration(tool)
+
+ for watcher in self._watchers:
+ nic_data = watcher.result()
+ record[mark.rxCount] += nic_data['rxpck']
+ record[mark.txCount] += nic_data['txpck']
+ record[mark.bandwidth] += nic_data['rxpck/s']
+ record[mark.rxMbps] += nic_data['rxmB/s']
+ record[mark.txMbps] += nic_data['txmB/s']
+
+ if record[mark.txCount]:
+ record[mark.percentLoss] = round(100 * (1 - record[mark.rxCount] / record[mark.txCount]),
+ cst.PKTLOSS_ROUND)
+ else:
+ record[mark.percentLoss] = 100
+
+ record[mark.bandwidth] /= 1000000.0
+ if cpu_mhz and record[mark.cpu]:
+ record[mark.mppsGhz] = round(record[mark.bandwidth] / (record[mark.cpu] * cpu_mhz / 100000),
+ cst.CPU_USAGE_ROUND)
+
+ record[mark.bandwidth] = round(record[mark.bandwidth], cst.RATEP_ROUND)
+
+ elif ttype in {'latency'}:
+ record = {
+ mark.offLoad: 0.0,
+ mark.avgLatency: 0,
+ mark.maxLatency: 0,
+ mark.minLatency: 0
+ }
+ minlatency, avglatency, maxlatency = 0, 0, 0
+ count = 0
+ for sender in self._senders:
+ info = sender.result()
+ LOG.info(info)
+ minlatency += info[mark.minLatency]
+ avglatency += info[mark.avgLatency]
+ maxlatency += info[mark.maxLatency]
+ count = 1 if not count else count
+ record[mark.minLatency] = round(minlatency / count, cst.TIME_ROUND)
+ record[mark.avgLatency] = round(avglatency / count, cst.TIME_ROUND)
+ record[mark.maxLatency] = round(maxlatency / count, cst.TIME_ROUND)
+
+ else:
+ raise Exception('error:protocol type:%s' % ttype)
+
+ LOG.info('record:%s' % record)
+ return record
+
+
+def unit_test():
+ from vstf.common.log import setup_logging
+ setup_logging(level=logging.DEBUG, log_file="/var/log/vstf/vstf-sw_perf.log", clevel=logging.INFO)
+
+ conn = Server("192.168.188.10")
+ perf_settings = PerfSettings()
+ flows_settings = FlowsSettings()
+ tool_settings = ToolSettings()
+ tester_settings = TesterSettings()
+ flow_producer = FlowsProducer(conn, flows_settings)
+ provider = PerfProvider(flows_settings.settings, tool_settings.settings, tester_settings.settings)
+ perf = Performance(conn, provider)
+ tests = perf_settings.settings
+ for scenario, cases in tests.items():
+ if not cases:
+ continue
+ for case in cases:
+ casetag = case['case']
+ tool = case['tool']
+ protocol = case['protocol']
+ profile = case['profile']
+ ttype = case['type']
+ sizes = case['sizes']
+
+ flow_producer.create(scenario, casetag)
+ result = perf.run(tool, protocol, ttype, sizes)
+ LOG.info(result)
+
+
+def main():
+ from vstf.common.log import setup_logging
+ setup_logging(level=logging.DEBUG, log_file="/var/log/vstf/vstf-performance.log", clevel=logging.INFO)
+ from vstf.controller.database.dbinterface import DbManage
+ parser = argparse.ArgumentParser(add_help=True)
+ parser.add_argument("case",
+ action="store",
+ help="test case like Ti-1, Tn-1, Tnv-1, Tu-1...")
+ parser.add_argument("tool",
+ action="store",
+ choices=cst.TOOLS,
+ )
+ parser.add_argument("protocol",
+ action="store",
+ choices=cst.TPROTOCOLS,
+ )
+ parser.add_argument("profile",
+ action="store",
+ choices=cst.PROFILES,
+ )
+ parser.add_argument("type",
+ action="store",
+ choices=cst.TTYPES,
+ )
+ parser.add_argument("sizes",
+ action="store",
+ default="64",
+ help='test size list "64 128"')
+ parser.add_argument("--affctl",
+ action="store_true",
+ help="when input '--affctl', the performance will do affctl before testing")
+ parser.add_argument("--monitor",
+ dest="monitor",
+ default="localhost",
+ action="store",
+ help="which ip to be monitored")
+ args = parser.parse_args()
+
+ LOG.info(args.monitor)
+ conn = Server(host=args.monitor)
+ db_mgr = DbManage()
+
+ casetag = args.case
+ tool = args.tool
+ protocol = args.protocol
+ profile = args.profile
+ ttype = args.type
+ sizes = map(lambda x: int(x), args.sizes.strip().split())
+
+ flows_settings = FlowsSettings()
+ tool_settings = ToolSettings()
+ tester_settings = TesterSettings()
+ flow_producer = FlowsProducer(conn, flows_settings)
+ provider = PerfProvider(flows_settings.settings, tool_settings.settings, tester_settings.settings)
+ perf = Performance(conn, provider)
+ scenario = db_mgr.query_scenario(casetag)
+ flow_producer.create(scenario, casetag)
+ LOG.info(flows_settings.settings)
+ result = perf.run(tool, protocol, ttype, sizes, affctl)
+
+
+if __name__ == '__main__':
+ main()
Code Review / bottlenecks.git / blobdiff