File: TimeFileMaker.py

package info (click to toggle)
coq 8.12.0-3
  • links: PTS, VCS
  • area: main
  • in suites: bullseye
  • size: 36,468 kB
  • sloc: ml: 210,451; sh: 3,345; python: 3,008; ansic: 2,482; makefile: 793; lisp: 224; javascript: 63; xml: 24; sed: 2
file content (480 lines) | stat: -rw-r--r-- 26,551 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
from __future__ import with_statement
from __future__ import division
from __future__ import unicode_literals
from __future__ import print_function
import sys
import re
import argparse
from io import open

# This script parses the output of `make TIMED=1` into a dictionary
# mapping names of compiled files to the number of minutes and seconds
# that they took to compile.

STRIP_REG = re.compile('^(coq/|contrib/|)(?:theories/|src/)?')
STRIP_REP = r'\1'
INFINITY  = '\u221e'

TIME_KEY = 'time'
MEM_KEY = 'mem'

def nonnegative(arg):
    v = int(arg)
    if v < 0: raise argparse.ArgumentTypeError("%s is an invalid non-negative int value" % arg)
    return v

def add_sort_by(parser):
    return parser.add_argument(
        '--sort-by', type=str, dest='sort_by', choices=('auto', 'absolute', 'diff'),
        default='auto',
        help=('How to sort the table entries.\n' +
              'The "auto" method sorts by absolute time differences ' +
              'rounded towards zero to a whole-number of seconds, then ' +
              'by times in the "after" column, and finally ' +
              'lexicographically by file name. This will put the ' +
              'biggest changes in either direction first, and will ' +
              'prefer sorting by build-time over subsecond changes in ' +
              'build time (which are frequently noise); lexicographic ' +
              'sorting forces an order on files which take effectively ' +
              'no time to compile.\n' +
              'The "absolute" method sorts by the total time taken.\n' +
              'The "diff" method sorts by the signed difference in time.'))

def add_sort_by_mem(parser):
    return parser.add_argument(
        '--sort-by-mem', action='store_true', dest='sort_by_mem',
        help=('Sort the table entries by memory rather than time.'))

def add_fuzz(parser):
    return parser.add_argument(
        '--fuzz', dest='fuzz', metavar='N', type=nonnegative, default=0,
        help=('By default, two lines are only considered the same if ' +
              'the character offsets and initial code strings match.  '
              'This option relaxes this constraint by allowing the ' +
              'character offsets to differ by up to N characters, as long ' +
              'as the total number of characters and initial code strings ' +
              'continue to match.  This is useful when there are small changes ' +
              'to a file, and you want to match later lines that have not ' +
              'changed even though the character offsets have changed.'))

def add_real(parser, single_timing=False):
    return parser.add_argument(
        '--real', action='store_true',
        help=(r'''Use real times rather than user times.

''' + ('''By default, the input is expected to contain lines in the format:
FILE_NAME (...user: NUMBER_IN_SECONDS...mem: NUMBER ko...)
If --real is passed, then the lines are instead expected in the format:
FILE_NAME (...real: NUMBER_IN_SECONDS...mem: NUMBER ko...)''' if not single_timing else
'''The input is expected to contain lines in the format:
Chars START - END COMMAND NUMBER secs (NUMBERu...)''')))

def add_user(parser, single_timing=False):
    return parser.add_argument(
        '--user', dest='real', action='store_false',
        help=(r'''Use user times rather than real times.

''' + ('''By default, the input is expected to contain lines in the format:
FILE_NAME (...real: NUMBER_IN_SECONDS...mem: NUMBER ko...)
If --user is passed, then the lines are instead expected in the format:
FILE_NAME (...user: NUMBER_IN_SECONDS...mem: NUMBER ko...)''' if not single_timing else
'''The input is expected to contain lines in the format:
Chars START - END COMMAND NUMBER secs (NUMBERu...)''')))

def add_include_mem(parser):
    return parser.add_argument(
        '--no-include-mem', dest='include_mem', default=True, action='store_false',
        help=(r'''Don't include memory in the table.'''))

