- filter the data using tags,
"""
-import multiprocessing
-import os
import re
import resource
import pandas as pd
import logging
+import prettytable
from robot.api import ExecutionResult, ResultVisitor
from robot import errors
from jumpavg.AvgStdevMetadataFactory import AvgStdevMetadataFactory
from input_data_files import download_and_unzip_data_file
-from utils import Worker
# Separator used in file names
REGEX_VERSION_VPP = re.compile(r"(return STDOUT Version:\s*|"
r"VPP Version:\s*|VPP version:\s*)(.*)")
- REGEX_VERSION_DPDK = re.compile(r"(return STDOUT testpmd)([\d\D\n]*)"
- r"(RTE Version: 'DPDK )(.*)(')")
+ REGEX_VERSION_DPDK = re.compile(r"DPDK Version: (\d*.\d*)")
REGEX_TCP = re.compile(r'Total\s(rps|cps|throughput):\s([0-9]*).*$')
:returns: Nothing.
"""
- if msg.message.count("Arguments:"):
- message = str(msg.message).replace(' ', '').replace('\n', '').\
- replace("'", '"').replace('b"', '"').\
- replace("honeycom", "honeycomb")
- message = loads(message[11:-1])
+ if msg.message.count("Setup of TG node"):
+ reg_tg_ip = re.compile(
+ r'Setup of TG node (\d{1,3}.\d{1,3}.\d{1,3}.\d{1,3}) done')
try:
- self._testbed = message["TG"]["host"]
- except (KeyError, ValueError):
+ self._testbed = str(re.search(reg_tg_ip, msg.message).group(1))
+ except (KeyError, ValueError, IndexError, AttributeError):
pass
finally:
self._data["metadata"]["testbed"] = self._testbed
:returns: Nothing.
"""
- if msg.message.count("return STDOUT testpmd"):
+ if msg.message.count("DPDK Version:"):
try:
self._version = str(re.search(
- self.REGEX_VERSION_DPDK, msg.message). group(4))
+ self.REGEX_VERSION_DPDK, msg.message). group(1))
self._data["metadata"]["version"] = self._version
except IndexError:
pass
:type msg: Message
:returns: Nothing.
"""
- if msg.message.count("Thread 0 vpp_main"):
+ if msg.message.count("Runtime:"):
self._show_run_lookup_nr += 1
if self._lookup_kw_nr == 1 and self._show_run_lookup_nr == 1:
self._data["tests"][self._test_ID]["show-run"] = str()
if self._lookup_kw_nr > 1:
self._msg_type = None
if self._show_run_lookup_nr == 1:
- text = msg.message.replace("vat# ", "").\
- replace("return STDOUT ", "").replace("\n\n", "\n").\
- replace('\n', ' |br| ').\
- replace('\r', '').replace('"', "'")
+ message = str(msg.message).replace(' ', '').replace('\n', '').\
+ replace("'", '"').replace('b"', '"').replace('u"', '"')[8:]
+ runtime = loads(message)
+ try:
+ threads_nr = len(runtime[0]["clocks"])
+ except (IndexError, KeyError):
+ return
+ tbl_hdr = ["Name", "Calls", "Vectors", "Suspends", "Clocks"]
+ table = [[tbl_hdr, ] for _ in range(threads_nr)]
+ for item in runtime:
+ for idx in range(threads_nr):
+ table[idx].append([
+ item["name"],
+ item["calls"][idx],
+ item["vectors"][idx],
+ item["suspends"][idx],
+ item["clocks"][idx]
+ ])
+ text = ""
+ for idx in range(threads_nr):
+ text += "Thread {idx} ".format(idx=idx)
+ text += "vpp_main\n" if idx == 0 else \
+ "vpp_wk_{idx}\n".format(idx=idx-1)
+ txt_table = None
+ for row in table[idx]:
+ if txt_table is None:
+ txt_table = prettytable.PrettyTable(row)
+ else:
+ if any(row[1:]):
+ txt_table.add_row(row)
+ txt_table.set_style(prettytable.MSWORD_FRIENDLY)
+ txt_table.align["Name"] = "l"
+ txt_table.align["Calls"] = "r"
+ txt_table.align["Vectors"] = "r"
+ txt_table.align["Suspends"] = "r"
+ txt_table.align["Clocks"] = "r"
+
+ text += txt_table.get_string(sortby="Name") + '\n'
+
+ text = text.replace('\n', ' |br| ').replace('\r', '').\
+ replace('"', "'")
try:
self._data["tests"][self._test_ID]["show-run"] += " |br| "
self._data["tests"][self._test_ID]["show-run"] += \
self._lookup_kw_nr += 1
self._show_run_lookup_nr = 0
self._msg_type = "test-show-runtime"
- elif test_kw.name.count("Start The L2fwd Test") and not self._version:
+ elif test_kw.name.count("Install Dpdk Test") and not self._version:
self._msg_type = "dpdk-version"
else:
return
return checker.data
- def _download_and_parse_build(self, pid, data_queue, job, build, repeat):
+ def _download_and_parse_build(self, job, build, repeat, pid=10000):
"""Download and parse the input data file.
:param pid: PID of the process executing this method.
- :param data_queue: Shared memory between processes. Queue which keeps
- the result data. This data is then read by the main process and used
- in further processing.
:param job: Name of the Jenkins job which generated the processed input
file.
:param build: Information about the Jenkins build which generated the
:param repeat: Repeat the download specified number of times if not
successful.
:type pid: int
- :type data_queue: multiprocessing.Manager().Queue()
:type job: str
:type build: dict
:type repeat: int
format(full_name, repr(err))))
logs.append(("INFO", " Done."))
- result = {
- "data": data,
- "state": state,
- "job": job,
- "build": build
- }
- data_queue.put(result)
-
for level, line in logs:
if level == "INFO":
logging.info(line)
elif level == "WARNING":
logging.warning(line)
- logging.info("Memory allocation: {0:,d}MB".format(
- resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1000))
+ return {"data": data, "state": state, "job": job, "build": build}
def download_and_parse_data(self, repeat=1):
"""Download the input data files, parse input data from input files and
logging.info("Downloading and parsing input files ...")
- work_queue = multiprocessing.JoinableQueue()
- manager = multiprocessing.Manager()
- data_queue = manager.Queue()
- cpus = multiprocessing.cpu_count()
-
- workers = list()
- for cpu in range(cpus):
- worker = Worker(work_queue,
- data_queue,
- self._download_and_parse_build)
- worker.daemon = True
- worker.start()
- workers.append(worker)
- os.system("taskset -p -c {0} {1} > /dev/null 2>&1".
- format(cpu, worker.pid))
-
for job, builds in self._cfg.builds.items():
for build in builds:
- work_queue.put((job, build, repeat))
-
- work_queue.join()
-
- logging.info("Done.")
- logging.info("Collecting data:")
-
- while not data_queue.empty():
- result = data_queue.get()
-
- job = result["job"]
- build_nr = result["build"]["build"]
- logging.info(" {job}-{build}".format(job=job, build=build_nr))
-
- if result["data"]:
- data = result["data"]
- build_data = pd.Series({
- "metadata": pd.Series(
- data["metadata"].values(),
- index=data["metadata"].keys()),
- "suites": pd.Series(data["suites"].values(),
- index=data["suites"].keys()),
- "tests": pd.Series(data["tests"].values(),
- index=data["tests"].keys())})
- if self._input_data.get(job, None) is None:
- self._input_data[job] = pd.Series()
- self._input_data[job][str(build_nr)] = build_data
+ result = self._download_and_parse_build(job, build, repeat)
+ build_nr = result["build"]["build"]
- self._cfg.set_input_file_name(
- job, build_nr, result["build"]["file-name"])
+ if result["data"]:
+ data = result["data"]
+ build_data = pd.Series({
+ "metadata": pd.Series(
+ data["metadata"].values(),
+ index=data["metadata"].keys()),
+ "suites": pd.Series(data["suites"].values(),
+ index=data["suites"].keys()),
+ "tests": pd.Series(data["tests"].values(),
+ index=data["tests"].keys())})
- self._cfg.set_input_state(job, build_nr, result["state"])
+ if self._input_data.get(job, None) is None:
+ self._input_data[job] = pd.Series()
+ self._input_data[job][str(build_nr)] = build_data
- logging.info("Memory allocation: {0:,d}MB".format(
- resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1000))
+ self._cfg.set_input_file_name(
+ job, build_nr, result["build"]["file-name"])
- del data_queue
+ self._cfg.set_input_state(job, build_nr, result["state"])
- # Terminate all workers
- for worker in workers:
- worker.terminate()
- worker.join()
+ logging.info("Memory allocation: {0:,d}MB".format(
+ resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1000))
logging.info("Done.")