Introduce separate timeout column

s64da_benchmark_toolkit/reporting.py

@@ -1,6 +1,7 @@
 
 import logging
 import os
+import time
 
 from csv import writer as csv_writer
 from datetime import datetime
@@ -22,21 +23,36 @@
 class QueryMetric:
     dataframe_columns = (
         'stream_id', 'query_id', 'timestamp_start', 'timestamp_stop',
-        'runtime', 'status')
+        'runtime', 'status', 'timeout')
 
     def __init__(self, *, stream_id, query_id, timestamp_start, timestamp_stop,
-                 status, result, plan):
+                 status, result, plan, timeout):
         self.stream_id = stream_id
         self.query_id = query_id
         self.timestamp_start = datetime.fromtimestamp(timestamp_start)
         self.timestamp_stop = datetime.fromtimestamp(timestamp_stop)
         self.status = status
         self.result = result
         self.plan = plan
+        self.timeout = timeout
 
     def make_file_name(self, extension):
         return f'{self.stream_id}_{self.query_id}.{extension}'
 
+    @classmethod
+    def make_ignored(cls, stream_id, query_id, timeout):
+        timestamp = time.time()
+        return cls(
+            stream_id=stream_id,
+            query_id=query_id,
+            timestamp_start=timestamp,
+            timestamp_stop=timestamp,
+            status='IGNORED',
+            result=None,
+            plan=None,
+            timeout=timeout
+        )
+
     @property
     def dataframe(self):
         runtime = (self.timestamp_stop - self.timestamp_start).total_seconds()

s64da_benchmark_toolkit/streams.py

@@ -132,26 +132,25 @@ def _run_query(self, stream_id, query_id):
     def _run_stream(self, reporting_queue, stream_id):
         sequence = self.get_stream_sequence(stream_id)
         num_queries = len(sequence)
+        ignored_queries = self.config.get('ignore', [])
+        timeout = Streams.parse_timeout(self.config.get('timeout', 0))
+
         for idx, query_id in enumerate(sequence):
             num_query = idx + 1
             pretext = f'{num_query:2}/{num_queries:2}: query {query_id:2} of stream {stream_id:2}'
 
-            if query_id in self.config.get('ignore', []):
+            if query_id in ignored_queries:
                 LOG.info(f'ignoring {pretext}.')
-                reporting_queue.put(QueryMetric(
-                    stream_id=stream_id,
-                    query_id=query_id,
-                    timestamp_start=time.time(),
-                    timestamp_stop=time.time() + Streams.parse_timeout(self.config.get('timeout', 0)),
-                    status="IGNORED",
-                    result=None,
-                    plan=None
-                ))
+                reporting_queue.put(
+                    QueryMetric.make_ignored(stream_id, query_id, timeout))
+
             else:
                 LOG.info(f'running  {pretext}.')
                 timing, query_result, plan = self._run_query(stream_id, query_id)
 
                 runtime = timing.stop - timing.start
+                query_status = timing.status.name
+
                 LOG.info(f'finished {pretext}: {runtime:.2f}s {timing.status.name}')
 
                 reporting_queue.put(QueryMetric(
@@ -161,7 +160,8 @@ def _run_stream(self, reporting_queue, stream_id):
                     timestamp_stop=timing.stop,
                     status=timing.status.name,
                     result=query_result,
-                    plan=plan
+                    plan=plan,
+                    timeout=timeout
                 ))
 
     @staticmethod