# N.B. We need to include default=None for nargs='*', c.f., https://bugs.python.org/issue28609#msg280180
def add_file_name_gen(parser, prefix='', descr='file containing the build log', stddir='in', defaults=None, **kwargs):
    extra = ('' if defaults is None else ' (defaults to %s if no argument is passed)' % defaults)
    return parser.add_argument(
        prefix + 'FILE_NAME', type=str,
        help=('The name of the %s (use "-" for std%s)%s.' % (descr, stddir, extra)),
        **kwargs)

def add_file_name(parser): return add_file_name_gen(parser)
def add_after_file_name(parser): return add_file_name_gen(parser, 'AFTER_', 'file containing the "after" build log')
def add_before_file_name(parser): return add_file_name_gen(parser, 'BEFORE_', 'file containing the "before" build log')
def add_output_file_name(parser): return add_file_name_gen(parser, 'OUTPUT_', 'file to write the output table to', stddir='out', defaults='-', nargs='*', default=None)


def reformat_time_string(time):
    seconds, milliseconds = time.split('.')
    seconds = int(seconds)
    minutes, seconds = divmod(seconds, 60)
    return '%dm%02d.%ss' % (minutes, seconds, milliseconds)

def get_file_lines(file_name):
    if file_name == '-':
        if hasattr(sys.stdin, 'buffer'):
            lines = sys.stdin.buffer.readlines()
        else:
            lines = sys.stdin.readlines()
    else:
        with open(file_name, 'rb') as f:
            lines = f.readlines()
    for line in lines:
        try:
            # Since we read the files in binary mode, we have to
            # normalize Windows line endings from \r\n to \n
            yield line.decode('utf-8').replace('\r\n', '\n')
        except UnicodeDecodeError: # invalid utf-8
            pass

def get_file(file_name):
    return ''.join(get_file_lines(file_name))

def merge_dicts(d1, d2):
    if d2 is None: return d1
    if d1 is None: return d2
    assert(isinstance(d1, dict))
    assert(isinstance(d2, dict))
    ret = {}
    for k in set(list(d1.keys()) + list(d2.keys())):
        ret[k] = merge_dicts(d1.get(k), d2.get(k))
    return ret

def get_mems_of_lines(lines):
    reg = re.compile(r'^([^\s]+) \([^\)]*?mem: ([0-9]+) ko[^\)]*?\)\s*$', re.MULTILINE)
    mems = reg.findall(lines)
    if all(STRIP_REG.search(name.strip()) for name, mem in mems):
        mems = tuple((STRIP_REG.sub(STRIP_REP, name.strip()), mem) for name, mem in mems)
    return dict((name, {MEM_KEY:int(mem)}) for name, mem in mems)

def get_times_of_lines(lines, use_real=False):
    reg_user = re.compile(r'^([^\s]+) \([^\)]*?user: ([0-9\.]+)[^\)]*?\)\s*$', re.MULTILINE)
    reg_real = re.compile(r'^([^\s]+) \([^\)]*?real: ([0-9\.]+)[^\)]*?\)\s*$', re.MULTILINE)
    reg = reg_real if use_real else reg_user
    times = reg.findall(lines)
    if all(time in ('0.00', '0.01') for name, time in times):
        reg = reg_real
        times = reg.findall(lines)
    if all(STRIP_REG.search(name.strip()) for name, time in times):
        times = tuple((STRIP_REG.sub(STRIP_REP, name.strip()), time) for name, time in times)
    return dict((name, {TIME_KEY:reformat_time_string(time)}) for name, time in times)

def get_times_and_mems(file_name, use_real=False, include_mem=True):
    # we only get the file once, in case it is a stream like stdin
    lines = get_file(file_name)
    return merge_dicts(get_times_of_lines(lines, use_real=use_real),
                       (get_mems_of_lines(lines) if include_mem else None))

def get_mems(file_name):
    '''
    Reads the contents of file_name, which should be the output of
    'make TIMED=1', and parses it to construct a dict mapping file
    names to peak memory usage, as integers.  Removes common prefixes
    using STRIP_REG and STRIP_REP.
    '''
    return get_mems_of_lines(get_file(file_name))

