WIP, limpiando codigo, reorganizando y refactorizando

Author: JonatanEnes

.gitignore

@@ -1,4 +1,6 @@
 /REPORTS/*
+/src/timeseries_plots/
 .pyc
 **/__pycache__/**
 .idea/
+conf/experiments/report_generator_config.ini

conf/experiments/blockchain/report_generator_config.ini

@@ -5,11 +5,12 @@ PRINT_MISSING_INFO_REPORT = true
 PRINT_TEST_BASIC_INFORMATION = true
 
 GENERATE_EXPERIMENT_PLOT = true
-GENERATE_USER_PLOTS = false
-GENERATE_APP_PLOTS = false
+GENERATE_USER_PLOTS = true
+GENERATE_APP_PLOTS = true
 GENERATE_NODES_PLOTS = true
 
 NODES_LIST = "cont0"
+USERS_LIST = "user0"
 
 STATIC_LIMITS = false
 REPORTED_RESOURCES = "cpu"

src/ExperimentReporter.py

@@ -25,14 +25,13 @@
 import sys
 import time
 
-from src.lineplotting.lineplots import plot_document, plot_user
+from src.lineplotting.lineplots import plot_test, plot_user
 from src.common.config import Config, MongoDBConfig, eprint
 
 from src.latex.latex_output import print_latex_section
 from src.TestReporter import TestReporter
 from TimestampsSnitch.src.mongodb.mongodb_agent import MongoDBTimestampAgent
-from src.common.utils import generate_duration, print_basic_doc_info, split_tests_by_test_type, \
-    generate_resources_timeseries, get_plots
+from src.common.utils import generate_duration, print_basic_doc_info, generate_resources_timeseries, nowt
 
 
 class ExperimentReporter():
@@ -41,111 +40,38 @@ def __init__(self):
         mongoDBConfig = MongoDBConfig()
         self.timestampingAgent = MongoDBTimestampAgent(mongoDBConfig.get_config_as_dict())
 
-    def get_experiment_data(self, exp):
-        exp = generate_duration(exp)
-        exp = generate_resources_timeseries(exp, self.cfg)
-        return exp
-
-    def print_experiment_report(self, exp):
-        # PRINT EXPERIMENT INFO
-        print_latex_section("Experiment basic information")
-        print_basic_doc_info(exp)
-
-    def report_tests_serverless(self, processed_tests):
+    def report_tests(self, processed_tests):
         testRepo = TestReporter()
 
-        # PRINT TESTS RESOURCE INFO
-        # (durations with overheads, resource usages, utilization, overheads, hysteresis and basic each test info)
-        benchmarks = split_tests_by_test_type(processed_tests)
-        test_reports = [
-            ("Resource usages", testRepo.print_tests_resource_usage, [], True),
-            ("Tests durations", testRepo.print_tests_times, [], True),
-            ("Tests basic information", testRepo.print_test_report, [self.cfg.PRINT_NODE_INFO],
-             self.cfg.PRINT_TEST_BASIC_INFORMATION),
-            ("Missing information report", testRepo.report_resources_missing_data, [],
-             self.cfg.PRINT_MISSING_INFO_REPORT),
-            ("Resource utilization", testRepo.print_tests_resource_utilization, [], True),
-            ("Tests durations and overheads", testRepo.print_summarized_tests_info, [self.cfg.NUM_BASE_EXPERIMENTS],
-             False),
-            ("Resource overheads", testRepo.print_tests_resource_overhead_report, [self.cfg.NUM_BASE_EXPERIMENTS],
-             False and self.cfg.NUM_BASE_EXPERIMENTS != 0)]
-
-        for test_type in benchmarks:
-            for report in test_reports:
-                report_name, report_function, report_function_extra, bool_apply = report
-                if bool_apply:
-                    eprint("Doing {0} for {1} at {2}".format(
-                        report_name, test_type, time.strftime("%D %H:%M:%S", time.localtime())))
-                    print_latex_section("{0} for {1}".format(report_name, test_type))
-                    args = tuple([benchmarks[test_type]] + report_function_extra)
-                    report_function(*args)
-
-        if self.cfg.GENERATE_APP_PLOTS or self.cfg.GENERATE_NODES_PLOTS:
-            for test_type in benchmarks:
-                eprint("Plotting resource plots for {0} at {1}".format(
-                    test_type, time.strftime("%D %H:%M:%S", time.localtime())))
-                testRepo.generate_test_resource_plot(benchmarks[test_type])
-
-    def report_tests_energy(self, processed_tests):
-        testRepo = TestReporter()
-        # PRINT TESTS RESOURCE INFO
-        # (durations with overheads, resource usages, utilization, overheads, hysteresis and basic each test info)
         test_reports = [
-            ("Resource usages", testRepo.print_tests_resource_usage, [], True),
-            ("Tests durations", testRepo.print_tests_times, [], True),
-            ("Tests basic information", testRepo.print_test_report, [self.cfg.PRINT_NODE_INFO],
-             self.cfg.PRINT_TEST_BASIC_INFORMATION),
-            ("Missing information report", testRepo.report_resources_missing_data, [],
-             self.cfg.PRINT_MISSING_INFO_REPORT),
-            ("Resource utilization", testRepo.print_tests_resource_utilization, [], True)]
+            ("Resource usages", testRepo.print_tests_resource_usage, True),
+            ("Tests durations", testRepo.print_tests_times, True),
+            ("Tests basic information", testRepo.print_test_report, self.cfg.PRINT_TEST_BASIC_INFORMATION),
+            ("Missing information report", testRepo.report_resources_missing_data, self.cfg.PRINT_MISSING_INFO_REPORT),
+            ("Resource utilization", testRepo.print_tests_resource_utilization, True),
+        ]
 
         for report in test_reports:
-            report_name, report_function, report_function_extra, bool_apply = report
+            report_name, report_function, bool_apply = report
             if bool_apply:
-                eprint("Doing {0} at {1}".format(
-                    report_name, time.strftime("%D %H:%M:%S", time.localtime())))
+                eprint("Doing {0} at {1}".format(report_name, nowt()))
                 print_latex_section("{0}".format(report_name))
-                args = tuple([processed_tests] + report_function_extra)
-                report_function(*args)
+                report_function(processed_tests)
 
         if self.cfg.GENERATE_APP_PLOTS or self.cfg.GENERATE_NODES_PLOTS:
+            eprint("Plotting resource plots for at {0}".format(nowt()))
             testRepo.generate_test_resource_plot(processed_tests)
 
-    def report_experiment(self, exp):
+
+    def report_experiment(self, experiment):
         testRepo = TestReporter()
-        report_type = self.cfg.EXPERIMENT_TYPE
 
         # Get the timeseries and compute durations for the experiment
-        experiment = self.get_experiment_data(exp)
-
-        # Print the basic experiment info
-        eprint("Generating experiment info at {0}".format(time.strftime("%D %H:%M:%S", time.localtime())))
-        self.print_experiment_report(experiment)
-
-        if self.cfg.GENERATE_EXPERIMENT_PLOT:
-            if "end_time" not in experiment or "start_time" not in experiment:
-                return
-
-            eprint("Plotting experiment {0}".format(time.strftime("%D %H:%M:%S", time.localtime())))
-            start, end = experiment["start_time"], experiment["end_time"]
-            plots = get_plots()
-
-            if self.cfg.GENERATE_NODES_PLOTS:
-                for node in self.cfg.NODES_LIST:
-                    test_plots = plots["node"][report_type]
-                    structure = (node, "node")
-                    plot_document(experiment, structure, test_plots, start, end, self.cfg.REPORTED_RESOURCES)
-
-            if self.cfg.GENERATE_APP_PLOTS:
-                for app in self.cfg.APPS_LIST + ["ALL"]:
-                    app_plots = plots["app"][report_type]
-                    structure = (app, "app")
-                    plot_document(experiment, structure, app_plots, start, end, self.cfg.REPORTED_RESOURCES)
-
-            if self.cfg.GENERATE_USER_PLOTS:
-                for user in self.cfg.USERS_LIST:
-                    user_plots = plots["user"][report_type]
-                    plot_user(experiment, user, user_plots, start, end, self.cfg.REPORTED_RESOURCES)
+        eprint("Generating experiment info at {0}".format(nowt()))
+        experiment = generate_duration(experiment)
+        experiment = generate_resources_timeseries(experiment, self.cfg)
+        print_latex_section("Experiment basic information")
+        print_basic_doc_info(experiment)
 
         # Get the experiment tests
         tests = self.timestampingAgent.get_experiment_tests(experiment["experiment_id"], experiment["username"])
@@ -154,9 +80,4 @@ def report_experiment(self, exp):
         processed_tests = list(testRepo.get_test_data(test) for test in tests)
 
         # Print the basic tests info
-        if report_type == "serverless":
-            self.report_tests_serverless(processed_tests)
-        elif report_type == "energy":
-            self.report_tests_energy(processed_tests)
-        else:
-            pass
+        self.report_tests(processed_tests)

src/TestReporter.py

@@ -23,17 +23,15 @@
 
 from __future__ import print_function
 
-import sys
 
 from src.opentsdb import bdwatchdog
 from src.common.config import Config, OpenTSDBConfig, eprint
 from src.latex.latex_output import latex_print, print_latex_stress
 
-from src.barplotting.barplots import plot_tests_resource_usage, plot_tests_times
-from src.lineplotting.lineplots import plot_document
+from src.lineplotting.lineplots import plot_test
 
 from src.common.utils import generate_duration, translate_metric, format_metric, flush_table, \
-    print_basic_doc_info, generate_resources_timeseries, get_plots
+    print_basic_doc_info, generate_resources_timeseries, get_plots_metrics
 
 
 class TestReporter:
@@ -55,19 +53,22 @@ def generate_test_resource_plot(self, tests):
                 return
 
             start, end = test["start_time"], test["end_time"]
-            plots = get_plots()
+            plots = get_plots_metrics()
 
             if self.cfg.GENERATE_NODES_PLOTS:
                 for node in self.cfg.NODES_LIST:
                     test_plots = plots["node"][report_type]
-                    structure = (node, "node")
-                    plot_document(test, structure, test_plots, start, end, self.cfg.REPORTED_RESOURCES)
+                    plot_test(test, node, "node", test_plots, start, end, self.cfg.REPORTED_RESOURCES)
 
             if self.cfg.GENERATE_APP_PLOTS:
                 for app in self.cfg.APPS_LIST + ["ALL"]:
                     app_plots = plots["app"][report_type]
-                    structure = (app, "app")
-                    plot_document(test, structure, app_plots, start, end, self.cfg.REPORTED_RESOURCES)
+                    plot_test(test, app, "app", app_plots, start, end, self.cfg.REPORTED_RESOURCES)
+
+            if self.cfg.GENERATE_USER_PLOTS:
+                for user in self.cfg.USERS_LIST + ["ALL"]:
+                    user_plots = plots["user"][report_type]
+                    plot_test(test, user, "user", user_plots, start, end, self.cfg.REPORTED_RESOURCES)
 
     # PRINT TEST RESOURCE USAGES
     def print_test_resources(self, test, structures_list):
@@ -111,59 +112,6 @@ def flush_rows_with_aggregations(self, rows, headers, table_caption=None):
             final_rows += list(rows[row].values())
         flush_table(final_rows, headers, table_caption)
 
-    # PRINT TEST RESOURCE OVERHEAD
-    def print_tests_resource_overhead_report(self, tests, num_base_experiments=3, print_with_stepping=True):
-        table_caption = "TESTs resource overhead"
-        max_columns = self.cfg.MAX_COLUMNS["print_tests_resource_overhead_report"]
-        resource_tuples = self.cfg.METRICS_FOR_OVERHEAD_REPORT
-
-        overheads, base_values, headers, num_columns, remaining_data = dict(), dict(), ["resource"], 0, False
-
-        for test in tests[:num_base_experiments]:
-            headers.append(test["test_name"])
-            for resource_tuple in resource_tuples:
-                resource, usage_metric = resource_tuple
-                if resource not in overheads:
-                    overheads[resource] = [resource]
-                    base_values[resource] = 0
-
-                if test["resource_aggregates"] != "n/a":
-                    overheads[resource].append("---")
-                    base_values[resource] += test["resource_aggregates"]["ALL"][usage_metric]["SUM"]
-                else:
-                    overheads[resource].append("n/a")
-        for resource in base_values:
-            base_values[resource] = base_values[resource] / num_base_experiments
-
-        num_columns += num_base_experiments
-
-        for test in tests[num_base_experiments:]:
-            headers.append(test["test_name"])
-            for resource_tuple in resource_tuples:
-                resource, usage_metric = resource_tuple
-
-                if resource not in overheads:
-                    overheads[resource] = [resource]
-
-                if test["resource_aggregates"] != "n/a":
-                    overhead = test["resource_aggregates"]["ALL"][usage_metric]["SUM"] / base_values[resource]
-                    resource_overhead = str(int((overhead - 1) * 100)) + "%"
-                else:
-                    resource_overhead = "n/a"
-
-                overheads[resource].append(resource_overhead)
-
-            num_columns += 1
-            remaining_data = True
-            if num_columns >= max_columns:
-                flush_table(overheads.values(), headers, table_caption)
-                table_caption = None
-                overheads, headers, num_columns, remaining_data = dict(), ["resource"], 0, False
-        if remaining_data:
-            flush_table(overheads.values(), headers, table_caption)
-
-        plot_tests_resource_usage(tests)
-
     # PRINT TEST RESOURCE UTILIZATION
     def print_tests_resource_utilization(self, tests):
         max_columns = self.cfg.MAX_COLUMNS["print_tests_resource_utilization_report"]
@@ -296,7 +244,8 @@ def print_tests_resource_usage(self, tests):
         if remaining_data:
             self.flush_rows_with_aggregations(rows, headers, table_caption)
 
-    def print_test_report(self, tests, print_node_info):
+    def print_test_report(self, tests):
+        print_node_info = self.cfg.PRINT_NODE_INFO
         # PRINT BASIC INFO ABOUT THE TEST
         for test in tests:
             print_basic_doc_info(test)
@@ -340,58 +289,3 @@ def print_tests_times(self, tests):
 
         if remaining_data:
             flush_table([durations_seconds, durations_minutes], headers, table_caption)
-
-    def print_summarized_tests_info(self, tests, num_base_experiments, print_with_stepping=True):
-        max_columns = self.cfg.MAX_COLUMNS["print_summarized_tests_info"]
-        table_caption = "TESTs durations and time benchmarking (over the first {0} experiments)".format(
-            num_base_experiments)
-
-        headers, overheads, durations_seconds, durations_minutes, num_columns, remaining_data = \
-            ["time"], ["overhead"], ["seconds"], ["minutes"], 0, False
-        basetime = 0
-
-        if num_base_experiments == 0:
-            basetime = 1
-        else:
-            for test in tests[:num_base_experiments]:
-                headers.append(test["test_name"])
-                basetime += test["duration"]
-                overheads.append("---")
-                durations_seconds.append(test["duration"])
-                durations_minutes.append("{:.2f}".format((test["duration"]) / 60))
-
-                num_columns += 1
-                remaining_data = True
-                if num_columns >= max_columns:
-                    flush_table([durations_seconds, durations_minutes, overheads], headers, table_caption)
-                    table_caption = None
-                    headers, overheads, durations_seconds, durations_minutes, num_columns, remaining_data = \
-                        ["time"], ["overhead"], ["seconds"], ["minutes"], 0, False
-
-            basetime = basetime / num_base_experiments
-
-        for test in tests[num_base_experiments:]:
-            headers.append(test["test_name"])
-            seconds, minutes, overhead = "n/a", "n/a", "n/a"
-            if test["duration"] != "n/a":
-                seconds = test["duration"]
-                minutes = "{:.2f}".format((test["duration"]) / 60)
-                overhead = test["duration"] / basetime
-                overhead = str(int((overhead - 1) * 100)) + "%"
-
-            durations_seconds.append(seconds)
-            durations_minutes.append(minutes)
-            overheads.append(overhead)
-
-            num_columns += 1
-            remaining_data = True
-            if num_columns >= max_columns:
-                flush_table([durations_seconds, durations_minutes, overheads], headers, table_caption)
-                table_caption = None
-                headers, overheads, durations_seconds, durations_minutes, num_columns, remaining_data = \
-                    ["time"], ["overhead"], ["seconds"], ["minutes"], 0, False
-
-        if remaining_data:
-            flush_table([durations_seconds, durations_minutes, overheads], headers, table_caption)
-
-        plot_tests_times(tests)