Provide a human-readable output format

Author: Quincunx271

util/analyze/__init__.py

@@ -1,5 +1,5 @@
 from ._types import Logs, Benchmark, Block
 from ._main import parse_args
 from .imports import import_cpu2006, import_plaidml, import_shoc, import_utils
-from . import utils
+from . import utils, ioutils
 from .utils import foreach_bench

util/analyze/_main.py

@@ -75,14 +75,14 @@ def parse_args(parser: argparse.ArgumentParser, *names, args=None):
         'plaidml': import_plaidml.parse,
         'shoc': import_shoc.parse,
     }
-    parser = FILE_PARSERS[args.benchsuite]
+    fileparser = FILE_PARSERS[args.benchsuite]
     blk_filter = block_filter(args.keep_blocks_if) if args.keep_blocks_if is not True else True
 
     args_dict = vars(args)
 
     def parse_input(x):
         if isinstance(x, str):
-            result = parser(x)
+            result = fileparser(x)
             if blk_filter is not True:
                 result = result.keep_blocks_if(blk_filter)
             return result
@@ -94,4 +94,8 @@ def parse_input(x):
     for name in names:
         args_dict[name] = parse_input(args_dict[name])
 
+    if hasattr(parser, '__analyze_post_process_parse_args__'):
+        for argname, postprocess in getattr(parser, '__analyze_post_process_parse_args__').items():
+            args_dict[argname] = postprocess(args_dict[argname])
+
     return args

util/analyze/ioutils.py

@@ -0,0 +1,90 @@
+import argparse
+import csv
+
+
+class _Writer:
+    def __init__(self, add_bench):
+        self.__add_bench = add_bench
+
+    def __addinfo(self, bench, data):
+        if self.__add_bench:
+            return {'Benchmark': bench, **data}
+        return data
+
+    def benchdata(self, bench, data):
+        self._benchdata(self.__addinfo(bench, data))
+
+    def finish(self):
+        self._finish()
+
+
+class _CSVWriter(_Writer):
+    def __init__(self, f, data: dict, fieldnames=None):
+        add_bench = fieldnames is None or 'Benchmark' in fieldnames and 'Benchmark' not in data
+        super().__init__(add_bench)
+
+        if fieldnames is None:
+            fieldnames = ['Benchmark', *data['Total'].keys()]
+
+        self.__csv_writer = csv.DictWriter(f, fieldnames=fieldnames)
+        self.__csv_writer.writeheader()
+
+    def _benchdata(self, data):
+        self.__csv_writer.writerow(data)
+
+    def _finish(self):
+        pass
+
+
+class _HumanWriter(_Writer):
+    def __init__(self, f, data: dict, fieldnames=None):
+        add_bench = fieldnames is None or 'Benchmark' in fieldnames and 'Benchmark' not in data
+        super().__init__(add_bench)
+
+        if fieldnames is None:
+            fieldnames = ['Benchmark', *data['Total'].keys()]
+
+        self.__f = f
+        self.__fieldnames = fieldnames
+        self.__data = {name: [f'{name}:'] for name in fieldnames}
+        self.__num_entries = 1
+
+    def _benchdata(self, data):
+        self.__num_entries += 1
+        for k, v in data.items():
+            self.__data[k].append(str(v))
+
+    def _finish(self):
+        col_max = [max(len(self.__data[field][index]) for field in self.__fieldnames)
+                   for index in range(self.__num_entries)]
+        for field in self.__fieldnames:
+            for index, val in enumerate(self.__data[field]):
+                self.__f.write(f'{val:{col_max[index]+1}}')
+            self.__f.write('\n')
+
+
+def _write_data(writer: _Writer, data: dict):
+    for bench, bench_data in data.items():
+        writer.benchdata(bench, bench_data)
+    writer.finish()
+
+
+def write_csv(f, data: dict, *, fieldnames=None):
+    _write_data(_CSVWriter(f, data, fieldnames), data)
+
+
+def write_human(f, data: dict, *, fieldnames=None):
+    _write_data(_HumanWriter(f, data, fieldnames), data)
+
+
+def add_output_format_arg(parser: argparse.ArgumentParser, default='csv'):
+    parser.add_argument('--format', default=default, choices=('csv', 'human'),
+                        help=f'Which format style to use (default: {default})')
+    FORMAT_OPTIONS = {
+        'csv': write_csv,
+        'human': write_human,
+    }
+
+    if not hasattr(parser, '__analyze_post_process_parse_args__'):
+        setattr(parser, '__analyze_post_process_parse_args__', {})
+    getattr(parser, '__analyze_post_process_parse_args__')['format'] = FORMAT_OPTIONS.__getitem__

util/analyze/lib/block_stats.py

@@ -2,6 +2,7 @@
 
 from typing import *
 import argparse
+from analyze import ioutils
 import analyze
 from analyze import Block, Logs, utils
 
@@ -82,12 +83,9 @@ def compute_block_stats(logs: Logs):
     parser = argparse.ArgumentParser(
         description='Computes the block stats for the logs')
     parser.add_argument('logs', help='The logs to analyze')
+    ioutils.add_output_format_arg(parser)
     args = analyze.parse_args(parser, 'logs')
 
     results = utils.foreach_bench(compute_block_stats, args.logs)
 
-    writer = csv.DictWriter(sys.stdout,
-                            fieldnames=['Benchmark'] + list(results['Total'].keys()))
-    writer.writeheader()
-    for bench, bench_res in results.items():
-        writer.writerow({'Benchmark': bench, **bench_res})
+    args.format(result)

util/gt_analysis/gt_cmp.py

@@ -4,7 +4,7 @@
 from typing import Tuple
 
 import analyze
-from analyze import Block, Logs, utils
+from analyze import Block, Logs, utils, ioutils
 from analyze.lib import block_stats, compile_times
 
 sched_time = compile_times.sched_time
@@ -153,6 +153,7 @@ def compute_stats(nogt: Logs, gt: Logs, *, pass_num: int, total_compile_time_sec
     parser.add_argument('nogt')
     parser.add_argument('gt')
     parser.add_argument('--pass-num', type=int, default=None, help='Which pass to analyze (default: all passes)')
+    ioutils.add_output_format_arg(parser)
     args = analyze.parse_args(parser, 'nogt', 'gt')
 
     results = utils.foreach_bench(
@@ -161,8 +162,4 @@ def compute_stats(nogt: Logs, gt: Logs, *, pass_num: int, total_compile_time_sec
         total_compile_time_seconds=compile_times.total_compile_time_seconds_f(args.benchsuite),
     )
 
-    writer = csv.DictWriter(sys.stdout,
-                            fieldnames=['Benchmark'] + list(results['Total'].keys()))
-    writer.writeheader()
-    for bench, bench_res in results.items():
-        writer.writerow({'Benchmark': bench, **bench_res})
+    args.format(sys.stdout, results)