def get_times(file_name, use_real=False):
    '''
    Reads the contents of file_name, which should be the output of
    'make TIMED=1', and parses it to construct a dict mapping file
    names to compile durations, as strings.  Removes common prefixes
    using STRIP_REG and STRIP_REP.
    '''
    return get_times_of_lines(get_file(file_name))

def get_single_file_times(file_name, use_real=False):
    '''
    Reads the contents of file_name, which should be the output of
    'coqc -time', and parses it to construct a dict mapping lines to
    to compile durations, as strings.
    '''
    lines = get_file(file_name)
    reg = re.compile(r'^Chars ([0-9]+) - ([0-9]+) ([^ ]+) ([0-9\.]+) secs \(([0-9\.]+)u(.*)\)$', re.MULTILINE)
    times = reg.findall(lines)
    if len(times) == 0: return dict()
    longest = max(max((len(start), len(stop))) for start, stop, name, real, user, extra in times)
    FORMAT = 'Chars %%0%dd - %%0%dd %%s' % (longest, longest)
    return dict((FORMAT % (int(start), int(stop), name), {TIME_KEY:reformat_time_string(real if use_real else user)}) for start, stop, name, real, user, extra in times)

def fuzz_merge(l1, l2, fuzz):
    '''Takes two iterables of ((start, end, code), times) and a fuzz
    parameter, and yields a single iterable of ((start, stop, code),
    times1, times2)

    We only give both left and right if (a) the codes are the same,
    (b) the number of characters (stop - start) is the same, and (c)
    the difference between left and right code locations is <= fuzz.

    We keep a current guess at the overall offset, and prefer drawing
    from whichever list is earliest after correcting for current
    offset.

    '''
    assert(fuzz >= 0)
    cur_fuzz = 0
    l1 = list(l1)
    l2 = list(l2)
    cur1, cur2 = None, None
    while (len(l1) > 0 or cur1 is not None) and (len(l2) > 0 or cur2 is not None):
        if cur1 is None: cur1 = l1.pop(0)
        if cur2 is None: cur2 = l2.pop(0)
        ((s1, e1, c1), t1), ((s2, e2, c2), t2) = cur1, cur2
        assert(t1 is not None)
        assert(t2 is not None)
        s2_adjusted, e2_adjusted = s2 + cur_fuzz, e2 + cur_fuzz
        if cur1[0] == cur2[0]:
            yield (cur1, cur2)
            cur1, cur2 = None, None
            cur_fuzz = 0
        elif c1 == c2 and e1-s1 == e2-s2 and abs(s1 - s2) <= fuzz:
            yield (((s1, e1, c1), t1), ((s2, e2, c2), t2))
            cur1, cur2 = None, None
            cur_fuzz = s1 - s2
        elif s1 < s2_adjusted or (s1 == s2_adjusted and e1 <= e2):
            yield (((s1, e1, c1), t1), ((s1 - cur_fuzz, e1 - cur_fuzz, c1), None))
            cur1 = None
        else:
            yield (((s2 + cur_fuzz, e2 + cur_fuzz, c2), None), ((s2, e2, c2), t2))
            cur2 = None
    if len(l1) > 0:
        for i in l1: yield (i, (i[0], None))
    elif len(l2) > 0:
        for i in l2: yield ((i[0], None), i)

