X-Git-Url: https://gerrit.fd.io/r/gitweb?p=csit.git;a=blobdiff_plain;f=resources%2Ftools%2Fpresentation%2Finput_data_parser.py;h=8747f938a90fbabd3b8a9e1694ce24ab6d87dd46;hp=6742439be6148f8bc7896829d293707ef8b03ff9;hb=7bd576415bbc25c00d9f5dd1b4cd19482432718f;hpb=b9aa1c7701f6f261acc4849fb07929c64e3ae692 diff --git a/resources/tools/presentation/input_data_parser.py b/resources/tools/presentation/input_data_parser.py index 6742439be6..8747f938a9 100644 --- a/resources/tools/presentation/input_data_parser.py +++ b/resources/tools/presentation/input_data_parser.py @@ -1,4 +1,4 @@ -# Copyright (c) 2020 Cisco and/or its affiliates. +# Copyright (c) 2021 Cisco and/or its affiliates. # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at: @@ -239,6 +239,15 @@ class ExecutionChecker(ResultVisitor): ) REGEX_MRR_MSG_INFO = re.compile(r'.*\[(.*)\]') + REGEX_VSAP_MSG_INFO = re.compile( + r'Transfer Rate: (\d*.\d*).*\n' + r'Latency: (\d*.\d*).*\n' + r'Completed requests: (\d*).*\n' + r'Failed requests: (\d*).*\n' + r'Total data transferred: (\d*).*\n' + r'Connection [cr]ps rate:\s*(\d*.\d*)' + ) + # Needed for CPS and PPS tests REGEX_NDRPDR_LAT_BASE = re.compile( r'LATENCY.*\[\'(.*)\', \'(.*)\'\]\s\n.*\n.*\n' @@ -278,15 +287,17 @@ class ExecutionChecker(ResultVisitor): ) REGEX_TC_TAG = re.compile(r'\d+[tT]\d+[cC]') - REGEX_TC_NAME_OLD = re.compile(r'-\d+[tT]\d+[cC]-') - REGEX_TC_NAME_NEW = re.compile(r'-\d+[cC]-') REGEX_TC_NUMBER = re.compile(r'tc\d{2}-') REGEX_TC_PAPI_CLI = re.compile(r'.*\((\d+.\d+.\d+.\d+.) - (.*)\)') - def __init__(self, metadata, mapping, ignore): + REGEX_SH_RUN_HOST = re.compile( + r'hostname=\"(\d{1,3}.\d{1,3}.\d{1,3}.\d{1,3})\",hook=\"(.*)\"' + ) + + def __init__(self, metadata, mapping, ignore, for_output): """Initialisation. :param metadata: Key-value pairs to be included in "metadata" part of @@ -294,9 +305,11 @@ class ExecutionChecker(ResultVisitor): :param mapping: Mapping of the old names of test cases to the new (actual) one. :param ignore: List of TCs to be ignored. + :param for_output: Output to be generated from downloaded data. :type metadata: dict :type mapping: dict :type ignore: list + :type for_output: str """ # Type of message to parse out from the test messages @@ -317,6 +330,8 @@ class ExecutionChecker(ResultVisitor): # Ignore list self._ignore = ignore + self._for_output = for_output + # Number of PAPI History messages found: # 0 - no message # 1 - PAPI History of DUT1 @@ -324,6 +339,8 @@ class ExecutionChecker(ResultVisitor): self._conf_history_lookup_nr = 0 self._sh_run_counter = 0 + self._telemetry_kw_counter = 0 + self._telemetry_msg_counter = 0 # Test ID of currently processed test- the lowercase full path to the # test @@ -343,14 +360,12 @@ class ExecutionChecker(ResultVisitor): # Dictionary defining the methods used to parse different types of # messages self.parse_msg = { - u"timestamp": self._get_timestamp, u"vpp-version": self._get_vpp_version, u"dpdk-version": self._get_dpdk_version, - # TODO: Remove when not needed: - u"teardown-vat-history": self._get_vat_history, u"teardown-papi-history": self._get_papi_history, u"test-show-runtime": self._get_show_run, - u"testbed": self._get_testbed + u"testbed": self._get_testbed, + u"test-telemetry": self._get_telemetry } @property @@ -572,8 +587,9 @@ class ExecutionChecker(ResultVisitor): if msg.message.count(u"return STDOUT Version:") or \ msg.message.count(u"VPP Version:") or \ msg.message.count(u"VPP version:"): - self._version = str(re.search(self.REGEX_VERSION_VPP, msg.message). - group(2)) + self._version = str( + re.search(self.REGEX_VERSION_VPP, msg.message).group(2) + ) self._data[u"metadata"][u"version"] = self._version self._msg_type = None @@ -595,42 +611,6 @@ class ExecutionChecker(ResultVisitor): finally: self._msg_type = None - def _get_timestamp(self, msg): - """Called when extraction of timestamp is required. - - :param msg: Message to process. - :type msg: Message - :returns: Nothing. - """ - - self._timestamp = msg.timestamp[:14] - self._data[u"metadata"][u"generated"] = self._timestamp - self._msg_type = None - - def _get_vat_history(self, msg): - """Called when extraction of VAT command history is required. - - TODO: Remove when not needed. - - :param msg: Message to process. - :type msg: Message - :returns: Nothing. - """ - if msg.message.count(u"VAT command history:"): - self._conf_history_lookup_nr += 1 - if self._conf_history_lookup_nr == 1: - self._data[u"tests"][self._test_id][u"conf-history"] = str() - else: - self._msg_type = None - text = re.sub(r"\d{1,3}.\d{1,3}.\d{1,3}.\d{1,3} " - r"VAT command history:", u"", - msg.message, count=1).replace(u'\n', u' |br| ').\ - replace(u'"', u"'") - - self._data[u"tests"][self._test_id][u"conf-history"] += ( - f" |br| **DUT{str(self._conf_history_lookup_nr)}:** {text}" - ) - def _get_papi_history(self, msg): """Called when extraction of PAPI command history is required. @@ -644,12 +624,14 @@ class ExecutionChecker(ResultVisitor): self._data[u"tests"][self._test_id][u"conf-history"] = str() else: self._msg_type = None - text = re.sub(r"\d{1,3}.\d{1,3}.\d{1,3}.\d{1,3} " - r"PAPI command history:", u"", - msg.message, count=1).replace(u'\n', u' |br| ').\ - replace(u'"', u"'") + text = re.sub( + r"\d{1,3}.\d{1,3}.\d{1,3}.\d{1,3} PAPI command history:", + u"", + msg.message, + count=1 + ).replace(u'"', u"'") self._data[u"tests"][self._test_id][u"conf-history"] += ( - f" |br| **DUT{str(self._conf_history_lookup_nr)}:** {text}" + f"**DUT{str(self._conf_history_lookup_nr)}:** {text}" ) def _get_show_run(self, msg): @@ -683,52 +665,90 @@ class ExecutionChecker(ResultVisitor): except (AttributeError, IndexError): sock = u"" - runtime = loads(str(msg.message).replace(u' ', u'').replace(u'\n', u''). - replace(u"'", u'"').replace(u'b"', u'"'). - replace(u'u"', u'"').split(u":", 1)[1]) + dut = u"dut{nr}".format( + nr=len(self._data[u'tests'][self._test_id][u'show-run'].keys()) + 1) - try: - threads_nr = len(runtime[0][u"clocks"]) - except (IndexError, KeyError): + self._data[u'tests'][self._test_id][u'show-run'][dut] = \ + copy.copy( + { + u"host": host, + u"socket": sock, + u"runtime": str(msg.message).replace(u' ', u''). + replace(u'\n', u'').replace(u"'", u'"'). + replace(u'b"', u'"').replace(u'u"', u'"'). + split(u":", 1)[1] + } + ) + + def _get_telemetry(self, msg): + """Called when extraction of VPP telemetry data is required. + + :param msg: Message to process. + :type msg: Message + :returns: Nothing. + """ + + if self._telemetry_kw_counter > 1: + return + if not msg.message.count(u"# TYPE vpp_runtime_calls"): return - dut = u"DUT{nr}".format( - nr=len(self._data[u'tests'][self._test_id][u'show-run'].keys()) + 1) + if u"telemetry-show-run" not in \ + self._data[u"tests"][self._test_id].keys(): + self._data[u"tests"][self._test_id][u"telemetry-show-run"] = dict() - oper = { + self._telemetry_msg_counter += 1 + groups = re.search(self.REGEX_SH_RUN_HOST, msg.message) + if not groups: + return + try: + host = groups.group(1) + except (AttributeError, IndexError): + host = u"" + try: + sock = groups.group(2) + except (AttributeError, IndexError): + sock = u"" + runtime = { + u"source_type": u"node", + u"source_id": host, + u"msg_type": u"metric", + u"log_level": u"INFO", + u"timestamp": msg.timestamp, + u"msg": u"show_runtime", u"host": host, u"socket": sock, - u"threads": OrderedDict({idx: list() for idx in range(threads_nr)}) + u"data": list() } - - for item in runtime: - for idx in range(threads_nr): - if item[u"vectors"][idx] > 0: - clocks = item[u"clocks"][idx] / item[u"vectors"][idx] - elif item[u"calls"][idx] > 0: - clocks = item[u"clocks"][idx] / item[u"calls"][idx] - elif item[u"suspends"][idx] > 0: - clocks = item[u"clocks"][idx] / item[u"suspends"][idx] - else: - clocks = 0.0 - - if item[u"calls"][idx] > 0: - vectors_call = item[u"vectors"][idx] / item[u"calls"][idx] - else: - vectors_call = 0.0 - - if int(item[u"calls"][idx]) + int(item[u"vectors"][idx]) + \ - int(item[u"suspends"][idx]): - oper[u"threads"][idx].append([ - item[u"name"], - item[u"calls"][idx], - item[u"vectors"][idx], - item[u"suspends"][idx], - clocks, - vectors_call - ]) - - self._data[u'tests'][self._test_id][u'show-run'][dut] = copy.copy(oper) + for line in msg.message.splitlines(): + if not line.startswith(u"vpp_runtime_"): + continue + try: + params, value, timestamp = line.rsplit(u" ", maxsplit=2) + cut = params.index(u"{") + name = params[:cut].split(u"_", maxsplit=2)[-1] + labels = eval( + u"dict" + params[cut:].replace('{', '(').replace('}', ')') + ) + labels[u"graph_node"] = labels.pop(u"name") + runtime[u"data"].append( + { + u"name": name, + u"value": value, + u"timestamp": timestamp, + u"labels": labels + } + ) + except (TypeError, ValueError, IndexError): + continue + self._data[u'tests'][self._test_id][u'telemetry-show-run']\ + [f"dut{self._telemetry_msg_counter}"] = copy.copy( + { + u"host": host, + u"socket": sock, + u"runtime": runtime + } + ) def _get_ndrpdr_throughput(self, msg): """Get NDR_LOWER, NDR_UPPER, PDR_LOWER and PDR_UPPER from the test @@ -912,38 +932,6 @@ class ExecutionChecker(ResultVisitor): except (IndexError, ValueError): pass - # TODO: Remove when not needed - latency[u"NDR10"] = { - u"direction1": copy.copy(latency_default), - u"direction2": copy.copy(latency_default) - } - latency[u"NDR50"] = { - u"direction1": copy.copy(latency_default), - u"direction2": copy.copy(latency_default) - } - latency[u"NDR90"] = { - u"direction1": copy.copy(latency_default), - u"direction2": copy.copy(latency_default) - } - try: - latency[u"LAT0"][u"direction1"] = process_latency(groups.group(5)) - latency[u"LAT0"][u"direction2"] = process_latency(groups.group(6)) - latency[u"NDR10"][u"direction1"] = process_latency(groups.group(7)) - latency[u"NDR10"][u"direction2"] = process_latency(groups.group(8)) - latency[u"NDR50"][u"direction1"] = process_latency(groups.group(9)) - latency[u"NDR50"][u"direction2"] = process_latency(groups.group(10)) - latency[u"NDR90"][u"direction1"] = process_latency(groups.group(11)) - latency[u"NDR90"][u"direction2"] = process_latency(groups.group(12)) - latency[u"PDR10"][u"direction1"] = process_latency(groups.group(13)) - latency[u"PDR10"][u"direction2"] = process_latency(groups.group(14)) - latency[u"PDR50"][u"direction1"] = process_latency(groups.group(15)) - latency[u"PDR50"][u"direction2"] = process_latency(groups.group(16)) - latency[u"PDR90"][u"direction1"] = process_latency(groups.group(17)) - latency[u"PDR90"][u"direction2"] = process_latency(groups.group(18)) - return latency, u"PASS" - except (IndexError, ValueError): - pass - return latency, u"FAIL" @staticmethod @@ -980,6 +968,39 @@ class ExecutionChecker(ResultVisitor): return result, status + def _get_vsap_data(self, msg, tags): + """Get data from the vsap test message. + + :param msg: The test message to be parsed. + :param tags: Test tags. + :type msg: str + :type tags: list + :returns: Parsed data as a JSON dict and the status (PASS/FAIL). + :rtype: tuple(dict, str) + """ + result = dict() + status = u"FAIL" + + groups = re.search(self.REGEX_VSAP_MSG_INFO, msg) + if groups is not None: + try: + result[u"transfer-rate"] = float(groups.group(1)) * 1e3 + result[u"latency"] = float(groups.group(2)) + result[u"completed-requests"] = int(groups.group(3)) + result[u"failed-requests"] = int(groups.group(4)) + result[u"bytes-transferred"] = int(groups.group(5)) + if u"TCP_CPS"in tags: + result[u"cps"] = float(groups.group(6)) + elif u"TCP_RPS" in tags: + result[u"rps"] = float(groups.group(6)) + else: + return result, status + status = u"PASS" + except (IndexError, ValueError): + pass + + return result, status + def visit_suite(self, suite): """Implements traversing through the suite and its direct children. @@ -1005,19 +1026,11 @@ class ExecutionChecker(ResultVisitor): except AttributeError: return - doc_str = suite.doc.\ - replace(u'"', u"'").\ - replace(u'\n', u' ').\ - replace(u'\r', u'').\ - replace(u'*[', u' |br| *[').\ - replace(u"*", u"**").\ - replace(u' |br| *[', u'*[', 1) - self._data[u"suites"][suite.longname.lower(). replace(u'"', u"'"). replace(u" ", u"_")] = { u"name": suite.name.lower(), - u"doc": doc_str, + u"doc": suite.doc, u"parent": parent_name, u"level": len(suite.longname.split(u".")) } @@ -1052,6 +1065,8 @@ class ExecutionChecker(ResultVisitor): """ self._sh_run_counter = 0 + self._telemetry_kw_counter = 0 + self._telemetry_msg_counter = 0 longname_orig = test.longname.lower() @@ -1075,103 +1090,88 @@ class ExecutionChecker(ResultVisitor): name = test.name.lower() # Remove TC number from the TC long name (backward compatibility): - self._test_id = re.sub( - self.REGEX_TC_NUMBER, u"", longname.replace(u"snat", u"nat") - ) + self._test_id = re.sub(self.REGEX_TC_NUMBER, u"", longname) # Remove TC number from the TC name (not needed): - test_result[u"name"] = re.sub( - self.REGEX_TC_NUMBER, "", name.replace(u"snat", u"nat") - ) + test_result[u"name"] = re.sub(self.REGEX_TC_NUMBER, "", name) - test_result[u"parent"] = test.parent.name.lower().\ - replace(u"snat", u"nat") + test_result[u"parent"] = test.parent.name.lower() test_result[u"tags"] = tags - test_result["doc"] = test.doc.\ - replace(u'"', u"'").\ - replace(u'\n', u' ').\ - replace(u'\r', u'').\ - replace(u'[', u' |br| [').\ - replace(u' |br| [', u'[', 1) - test_result[u"type"] = u"FUNC" + test_result["doc"] = test.doc + test_result[u"type"] = u"" test_result[u"status"] = test.status + test_result[u"starttime"] = test.starttime + test_result[u"endtime"] = test.endtime if test.status == u"PASS": if u"NDRPDR" in tags: if u"TCP_PPS" in tags or u"UDP_PPS" in tags: test_result[u"msg"] = self._get_data_from_pps_test_msg( - test.message).replace(u'\n', u' |br| '). \ - replace(u'\r', u'').replace(u'"', u"'") + test.message) elif u"TCP_CPS" in tags or u"UDP_CPS" in tags: test_result[u"msg"] = self._get_data_from_cps_test_msg( - test.message).replace(u'\n', u' |br| '). \ - replace(u'\r', u'').replace(u'"', u"'") + test.message) else: test_result[u"msg"] = self._get_data_from_perf_test_msg( - test.message).replace(u'\n', u' |br| ').\ - replace(u'\r', u'').replace(u'"', u"'") + test.message) elif u"MRR" in tags or u"FRMOBL" in tags or u"BMRR" in tags: test_result[u"msg"] = self._get_data_from_mrr_test_msg( - test.message).replace(u'\n', u' |br| ').\ - replace(u'\r', u'').replace(u'"', u"'") + test.message) else: - test_result[u"msg"] = test.message.replace(u'\n', u' |br| ').\ - replace(u'\r', u'').replace(u'"', u"'") + test_result[u"msg"] = test.message else: - test_result[u"msg"] = u"Test Failed." + test_result[u"msg"] = test.message - if u"PERFTEST" in tags: + if u"PERFTEST" in tags and u"TREX" not in tags: # Replace info about cores (e.g. -1c-) with the info about threads # and cores (e.g. -1t1c-) in the long test case names and in the # test case names if necessary. - groups = re.search(self.REGEX_TC_NAME_OLD, self._test_id) - if not groups: - tag_count = 0 - tag_tc = str() - for tag in test_result[u"tags"]: - groups = re.search(self.REGEX_TC_TAG, tag) - if groups: - tag_count += 1 - tag_tc = tag - - if tag_count == 1: - self._test_id = re.sub( - self.REGEX_TC_NAME_NEW, f"-{tag_tc.lower()}-", - self._test_id, count=1 - ) - test_result[u"name"] = re.sub( - self.REGEX_TC_NAME_NEW, f"-{tag_tc.lower()}-", - test_result["name"], count=1 - ) - else: - test_result[u"status"] = u"FAIL" - self._data[u"tests"][self._test_id] = test_result - logging.debug( - f"The test {self._test_id} has no or more than one " - f"multi-threading tags.\n" - f"Tags: {test_result[u'tags']}" - ) - return + tag_count = 0 + tag_tc = str() + for tag in test_result[u"tags"]: + groups = re.search(self.REGEX_TC_TAG, tag) + if groups: + tag_count += 1 + tag_tc = tag + + if tag_count == 1: + self._test_id = re.sub( + self.REGEX_TC_NAME_NEW, f"-{tag_tc.lower()}-", + self._test_id, count=1 + ) + test_result[u"name"] = re.sub( + self.REGEX_TC_NAME_NEW, f"-{tag_tc.lower()}-", + test_result["name"], count=1 + ) + else: + test_result[u"status"] = u"FAIL" + self._data[u"tests"][self._test_id] = test_result + logging.debug( + f"The test {self._test_id} has no or more than one " + f"multi-threading tags.\n" + f"Tags: {test_result[u'tags']}" + ) + return - if test.status == u"PASS": - if u"DEVICETEST" in tags: - test_result[u"type"] = u"DEVICETEST" - elif u"NDRPDR" in tags: - if u"TCP_CPS" in tags or u"UDP_CPS" in tags: - test_result[u"type"] = u"CPS" - else: - test_result[u"type"] = u"NDRPDR" + if u"DEVICETEST" in tags: + test_result[u"type"] = u"DEVICETEST" + elif u"NDRPDR" in tags: + if u"TCP_CPS" in tags or u"UDP_CPS" in tags: + test_result[u"type"] = u"CPS" + else: + test_result[u"type"] = u"NDRPDR" + if test.status == u"PASS": test_result[u"throughput"], test_result[u"status"] = \ self._get_ndrpdr_throughput(test.message) test_result[u"gbps"], test_result[u"status"] = \ self._get_ndrpdr_throughput_gbps(test.message) test_result[u"latency"], test_result[u"status"] = \ self._get_ndrpdr_latency(test.message) - elif u"MRR" in tags or u"FRMOBL" in tags or u"BMRR" in tags: - if u"MRR" in tags: - test_result[u"type"] = u"MRR" - else: - test_result[u"type"] = u"BMRR" - + elif u"MRR" in tags or u"FRMOBL" in tags or u"BMRR" in tags: + if u"MRR" in tags: + test_result[u"type"] = u"MRR" + else: + test_result[u"type"] = u"BMRR" + if test.status == u"PASS": test_result[u"result"] = dict() groups = re.search(self.REGEX_BMRR, test.message) if groups is not None: @@ -1182,26 +1182,35 @@ class ExecutionChecker(ResultVisitor): ] # Use whole list in CSIT-1180. stats = jumpavg.AvgStdevStats.for_runs(items_float) + test_result[u"result"][u"samples"] = items_float test_result[u"result"][u"receive-rate"] = stats.avg test_result[u"result"][u"receive-stdev"] = stats.stdev else: groups = re.search(self.REGEX_MRR, test.message) test_result[u"result"][u"receive-rate"] = \ float(groups.group(3)) / float(groups.group(1)) - elif u"SOAK" in tags: - test_result[u"type"] = u"SOAK" + elif u"SOAK" in tags: + test_result[u"type"] = u"SOAK" + if test.status == u"PASS": test_result[u"throughput"], test_result[u"status"] = \ self._get_plr_throughput(test.message) - elif u"HOSTSTACK" in tags: - test_result[u"type"] = u"HOSTSTACK" + elif u"HOSTSTACK" in tags: + test_result[u"type"] = u"HOSTSTACK" + if test.status == u"PASS": test_result[u"result"], test_result[u"status"] = \ self._get_hoststack_data(test.message, tags) - elif u"TCP" in tags: - test_result[u"type"] = u"TCP" - groups = re.search(self.REGEX_TCP, test.message) - test_result[u"result"] = int(groups.group(2)) - elif u"RECONF" in tags: - test_result[u"type"] = u"RECONF" + elif u"LDP_NGINX" in tags: + test_result[u"type"] = u"LDP_NGINX" + test_result[u"result"], test_result[u"status"] = \ + self._get_vsap_data(test.message, tags) + # elif u"TCP" in tags: # This might be not used + # test_result[u"type"] = u"TCP" + # if test.status == u"PASS": + # groups = re.search(self.REGEX_TCP, test.message) + # test_result[u"result"] = int(groups.group(2)) + elif u"RECONF" in tags: + test_result[u"type"] = u"RECONF" + if test.status == u"PASS": test_result[u"result"] = None try: grps_loss = re.search(self.REGEX_RECONF_LOSS, test.message) @@ -1212,10 +1221,8 @@ class ExecutionChecker(ResultVisitor): } except (AttributeError, IndexError, ValueError, TypeError): test_result[u"status"] = u"FAIL" - else: - test_result[u"status"] = u"FAIL" - self._data[u"tests"][self._test_id] = test_result - return + else: + test_result[u"status"] = u"FAIL" self._data[u"tests"][self._test_id] = test_result @@ -1283,9 +1290,13 @@ class ExecutionChecker(ResultVisitor): :type test_kw: Keyword :returns: Nothing. """ - if test_kw.name.count(u"Show Runtime On All Duts") or \ - test_kw.name.count(u"Show Runtime Counters On All Duts") or \ - test_kw.name.count(u"Vpp Show Runtime On All Duts"): + if self._for_output == u"trending": + return + + if test_kw.name.count(u"Run Telemetry On All Duts"): + self._msg_type = u"test-telemetry" + self._telemetry_kw_counter += 1 + elif test_kw.name.count(u"Show Runtime On All Duts"): self._msg_type = u"test-show-runtime" self._sh_run_counter += 1 else: @@ -1327,9 +1338,6 @@ class ExecutionChecker(ResultVisitor): elif setup_kw.name.count(u"Install Dpdk Framework On All Duts") and \ not self._version: self._msg_type = u"dpdk-version" - elif setup_kw.name.count(u"Set Global Variable") \ - and not self._timestamp: - self._msg_type = u"timestamp" elif setup_kw.name.count(u"Setup Framework") and not self._testbed: self._msg_type = u"testbed" else: @@ -1364,13 +1372,7 @@ class ExecutionChecker(ResultVisitor): :type teardown_kw: Keyword :returns: Nothing. """ - - if teardown_kw.name.count(u"Show Vat History On All Duts"): - # TODO: Remove when not needed: - self._conf_history_lookup_nr = 0 - self._msg_type = u"teardown-vat-history" - teardown_kw.messages.visit(self) - elif teardown_kw.name.count(u"Show Papi History On All Duts"): + if teardown_kw.name.count(u"Show Papi History On All Duts"): self._conf_history_lookup_nr = 0 self._msg_type = u"teardown-papi-history" teardown_kw.messages.visit(self) @@ -1430,16 +1432,20 @@ class InputData: (as described in ExecutionChecker documentation) """ - def __init__(self, spec): + def __init__(self, spec, for_output): """Initialization. :param spec: Specification. + :param for_output: Output to be generated from downloaded data. :type spec: Specification + :type for_output: str """ # Specification: self._cfg = spec + self._for_output = for_output + # Data store: self._input_data = pd.Series() @@ -1513,10 +1519,20 @@ class InputData: f"Error occurred while parsing output.xml: {repr(err)}" ) return None - checker = ExecutionChecker(metadata, self._cfg.mapping, - self._cfg.ignore) + checker = ExecutionChecker( + metadata, self._cfg.mapping, self._cfg.ignore, self._for_output + ) result.visit(checker) + checker.data[u"metadata"][u"tests_total"] = \ + result.statistics.total.all.total + checker.data[u"metadata"][u"tests_passed"] = \ + result.statistics.total.all.passed + checker.data[u"metadata"][u"tests_failed"] = \ + result.statistics.total.all.failed + checker.data[u"metadata"][u"elapsedtime"] = result.suite.elapsedtime + checker.data[u"metadata"][u"generated"] = result.suite.endtime[:14] + return checker.data def _download_and_parse_build(self, job, build, repeat, pid=10000): @@ -1535,7 +1551,7 @@ class InputData: :type repeat: int """ - logging.info(f" Processing the job/build: {job}: {build[u'build']}") + logging.info(f"Processing the job/build: {job}: {build[u'build']}") state = u"failed" success = False @@ -1553,7 +1569,7 @@ class InputData: f"Skipped." ) if success: - logging.info(f" Processing data from build {build[u'build']}") + logging.info(f" Processing data from build {build[u'build']}") data = self._parse_tests(job, build) if data is None: logging.error( @@ -1573,7 +1589,7 @@ class InputData: # If the time-period is defined in the specification file, remove all # files which are outside the time period. is_last = False - timeperiod = self._cfg.input.get(u"time-period", None) + timeperiod = self._cfg.environment.get(u"time-period", None) if timeperiod and data: now = dt.utcnow() timeperiod = timedelta(int(timeperiod)) @@ -1588,11 +1604,9 @@ class InputData: data = None is_last = True logging.info( - f" The build {job}/{build[u'build']} is " + f" The build {job}/{build[u'build']} is " f"outdated, will be removed." ) - logging.info(u" Done.") - return { u"data": data, u"state": state, @@ -1612,7 +1626,7 @@ class InputData: logging.info(u"Downloading and parsing input files ...") - for job, builds in self._cfg.builds.items(): + for job, builds in self._cfg.input.items(): for build in builds: result = self._download_and_parse_build(job, build, repeat) @@ -1640,10 +1654,9 @@ class InputData: if self._input_data.get(job, None) is None: self._input_data[job] = pd.Series() self._input_data[job][str(build_nr)] = build_data - self._cfg.set_input_file_name( - job, build_nr, result[u"build"][u"file-name"]) - + job, build_nr, result[u"build"][u"file-name"] + ) self._cfg.set_input_state(job, build_nr, result[u"state"]) mem_alloc = \ @@ -1652,6 +1665,16 @@ class InputData: logging.info(u"Done.") + msg = f"Successful downloads from the sources:\n" + for source in self._cfg.environment[u"data-sources"]: + if source[u"successful-downloads"]: + msg += ( + f"{source[u'url']}/{source[u'path']}/" + f"{source[u'file-name']}: " + f"{source[u'successful-downloads']}\n" + ) + logging.info(msg) + def process_local_file(self, local_file, job=u"local", build_nr=1, replace=True): """Process local XML file given as a command-line parameter. @@ -1682,7 +1705,7 @@ class InputData: u"file-name": local_file } if replace: - self._cfg.builds = dict() + self._cfg.input = dict() self._cfg.add_build(job, build) logging.info(f"Processing {job}: {build_nr:2d}: {local_file}") @@ -1767,7 +1790,7 @@ class InputData: ) if replace: - self._cfg.builds = dict() + self._cfg.input = dict() for job, files in local_builds.items(): for idx, local_file in enumerate(files): @@ -1862,7 +1885,7 @@ class InputData: if params is None: params = element.get(u"parameters", None) if params: - params.append(u"type") + params.extend((u"type", u"status")) data_to_filter = data if data else element[u"data"] data = pd.Series() @@ -1953,16 +1976,25 @@ class InputData: if params is None: params = element.get(u"parameters", None) - if params: + if params and u"type" not in params: params.append(u"type") + cores = element.get(u"core", None) + if cores: + tests = list() + for core in cores: + for test in include: + tests.append(test.format(core=core)) + else: + tests = include + data = pd.Series() try: for job, builds in element[u"data"].items(): data[job] = pd.Series() for build in builds: data[job][str(build)] = pd.Series() - for test in include: + for test in tests: try: reg_ex = re.compile(str(test).lower()) for test_id in self.data[job][ @@ -2036,15 +2068,6 @@ class InputData: """Print all operational data to console. """ - tbl_hdr = ( - u"Name", - u"Nr of Vectors", - u"Nr of Packets", - u"Suspends", - u"Cycles per Packet", - u"Average Vector Size" - ) - for job in self._input_data.values: for build in job.values: for test_id, test_data in build[u"tests"].items(): @@ -2052,12 +2075,60 @@ class InputData: if test_data.get(u"show-run", None) is None: continue for dut_name, data in test_data[u"show-run"].items(): - if data.get(u"threads", None) is None: + if data.get(u"runtime", None) is None: + continue + runtime = loads(data[u"runtime"]) + try: + threads_nr = len(runtime[0][u"clocks"]) + except (IndexError, KeyError): continue + threads = OrderedDict( + {idx: list() for idx in range(threads_nr)}) + for item in runtime: + for idx in range(threads_nr): + if item[u"vectors"][idx] > 0: + clocks = item[u"clocks"][idx] / \ + item[u"vectors"][idx] + elif item[u"calls"][idx] > 0: + clocks = item[u"clocks"][idx] / \ + item[u"calls"][idx] + elif item[u"suspends"][idx] > 0: + clocks = item[u"clocks"][idx] / \ + item[u"suspends"][idx] + else: + clocks = 0.0 + + if item[u"calls"][idx] > 0: + vectors_call = item[u"vectors"][idx] / \ + item[u"calls"][idx] + else: + vectors_call = 0.0 + + if int(item[u"calls"][idx]) + int( + item[u"vectors"][idx]) + \ + int(item[u"suspends"][idx]): + threads[idx].append([ + item[u"name"], + item[u"calls"][idx], + item[u"vectors"][idx], + item[u"suspends"][idx], + clocks, + vectors_call + ]) + print(f"Host IP: {data.get(u'host', '')}, " f"Socket: {data.get(u'socket', '')}") - for thread_nr, thread in data[u"threads"].items(): - txt_table = prettytable.PrettyTable(tbl_hdr) + for thread_nr, thread in threads.items(): + txt_table = prettytable.PrettyTable( + ( + u"Name", + u"Nr of Vectors", + u"Nr of Packets", + u"Suspends", + u"Cycles per Packet", + u"Average Vector Size" + ) + ) avg = 0.0 for row in thread: txt_table.add_row(row)