telemetry: linux telemetry with perf-stat

[csit.git] / resources / tools / telemetry / bundle_bpf.py

diff --git a/resources/tools/telemetry/bundle_bpf.py b/resources/tools/telemetry/bundle_bpf.py
index bf54db0..58cfd5d 100644 (file)
--- a/resources/tools/telemetry/bundle_bpf.py
+++ b/resources/tools/telemetry/bundle_bpf.py
@@ -52,12 +52,15 @@ class BundleBpf:
 
         self.obj = BPF(text=self.code)
 
-    def attach(self, duration):
+
+    def attach(self, sample_period):
         """
         Attach events to BPF.
 
-        :param duration: Trial duration.
-        :type duration: int
+        :param sample_period:  A "sampling" event is one that generates
+        an overflow notification every N events, where N is given by
+        sample_period.
+        :type sample_period: int
         """
         try:
             for event in self.events:
@@ -65,15 +68,16 @@ class BundleBpf:
                     ev_type=event[u"type"],
                     ev_config=event[u"name"],
                     fn_name=event[u"target"],
-                    sample_period=duration
+                    sample_period=sample_period
                 )
         except AttributeError:
-            getLogger("console_stderr").error(u"Could not attach BPF events!")
+            getLogger("console_stderr").error(f"Could not attach BPF event: "
+                                              f"{event[u'name']}")
             sys.exit(Constants.err_linux_attach)
 
     def detach(self):
         """
-        Dettach events from BPF.
+        Detach events from BPF.
         """
         try:
             for event in self.events:
@@ -98,6 +102,9 @@ class BundleBpf:
 
         for _, metric_list in self.metrics.items():
             for metric in metric_list:
+                if table_name != metric[u"name"]:
+                    table_name = metric[u"name"]
+                    text += f"{table_name}\n"
                 for (key, val) in self.obj.get_table(metric[u"name"]).items():
                     item = dict()
                     labels = dict()
@@ -111,7 +118,7 @@ class BundleBpf:
                     if item[u"labels"][u"name"] == u"python3":
                         continue
                     if len(str(item[u'labels'][u'cpu'])) > max_len["cpu"]:
-                        max_len["cpu"]= len(str(item[u'labels'][u'cpu']))
+                        max_len["cpu"] = len(str(item[u'labels'][u'cpu']))
                     if len(str(item[u'labels'][u'pid'])) > max_len[u"pid"]:
                         max_len[u"pid"] = len(str(item[u'labels'][u'pid']))
                     if len(str(item[u'labels'][u'name'])) > max_len[u"name"]:
@@ -125,23 +132,23 @@ class BundleBpf:
         item_list = sorted(item_list, key=lambda x: x['labels']['cpu'])
         item_list = sorted(item_list, key=lambda x: x['name'])
 
-        for it in item_list:
-            if table_name != it[u"name"]:
-                table_name = it[u"name"]
+        for itl in item_list:
+            if table_name != itl[u"name"]:
+                table_name = itl[u"name"]
                 text += f"\n==={table_name}===\n" \
                         f"cpu {u' ' * (max_len[u'cpu'] - 3)} " \
                         f"pid {u' ' * (max_len[u'pid'] - 3)} " \
                         f"name {u' ' * (max_len[u'name'] - 4)} " \
                         f"value {u' ' * (max_len[u'value'] - 5)}\n"
             text += (
-                f"""{str(it[u'labels'][u'cpu']) + u' ' * 
-                     (max_len[u"cpu"] - len(str(it[u'labels'][u'cpu'])))}  """
-                f"""{str(it[u'labels'][u'pid']) + u' ' * 
-                     (max_len[u"pid"] - len(str(it[u'labels'][u'pid'])))}  """
-                f"""{str(it[u'labels'][u'name']) + u' ' * 
-                     (max_len[u"name"] - len(str(it[u'labels'][u'name'])))}  """
-                f"""{str(it[u'value']) + u' ' * 
-                     (max_len[u"value"] - len(str(it[u'value'])))}\n""")
+                f"""{str(itl[u'labels'][u'cpu']) + u' ' *
+                     (max_len[u"cpu"] - len(str(itl[u'labels'][u'cpu'])))} """
+                f"""{str(itl[u'labels'][u'pid']) + u' ' *
+                     (max_len[u"pid"] - len(str(itl[u'labels'][u'pid'])))} """
+                f"""{str(itl[u'labels'][u'name']) + u' ' *
+                     (max_len[u"name"] - len(str(itl[u'labels'][u'name'])))} """
+                f"""{str(itl[u'value']) + u' ' *
+                     (max_len[u"value"] - len(str(itl[u'value'])))}\n""")
         getLogger(u"console_stdout").info(text)
 
     def process_data(self):