def adjust_fuzz(left_dict, right_dict, fuzz):
    reg = re.compile(r'Chars ([0-9]+) - ([0-9]+) (.*)$')
    left_dict_list = sorted(((int(s), int(e), c), v) for ((s, e, c), v) in ((reg.match(k).groups(), v) for k, v in left_dict.items()))
    right_dict_list = sorted(((int(s), int(e), c), v) for ((s, e, c), v) in ((reg.match(k).groups(), v) for k, v in right_dict.items()))
    merged = list(fuzz_merge(left_dict_list, right_dict_list, fuzz))
    if len(merged) == 0:
        # assert that both left and right dicts are empty
        assert(not left_dict)
        assert(not right_dict)
        return left_dict, right_dict
    longest = max(max((len(str(start1)), len(str(stop1)), len(str(start2)), len(str(stop2)))) for ((start1, stop1, code1), t1), ((start2, stop2, code2), t2) in merged)
    FORMAT1 = 'Chars %%0%dd - %%0%dd %%s' % (longest, longest)
    FORMAT2 = 'Chars %%0%dd-%%0%dd ~ %%0%dd-%%0%dd %%s' % (longest, longest, longest, longest)
    if fuzz == 0:
        left_dict = dict((FORMAT1 % k, t1) for (k, t1), _ in merged if t1 is not None)
        right_dict = dict((FORMAT1 % k, t2) for _, (k, t2) in merged if t2 is not None)
    else:
        left_dict = dict((FORMAT2 % (s1, e1, s2, e2, c1), t1) for ((s1, e1, c1), t1), ((s2, e2, c2), t2) in merged if t1 is not None)
        right_dict = dict((FORMAT2 % (s1, e1, s2, e2, c1), t2) for ((s1, e1, c1), t1), ((s2, e2, c2), t2) in merged if t2 is not None)
    return left_dict, right_dict

def fix_sign_for_sorting(num, descending=True):
    return -num if descending else num

def make_sorting_key(stats_dict, descending=True, sort_by_mem=False):
    if sort_by_mem:
        def get_key(name):
            if MEM_KEY not in stats_dict[name].keys():
                print('WARNING: %s has no mem key: %s' % (name, repr(stats_dict[name])), file=sys.stderr)
            mem = stats_dict[name].get(MEM_KEY, '0')
            return (fix_sign_for_sorting(int(mem), descending=descending),
                    name)
    else:
        def get_key(name):
            if TIME_KEY not in stats_dict[name].keys():
                print('WARNING: %s has no time key: %s' % (name, repr(stats_dict[name])), file=sys.stderr)
            minutes, seconds = stats_dict[name].get(TIME_KEY, '0m00s').replace('s', '').split('m')
            return (fix_sign_for_sorting(int(minutes), descending=descending),
                    fix_sign_for_sorting(float(seconds), descending=descending),
                    name)
    return get_key

def get_sorted_file_list_from_stats_dict(stats_dict, descending=True, sort_by_mem=False):
    '''
    Takes the output dict of get_times and returns the list of keys,
    sorted by duration.
    '''
    return sorted(stats_dict.keys(), key=make_sorting_key(stats_dict, descending=descending, sort_by_mem=sort_by_mem))

def to_seconds(time):
    '''
    Converts a string time into a number of seconds.
    '''
    minutes, seconds = time.replace('s', '').split('m')
    sign = -1 if time[0] == '-' else 1
    return sign * (abs(int(minutes)) * 60 + float(seconds))

def from_seconds(seconds, signed=False):
    '''
    Converts a number of seconds into a string time.
    '''
    sign = ('-' if seconds < 0 else '+') if signed else ''
    seconds = abs(seconds)
    minutes = int(seconds) // 60
    seconds -= minutes * 60
    full_seconds = int(seconds)
    partial_seconds = int(100 * (seconds - full_seconds))
    return sign + '%dm%02d.%02ds' % (minutes, full_seconds, partial_seconds)

def sum_times(times, signed=False):
    '''
    Takes the values of an output from get_times, parses the time
    strings, and returns their sum, in the same string format.
    '''
    # sort the times before summing because floating point addition is not associative
    return from_seconds(sum(sorted(map(to_seconds, times))), signed=signed)

def format_percentage(num, signed=True):
    sign = ('-' if num < 0 else '+') if signed else ''
    num = abs(num)
    whole_part = int(num * 100)
    frac_part = int(100 * (num * 100 - whole_part))
    return sign + '%d.%02d%%' % (whole_part, frac_part)

def make_diff_table_string(left_dict, right_dict,
                           sort_by='auto',
                           descending=True, sort_by_mem=False,
                           left_tag='After', tag='File Name', right_tag='Before', with_percent=True,
                           left_mem_tag='Peak Mem', right_mem_tag='Peak Mem',
                           include_mem=False,
                           change_tag='Change', percent_change_tag='% Change',
                           change_mem_tag='Change (mem)', percent_change_mem_tag='% Change (mem)',
                           mem_fmt='%d ko'):
    # We first get the names of all of the compiled files: all files
    # that were compiled either before or after.
    all_names_dict = dict()
    all_names_dict.update(right_dict)
    all_names_dict.update(left_dict) # do the left (after) last, so that we give precedence to those ones
    if len(all_names_dict.keys()) == 0: return 'No timing data'
    get_time = (lambda d, name: to_seconds(d.get(name, {}).get(TIME_KEY, '0m0.0s')))
    prediff_times = tuple((name, get_time(left_dict, name), get_time(right_dict, name))
                          for name in all_names_dict.keys())
    diff_times_dict = dict((name, from_seconds(lseconds - rseconds, signed=True))
                           for name, lseconds, rseconds in prediff_times)
    percent_diff_times_dict = dict((name, ((format_percentage((lseconds - rseconds) / rseconds))
                                           if rseconds != 0 else (INFINITY if lseconds > 0 else 'N/A')))
                                   for name, lseconds, rseconds in prediff_times)

    get_mem = (lambda d, name: d.get(name, {}).get(MEM_KEY, 0))
    prediff_mems = tuple((name, get_mem(left_dict, name), get_mem(right_dict, name))
                         for name in all_names_dict.keys())
    diff_mems_dict = dict((name, lmem - rmem) for name, lmem, rmem in prediff_mems)
    percent_diff_mems_dict = dict((name, ((format_percentage((lmem - rmem) / float(rmem)))
                                          if rmem != 0 else (INFINITY if lmem > 0 else 'N/A')))
                                  for name, lmem, rmem in prediff_mems)

    # update to sort by approximate difference, first
    if sort_by_mem:
        get_prekey = (lambda name: diff_mems_dict[name])
    else:
        get_prekey = (lambda name: to_seconds(diff_times_dict[name]))
    get_key_abs = make_sorting_key(all_names_dict, descending=descending, sort_by_mem=sort_by_mem)
    get_key_diff_float = (lambda name: fix_sign_for_sorting(get_prekey(name), descending=descending))
    get_key_diff_absint = (lambda name: fix_sign_for_sorting(int(abs(get_prekey(name))), descending=descending))
    get_key_with_name = (lambda get_key: lambda name: (get_key(name), name))
    if sort_by == 'absolute':
        get_key = get_key_with_name(get_key_abs)
    elif sort_by == 'diff':
        get_key = get_key_with_name(get_key_diff_float)
    else: # sort_by == 'auto'
        get_key = get_key_with_name((lambda name: (get_key_diff_absint(name), get_key_abs(name))))
    names = sorted(all_names_dict.keys(), key=get_key)
    #names = get_sorted_file_list_from_stats_dict(all_names_dict, descending=descending)
    # set the widths of each of the columns by the longest thing to go in that column
    left_sum = sum_times(v[TIME_KEY] for v in left_dict.values() if TIME_KEY in v.keys())
    right_sum = sum_times(v[TIME_KEY] for v in right_dict.values() if TIME_KEY in v.keys())
    left_sum_float = sum(sorted(to_seconds(v[TIME_KEY]) for v in left_dict.values() if TIME_KEY in v.keys()))
    right_sum_float = sum(sorted(to_seconds(v[TIME_KEY]) for v in right_dict.values() if TIME_KEY in v.keys()))
    diff_sum = from_seconds(left_sum_float - right_sum_float, signed=True)
    percent_diff_sum = (format_percentage((left_sum_float - right_sum_float) / right_sum_float)
                        if right_sum_float > 0 else 'N/A')

    left_width = max(max(map(len, ['N/A', left_tag] + [v[TIME_KEY] for v in left_dict.values() if TIME_KEY in v.keys()])), len(left_sum))
    right_width = max(max(map(len, ['N/A', right_tag] + [v[TIME_KEY] for v in right_dict.values() if TIME_KEY in v.keys()])), len(right_sum))
    far_right_width = max(max(map(len, ['N/A', change_tag] + list(diff_times_dict.values()))), len(diff_sum))
    far_far_right_width = max(max(map(len, ['N/A', percent_change_tag] + list(percent_diff_times_dict.values()))), len(percent_diff_sum))
    total_string = 'Total' if not include_mem else 'Total Time / Peak Mem'
    middle_width = max(map(len, names + [tag, total_string]))

    left_peak = max([0] + [v.get(MEM_KEY, 0) for v in left_dict.values()])
    right_peak = max([0] + [v.get(MEM_KEY, 0) for v in right_dict.values()])
    diff_peak = left_peak - right_peak
    percent_diff_peak = (format_percentage((left_peak - right_peak) / float(right_peak))
                         if right_peak != 0 else (INFINITY if left_peak > 0 else 'N/A'))

    left_mem_width = max(max(map(len, ['N/A', left_mem_tag] + [mem_fmt % v.get(MEM_KEY, 0) for v in left_dict.values()])), len(mem_fmt % left_peak))
    right_mem_width = max(max(map(len, ['N/A', right_mem_tag] + [mem_fmt % v.get(MEM_KEY, 0) for v in right_dict.values()])), len(mem_fmt % right_peak))
    far_right_mem_width = max(max(map(len, ['N/A', change_mem_tag] + [mem_fmt % v for v in diff_mems_dict.values()])), len(mem_fmt % diff_peak))
    far_far_right_mem_width = max(max(map(len, ['N/A', percent_change_mem_tag] + list(percent_diff_mems_dict.values()))), len(percent_diff_peak))

    if include_mem:
        format_string = ("%%(left)%ds | %%(left_mem)%ds | %%(middle)-%ds | %%(right)%ds | %%(right_mem)%ds || %%(far_right)%ds || %%(far_right_mem)%ds"
                         % (left_width, left_mem_width, middle_width, right_width, right_mem_width, far_right_width, far_right_mem_width))
    else:
        format_string = ("%%(left)%ds | %%(middle)-%ds | %%(right)%ds || %%(far_right)%ds"
                         % (left_width, middle_width, right_width, far_right_width))

    if with_percent:
        format_string += " | %%(far_far_right)%ds" % far_far_right_width
        if include_mem:
            format_string += " | %%(far_far_right_mem)%ds" % far_far_right_mem_width

    header = format_string % {'left': left_tag, 'left_mem': left_mem_tag,
                              'middle': tag,
                              'right': right_tag, 'right_mem': right_mem_tag,
                              'far_right': change_tag, 'far_right_mem': change_mem_tag,
                              'far_far_right': percent_change_tag, 'far_far_right_mem': percent_change_mem_tag}
    total = format_string % {'left': left_sum, 'left_mem': mem_fmt % left_peak,
                             'middle': total_string,
                             'right': right_sum, 'right_mem': mem_fmt % right_peak,
                             'far_right': diff_sum, 'far_right_mem': mem_fmt % diff_peak,
                             'far_far_right': percent_diff_sum, 'far_far_right_mem': percent_diff_peak}
    # separator to go between headers and body
    sep = '-' * len(header)
    # the representation of the default value (0), to get replaced by N/A
    left_rep, right_rep, far_right_rep, far_far_right_rep = ("%%%ds | " % left_width) % 'N/A', (" | %%%ds |" % right_width) % 'N/A', ("|| %%%ds" % far_right_width) % 'N/A', ("| %%%ds" % far_far_right_width) % 'N/A'
    left_mem_rep, right_mem_rep, far_right_mem_rep, far_far_right_mem_rep = ("%%%ds | " % left_mem_width) % 'N/A', (" | %%%ds |" % right_mem_width) % 'N/A', ("|| %%%ds" % far_right_mem_width) % 'N/A', ("| %%%ds" % far_far_right_mem_width) % 'N/A'
    get_formatted_mem = (lambda k, v: (mem_fmt % v[k]) if k in v.keys() else 'N/A')
    return '\n'.join([header, sep, total, sep] +
                     [format_string % {'left': left_dict.get(name, {}).get(TIME_KEY, 'N/A'),
                                       'left_mem': get_formatted_mem(MEM_KEY, left_dict.get(name, {})),
                                       'middle': name,
                                       'right': right_dict.get(name, {}).get(TIME_KEY, 'N/A'),
                                       'right_mem': get_formatted_mem(MEM_KEY, right_dict.get(name, {})),
                                       'far_right': diff_times_dict.get(name, 'N/A'),
                                       'far_right_mem': get_formatted_mem(name, diff_mems_dict),
                                       'far_far_right': percent_diff_times_dict.get(name, 'N/A'),
                                       'far_far_right_mem': percent_diff_mems_dict.get(name, 'N/A')}
                      for name in names]).replace(left_rep, 'N/A'.center(len(left_rep) - 3) + ' | ').replace(right_rep, ' | ' + 'N/A'.center(len(right_rep) - 5) + ' |').replace(far_right_rep, '|| ' + 'N/A'.center(len(far_right_rep) - 3)).replace(far_far_right_rep, '| ' + 'N/A'.center(len(far_far_right_rep) - 2)).replace(left_mem_rep, 'N/A'.center(len(left_mem_rep) - 3) + ' | ').replace(right_mem_rep, ' | ' + 'N/A'.center(len(right_mem_rep) - 5) + ' |').replace(far_right_mem_rep, '|| ' + 'N/A'.center(len(far_right_mem_rep) - 3)).replace(far_far_right_mem_rep, '| ' + 'N/A'.center(len(far_far_right_mem_rep) - 2))

def make_table_string(stats_dict,
                      descending=True, sort_by_mem=False,
                      tag="Time", mem_tag="Peak Mem", mem_fmt='%d ko',
                      include_mem=False):
    if len(stats_dict.keys()) == 0: return 'No timing data'
    # We first get the names of all of the compiled files, sorted by
    # duration
    names = get_sorted_file_list_from_stats_dict(stats_dict, descending=descending, sort_by_mem=sort_by_mem)
    # compute the widths of the columns
    times_width = max(len('N/A'), len(tag), max(len(v[TIME_KEY]) for v in stats_dict.values() if TIME_KEY in v.keys()), len(sum_times(v[TIME_KEY] for v in stats_dict.values() if TIME_KEY in v.keys())))
    mems_width = max(len('N/A'), len(mem_tag), max(len(mem_fmt % v.get(MEM_KEY, 0)) for v in stats_dict.values()), len(mem_fmt % (max(v.get(MEM_KEY, 0) for v in stats_dict.values()))))
    total_string = 'Total' if not include_mem else 'Total Time / Peak Mem'
    names_width = max(map(len, names + ["File Name", total_string]))
    if include_mem:
        format_string = "%%(time)%ds | %%(mem)%ds | %%(name)-%ds" % (times_width, mems_width, names_width)
    else:
        format_string = "%%(time)%ds | %%(name)-%ds" % (times_width, names_width)
    get_formatted_mem = (lambda k, v: (mem_fmt % v[k]) if k in v.keys() else 'N/A')
    header = format_string % {'time': tag, 'mem': mem_tag, 'name': 'File Name'}
    total = format_string % {'time': sum_times(v[TIME_KEY] for v in stats_dict.values() if TIME_KEY in v.keys()),
                             'mem': ((mem_fmt % max(v[MEM_KEY] for v in stats_dict.values() if MEM_KEY in v.keys())) if any(MEM_KEY in v.keys() for v in stats_dict.values()) else 'N/A'),
                             'name': total_string}
    sep = '-' * len(header)
    return '\n'.join([header, sep, total, sep] +
                     [format_string % {'time': stats_dict[name].get(TIME_KEY, 'N/A'),
                                       'mem': get_formatted_mem(MEM_KEY, stats_dict[name]),
                                       'name': name}
                      for name in names])

def print_or_write_table(table, files):
    if table[-1] != '\n': table += '\n'
    if len(files) == 0 or '-' in files:
        if hasattr(sys.stdout, 'buffer'):
            sys.stdout.buffer.write(table.encode("utf-8"))
        else:
            sys.stdout.write(table.encode("utf-8"))
    for file_name in files:
        if file_name != '-':
            with open(file_name, 'w', encoding="utf-8") as f:
                f.write(table)