diff --git a/scripts/code.py b/scripts/code.py
index f78dfaea..e776bebd 100755
--- a/scripts/code.py
+++ b/scripts/code.py
@@ -378,6 +378,7 @@ def table(Result, results, diff_results=None, *,
         summary=False,
         all=False,
         percent=False,
+        compare=None,
         **_):
     all_, all = all, __builtins__.all
 
@@ -409,8 +410,22 @@ def table(Result, results, diff_results=None, *,
                             getattr(diff_table.get(name), k, None))
                         for k in fields)]
 
+    # find compare entry if there is one
+    if compare is not None:
+        compare_result = table.get(','.join(str(k) for k in compare))
+
     # sort again, now with diff info, note that python's sort is stable
     names.sort()
+    if compare is not None:
+        names.sort(
+                key=lambda n: (
+                    table.get(n) == compare_result,
+                    tuple(
+                        types[k].ratio(
+                                getattr(table.get(n), k, None),
+                                getattr(compare_result, k, None))
+                            for k in fields)),
+                reverse=True)
     if diff_results is not None:
         names.sort(
                 key=lambda n: tuple(
@@ -462,14 +477,30 @@ def table(Result, results, diff_results=None, *,
     # entry helper
     def table_entry(name, r, diff_r=None):
         entry = [name]
-        if diff_results is None:
+        # normal entry?
+        if ((compare is None or r == compare_result)
+                and diff_results is None):
             for k in fields:
                 entry.append(
                         (getattr(r, k).table(),
                                 getattr(getattr(r, k), 'notes', lambda: [])())
                             if getattr(r, k, None) is not None
                             else types[k].none)
-        elif percent:
+        # compare entry?
+        elif compare is not None and diff_results is None:
+            for k in fields:
+                entry.append(
+                        (getattr(r, k).table()
+                                if getattr(r, k, None) is not None
+                                else types[k].none,
+                            (lambda t: ['+∞%'] if t == +mt.inf
+                                    else ['-∞%'] if t == -mt.inf
+                                    else ['%+.1f%%' % (100*t)])(
+                                types[k].ratio(
+                                    getattr(r, k, None),
+                                    getattr(compare_result, k, None)))))
+        # percent entry?
+        elif diff_results is not None and percent:
             for k in fields:
                 entry.append(
                         (getattr(r, k).table()
@@ -481,7 +512,8 @@ def table(Result, results, diff_results=None, *,
                                 types[k].ratio(
                                     getattr(r, k, None),
                                     getattr(diff_r, k, None)))))
-        else:
+        # diff entry?
+        elif diff_results is not None:
             for k in fields:
                 entry.append(getattr(diff_r, k).table()
                         if getattr(diff_r, k, None) is not None
@@ -514,13 +546,14 @@ def table(Result, results, diff_results=None, *,
                 diff_r = diff_table.get(name)
             lines.append(table_entry(name, r, diff_r))
 
-    # total
-    r = next(iter(fold(Result, results, by=[])), None)
-    if diff_results is None:
-        diff_r = None
-    else:
-        diff_r = next(iter(fold(Result, diff_results, by=[])), None)
-    lines.append(table_entry('TOTAL', r, diff_r))
+    # total, unless we're comparing
+    if summary or not (compare is not None and diff_results is None):
+        r = next(iter(fold(Result, results, by=[])), None)
+        if diff_results is None:
+            diff_r = None
+        else:
+            diff_r = next(iter(fold(Result, diff_results, by=[])), None)
+        lines.append(table_entry('TOTAL', r, diff_r))
 
     # homogenize
     lines = [
@@ -679,6 +712,10 @@ if __name__ == "__main__":
             '-p', '--percent',
             action='store_true',
             help="Only show percentage change, not a full diff.")
+    parser.add_argument(
+            '-c', '--compare',
+            type=lambda x: tuple(v.strip() for v in x.split(',')),
+            help="Compare results to the row matching this by pattern.")
     parser.add_argument(
             '-b', '--by',
             action='append',
diff --git a/scripts/cov.py b/scripts/cov.py
index 46261b23..4ce0c742 100755
--- a/scripts/cov.py
+++ b/scripts/cov.py
@@ -388,6 +388,7 @@ def table(Result, results, diff_results=None, *,
         summary=False,
         all=False,
         percent=False,
+        compare=None,
         **_):
     all_, all = all, __builtins__.all
 
@@ -419,8 +420,22 @@ def table(Result, results, diff_results=None, *,
                             getattr(diff_table.get(name), k, None))
                         for k in fields)]
 
+    # find compare entry if there is one
+    if compare is not None:
+        compare_result = table.get(','.join(str(k) for k in compare))
+
     # sort again, now with diff info, note that python's sort is stable
     names.sort()
+    if compare is not None:
+        names.sort(
+                key=lambda n: (
+                    table.get(n) == compare_result,
+                    tuple(
+                        types[k].ratio(
+                                getattr(table.get(n), k, None),
+                                getattr(compare_result, k, None))
+                            for k in fields)),
+                reverse=True)
     if diff_results is not None:
         names.sort(
                 key=lambda n: tuple(
@@ -472,14 +487,30 @@ def table(Result, results, diff_results=None, *,
     # entry helper
     def table_entry(name, r, diff_r=None):
         entry = [name]
-        if diff_results is None:
+        # normal entry?
+        if ((compare is None or r == compare_result)
+                and diff_results is None):
             for k in fields:
                 entry.append(
                         (getattr(r, k).table(),
                                 getattr(getattr(r, k), 'notes', lambda: [])())
                             if getattr(r, k, None) is not None
                             else types[k].none)
-        elif percent:
+        # compare entry?
+        elif compare is not None and diff_results is None:
+            for k in fields:
+                entry.append(
+                        (getattr(r, k).table()
+                                if getattr(r, k, None) is not None
+                                else types[k].none,
+                            (lambda t: ['+∞%'] if t == +mt.inf
+                                    else ['-∞%'] if t == -mt.inf
+                                    else ['%+.1f%%' % (100*t)])(
+                                types[k].ratio(
+                                    getattr(r, k, None),
+                                    getattr(compare_result, k, None)))))
+        # percent entry?
+        elif diff_results is not None and percent:
             for k in fields:
                 entry.append(
                         (getattr(r, k).table()
@@ -491,7 +522,8 @@ def table(Result, results, diff_results=None, *,
                                 types[k].ratio(
                                     getattr(r, k, None),
                                     getattr(diff_r, k, None)))))
-        else:
+        # diff entry?
+        elif diff_results is not None:
             for k in fields:
                 entry.append(getattr(diff_r, k).table()
                         if getattr(diff_r, k, None) is not None
@@ -524,13 +556,14 @@ def table(Result, results, diff_results=None, *,
                 diff_r = diff_table.get(name)
             lines.append(table_entry(name, r, diff_r))
 
-    # total
-    r = next(iter(fold(Result, results, by=[])), None)
-    if diff_results is None:
-        diff_r = None
-    else:
-        diff_r = next(iter(fold(Result, diff_results, by=[])), None)
-    lines.append(table_entry('TOTAL', r, diff_r))
+    # total, unless we're comparing
+    if summary or not (compare is not None and diff_results is None):
+        r = next(iter(fold(Result, results, by=[])), None)
+        if diff_results is None:
+            diff_r = None
+        else:
+            diff_r = next(iter(fold(Result, diff_results, by=[])), None)
+        lines.append(table_entry('TOTAL', r, diff_r))
 
     # homogenize
     lines = [
@@ -791,6 +824,10 @@ if __name__ == "__main__":
             '-p', '--percent',
             action='store_true',
             help="Only show percentage change, not a full diff.")
+    parser.add_argument(
+            '-c', '--compare',
+            type=lambda x: tuple(v.strip() for v in x.split(',')),
+            help="Compare results to the row matching this by pattern.")
     parser.add_argument(
             '-b', '--by',
             action='append',
diff --git a/scripts/csv.py b/scripts/csv.py
index 31daecce..be4c7e9e 100755
--- a/scripts/csv.py
+++ b/scripts/csv.py
@@ -1403,6 +1403,7 @@ def table(Result, results, diff_results=None, *,
         summary=False,
         all=False,
         percent=False,
+        compare=None,
         **_):
     all_, all = all, __builtins__.all
 
@@ -1434,8 +1435,32 @@ def table(Result, results, diff_results=None, *,
                             getattr(diff_table.get(name), k, None))
                         for k in fields)]
 
+    # find compare entry if there is one
+    if compare is not None:
+        compare_result = table.get(','.join(str(k) for k in compare))
+
     # sort again, now with diff info, note that python's sort is stable
     names.sort()
+    if compare is not None:
+        names.sort(
+                key=lambda n: (
+                    table.get(n) == compare_result,
+                    tuple(
+                        types[k].ratio(
+                                getattr(table.get(n), k, None),
+                                getattr(compare_result, k, None))
+                            for k in fields)),
+                reverse=True)
+    if compare is not None:
+        names.sort(
+                key=lambda n: (
+                    table.get(n) == compare_result,
+                    tuple(
+                        types[k].ratio(
+                                getattr(table.get(n), k, None),
+                                getattr(compare_result, k, None))
+                            for k in fields)),
+                reverse=True)
     if diff_results is not None:
         names.sort(
                 key=lambda n: tuple(
@@ -1487,14 +1512,30 @@ def table(Result, results, diff_results=None, *,
     # entry helper
     def table_entry(name, r, diff_r=None):
         entry = [name]
-        if diff_results is None:
+        # normal entry?
+        if ((compare is None or r == compare_result)
+                and diff_results is None):
             for k in fields:
                 entry.append(
                         (getattr(r, k).table(),
                                 getattr(getattr(r, k), 'notes', lambda: [])())
                             if getattr(r, k, None) is not None
                             else types[k].none)
-        elif percent:
+        # compare entry?
+        elif compare is not None and diff_results is None:
+            for k in fields:
+                entry.append(
+                        (getattr(r, k).table()
+                                if getattr(r, k, None) is not None
+                                else types[k].none,
+                            (lambda t: ['+∞%'] if t == +mt.inf
+                                    else ['-∞%'] if t == -mt.inf
+                                    else ['%+.1f%%' % (100*t)])(
+                                types[k].ratio(
+                                    getattr(r, k, None),
+                                    getattr(compare_result, k, None)))))
+        # percent entry?
+        elif diff_results is not None and percent:
             for k in fields:
                 entry.append(
                         (getattr(r, k).table()
@@ -1506,7 +1547,8 @@ def table(Result, results, diff_results=None, *,
                                 types[k].ratio(
                                     getattr(r, k, None),
                                     getattr(diff_r, k, None)))))
-        else:
+        # diff entry?
+        elif diff_results is not None:
             for k in fields:
                 entry.append(getattr(diff_r, k).table()
                         if getattr(diff_r, k, None) is not None
@@ -1539,13 +1581,14 @@ def table(Result, results, diff_results=None, *,
                 diff_r = diff_table.get(name)
             lines.append(table_entry(name, r, diff_r))
 
-    # total
-    r = next(iter(fold(Result, results, by=[])), None)
-    if diff_results is None:
-        diff_r = None
-    else:
-        diff_r = next(iter(fold(Result, diff_results, by=[])), None)
-    lines.append(table_entry('TOTAL', r, diff_r))
+    # total, unless we're comparing
+    if summary or not (compare is not None and diff_results is None):
+        r = next(iter(fold(Result, results, by=[])), None)
+        if diff_results is None:
+            diff_r = None
+        else:
+            diff_r = next(iter(fold(Result, diff_results, by=[])), None)
+        lines.append(table_entry('TOTAL', r, diff_r))
 
     # homogenize
     lines = [
@@ -1708,6 +1751,10 @@ if __name__ == "__main__":
             '-p', '--percent',
             action='store_true',
             help="Only show percentage change, not a full diff.")
+    parser.add_argument(
+            '-c', '--compare',
+            type=lambda x: tuple(v.strip() for v in x.split(',')),
+            help="Compare results to the row matching this by pattern.")
     parser.add_argument(
             '-b', '--by',
             action='append',
diff --git a/scripts/data.py b/scripts/data.py
index fa820bc6..0af08061 100755
--- a/scripts/data.py
+++ b/scripts/data.py
@@ -378,6 +378,7 @@ def table(Result, results, diff_results=None, *,
         summary=False,
         all=False,
         percent=False,
+        compare=None,
         **_):
     all_, all = all, __builtins__.all
 
@@ -409,8 +410,22 @@ def table(Result, results, diff_results=None, *,
                             getattr(diff_table.get(name), k, None))
                         for k in fields)]
 
+    # find compare entry if there is one
+    if compare is not None:
+        compare_result = table.get(','.join(str(k) for k in compare))
+
     # sort again, now with diff info, note that python's sort is stable
     names.sort()
+    if compare is not None:
+        names.sort(
+                key=lambda n: (
+                    table.get(n) == compare_result,
+                    tuple(
+                        types[k].ratio(
+                                getattr(table.get(n), k, None),
+                                getattr(compare_result, k, None))
+                            for k in fields)),
+                reverse=True)
     if diff_results is not None:
         names.sort(
                 key=lambda n: tuple(
@@ -462,14 +477,30 @@ def table(Result, results, diff_results=None, *,
     # entry helper
     def table_entry(name, r, diff_r=None):
         entry = [name]
-        if diff_results is None:
+        # normal entry?
+        if ((compare is None or r == compare_result)
+                and diff_results is None):
             for k in fields:
                 entry.append(
                         (getattr(r, k).table(),
                                 getattr(getattr(r, k), 'notes', lambda: [])())
                             if getattr(r, k, None) is not None
                             else types[k].none)
-        elif percent:
+        # compare entry?
+        elif compare is not None and diff_results is None:
+            for k in fields:
+                entry.append(
+                        (getattr(r, k).table()
+                                if getattr(r, k, None) is not None
+                                else types[k].none,
+                            (lambda t: ['+∞%'] if t == +mt.inf
+                                    else ['-∞%'] if t == -mt.inf
+                                    else ['%+.1f%%' % (100*t)])(
+                                types[k].ratio(
+                                    getattr(r, k, None),
+                                    getattr(compare_result, k, None)))))
+        # percent entry?
+        elif diff_results is not None and percent:
             for k in fields:
                 entry.append(
                         (getattr(r, k).table()
@@ -481,7 +512,8 @@ def table(Result, results, diff_results=None, *,
                                 types[k].ratio(
                                     getattr(r, k, None),
                                     getattr(diff_r, k, None)))))
-        else:
+        # diff entry?
+        elif diff_results is not None:
             for k in fields:
                 entry.append(getattr(diff_r, k).table()
                         if getattr(diff_r, k, None) is not None
@@ -514,13 +546,14 @@ def table(Result, results, diff_results=None, *,
                 diff_r = diff_table.get(name)
             lines.append(table_entry(name, r, diff_r))
 
-    # total
-    r = next(iter(fold(Result, results, by=[])), None)
-    if diff_results is None:
-        diff_r = None
-    else:
-        diff_r = next(iter(fold(Result, diff_results, by=[])), None)
-    lines.append(table_entry('TOTAL', r, diff_r))
+    # total, unless we're comparing
+    if summary or not (compare is not None and diff_results is None):
+        r = next(iter(fold(Result, results, by=[])), None)
+        if diff_results is None:
+            diff_r = None
+        else:
+            diff_r = next(iter(fold(Result, diff_results, by=[])), None)
+        lines.append(table_entry('TOTAL', r, diff_r))
 
     # homogenize
     lines = [
@@ -676,6 +709,10 @@ if __name__ == "__main__":
             '-p', '--percent',
             action='store_true',
             help="Only show percentage change, not a full diff.")
+    parser.add_argument(
+            '-c', '--compare',
+            type=lambda x: tuple(v.strip() for v in x.split(',')),
+            help="Compare results to the row matching this by pattern.")
     parser.add_argument(
             '-b', '--by',
             action='append',
diff --git a/scripts/perf.py b/scripts/perf.py
index 539c0934..f90de89c 100755
--- a/scripts/perf.py
+++ b/scripts/perf.py
@@ -694,6 +694,7 @@ def table(Result, results, diff_results=None, *,
         summary=False,
         all=False,
         percent=False,
+        compare=None,
         depth=None,
         hot=None,
         **_):
@@ -755,8 +756,22 @@ def table(Result, results, diff_results=None, *,
                         getattr(diff_table.get(name), k, None))
                     for k in fields)]
 
+    # find compare entry if there is one
+    if compare is not None:
+        compare_result = table.get(','.join(str(k) for k in compare))
+
     # sort again, now with diff info, note that python's sort is stable
     names.sort()
+    if compare is not None:
+        names.sort(
+                key=lambda n: (
+                    table.get(n) == compare_result,
+                    tuple(
+                        types[k].ratio(
+                                getattr(table.get(n), k, None),
+                                getattr(compare_result, k, None))
+                            for k in fields)),
+                reverse=True)
     if diff_results is not None:
         names.sort(
                 key=lambda n: tuple(
@@ -808,14 +823,30 @@ def table(Result, results, diff_results=None, *,
     # entry helper
     def table_entry(name, r, diff_r=None):
         entry = [name]
-        if diff_results is None:
+        # normal entry?
+        if ((compare is None or r == compare_result)
+                and diff_results is None):
             for k in fields:
                 entry.append(
                         (getattr(r, k).table(),
                                 getattr(getattr(r, k), 'notes', lambda: [])())
                             if getattr(r, k, None) is not None
                             else types[k].none)
-        elif percent:
+        # compare entry?
+        elif compare is not None and diff_results is None:
+            for k in fields:
+                entry.append(
+                        (getattr(r, k).table()
+                                if getattr(r, k, None) is not None
+                                else types[k].none,
+                            (lambda t: ['+∞%'] if t == +mt.inf
+                                    else ['-∞%'] if t == -mt.inf
+                                    else ['%+.1f%%' % (100*t)])(
+                                types[k].ratio(
+                                    getattr(r, k, None),
+                                    getattr(compare_result, k, None)))))
+        # percent entry?
+        elif diff_results is not None and percent:
             for k in fields:
                 entry.append(
                         (getattr(r, k).table()
@@ -827,7 +858,8 @@ def table(Result, results, diff_results=None, *,
                                 types[k].ratio(
                                     getattr(r, k, None),
                                     getattr(diff_r, k, None)))))
-        else:
+        # diff entry?
+        elif diff_results is not None:
             for k in fields:
                 entry.append(getattr(diff_r, k).table()
                         if getattr(diff_r, k, None) is not None
@@ -923,13 +955,14 @@ def table(Result, results, diff_results=None, *,
                          "|   ",
                          "    "))
 
-    # total
-    r = next(iter(fold(Result, results, by=[])), None)
-    if diff_results is None:
-        diff_r = None
-    else:
-        diff_r = next(iter(fold(Result, diff_results, by=[])), None)
-    lines.append(table_entry('TOTAL', r, diff_r))
+    # total, unless we're comparing
+    if summary or not (compare is not None and diff_results is None):
+        r = next(iter(fold(Result, results, by=[])), None)
+        if diff_results is None:
+            diff_r = None
+        else:
+            diff_r = next(iter(fold(Result, diff_results, by=[])), None)
+        lines.append(table_entry('TOTAL', r, diff_r))
 
     # homogenize
     lines = [
@@ -1233,6 +1266,10 @@ if __name__ == "__main__":
             '-p', '--percent',
             action='store_true',
             help="Only show percentage change, not a full diff.")
+    parser.add_argument(
+            '-c', '--compare',
+            type=lambda x: tuple(v.strip() for v in x.split(',')),
+            help="Compare results to the row matching this by pattern.")
     parser.add_argument(
             '-b', '--by',
             action='append',
diff --git a/scripts/perfbd.py b/scripts/perfbd.py
index 1a5b81de..d3de783a 100755
--- a/scripts/perfbd.py
+++ b/scripts/perfbd.py
@@ -658,6 +658,7 @@ def table(Result, results, diff_results=None, *,
         summary=False,
         all=False,
         percent=False,
+        compare=None,
         depth=None,
         hot=None,
         **_):
@@ -719,8 +720,22 @@ def table(Result, results, diff_results=None, *,
                         getattr(diff_table.get(name), k, None))
                     for k in fields)]
 
+    # find compare entry if there is one
+    if compare is not None:
+        compare_result = table.get(','.join(str(k) for k in compare))
+
     # sort again, now with diff info, note that python's sort is stable
     names.sort()
+    if compare is not None:
+        names.sort(
+                key=lambda n: (
+                    table.get(n) == compare_result,
+                    tuple(
+                        types[k].ratio(
+                                getattr(table.get(n), k, None),
+                                getattr(compare_result, k, None))
+                            for k in fields)),
+                reverse=True)
     if diff_results is not None:
         names.sort(
                 key=lambda n: tuple(
@@ -772,14 +787,30 @@ def table(Result, results, diff_results=None, *,
     # entry helper
     def table_entry(name, r, diff_r=None):
         entry = [name]
-        if diff_results is None:
+        # normal entry?
+        if ((compare is None or r == compare_result)
+                and diff_results is None):
             for k in fields:
                 entry.append(
                         (getattr(r, k).table(),
                                 getattr(getattr(r, k), 'notes', lambda: [])())
                             if getattr(r, k, None) is not None
                             else types[k].none)
-        elif percent:
+        # compare entry?
+        elif compare is not None and diff_results is None:
+            for k in fields:
+                entry.append(
+                        (getattr(r, k).table()
+                                if getattr(r, k, None) is not None
+                                else types[k].none,
+                            (lambda t: ['+∞%'] if t == +mt.inf
+                                    else ['-∞%'] if t == -mt.inf
+                                    else ['%+.1f%%' % (100*t)])(
+                                types[k].ratio(
+                                    getattr(r, k, None),
+                                    getattr(compare_result, k, None)))))
+        # percent entry?
+        elif diff_results is not None and percent:
             for k in fields:
                 entry.append(
                         (getattr(r, k).table()
@@ -791,7 +822,8 @@ def table(Result, results, diff_results=None, *,
                                 types[k].ratio(
                                     getattr(r, k, None),
                                     getattr(diff_r, k, None)))))
-        else:
+        # diff entry?
+        elif diff_results is not None:
             for k in fields:
                 entry.append(getattr(diff_r, k).table()
                         if getattr(diff_r, k, None) is not None
@@ -887,13 +919,14 @@ def table(Result, results, diff_results=None, *,
                          "|   ",
                          "    "))
 
-    # total
-    r = next(iter(fold(Result, results, by=[])), None)
-    if diff_results is None:
-        diff_r = None
-    else:
-        diff_r = next(iter(fold(Result, diff_results, by=[])), None)
-    lines.append(table_entry('TOTAL', r, diff_r))
+    # total, unless we're comparing
+    if summary or not (compare is not None and diff_results is None):
+        r = next(iter(fold(Result, results, by=[])), None)
+        if diff_results is None:
+            diff_r = None
+        else:
+            diff_r = next(iter(fold(Result, diff_results, by=[])), None)
+        lines.append(table_entry('TOTAL', r, diff_r))
 
     # homogenize
     lines = [
@@ -1200,6 +1233,10 @@ if __name__ == "__main__":
             '-p', '--percent',
             action='store_true',
             help="Only show percentage change, not a full diff.")
+    parser.add_argument(
+            '-c', '--compare',
+            type=lambda x: tuple(v.strip() for v in x.split(',')),
+            help="Compare results to the row matching this by pattern.")
     parser.add_argument(
             '-b', '--by',
             action='append',
diff --git a/scripts/stack.py b/scripts/stack.py
index 1ae7bf0f..cf6d9c60 100755
--- a/scripts/stack.py
+++ b/scripts/stack.py
@@ -340,6 +340,7 @@ def table(Result, results, diff_results=None, *,
         summary=False,
         all=False,
         percent=False,
+        compare=None,
         depth=None,
         hot=None,
         **_):
@@ -401,8 +402,22 @@ def table(Result, results, diff_results=None, *,
                         getattr(diff_table.get(name), k, None))
                     for k in fields)]
 
+    # find compare entry if there is one
+    if compare is not None:
+        compare_result = table.get(','.join(str(k) for k in compare))
+
     # sort again, now with diff info, note that python's sort is stable
     names.sort()
+    if compare is not None:
+        names.sort(
+                key=lambda n: (
+                    table.get(n) == compare_result,
+                    tuple(
+                        types[k].ratio(
+                                getattr(table.get(n), k, None),
+                                getattr(compare_result, k, None))
+                            for k in fields)),
+                reverse=True)
     if diff_results is not None:
         names.sort(
                 key=lambda n: tuple(
@@ -454,14 +469,30 @@ def table(Result, results, diff_results=None, *,
     # entry helper
     def table_entry(name, r, diff_r=None):
         entry = [name]
-        if diff_results is None:
+        # normal entry?
+        if ((compare is None or r == compare_result)
+                and diff_results is None):
             for k in fields:
                 entry.append(
                         (getattr(r, k).table(),
                                 getattr(getattr(r, k), 'notes', lambda: [])())
                             if getattr(r, k, None) is not None
                             else types[k].none)
-        elif percent:
+        # compare entry?
+        elif compare is not None and diff_results is None:
+            for k in fields:
+                entry.append(
+                        (getattr(r, k).table()
+                                if getattr(r, k, None) is not None
+                                else types[k].none,
+                            (lambda t: ['+∞%'] if t == +mt.inf
+                                    else ['-∞%'] if t == -mt.inf
+                                    else ['%+.1f%%' % (100*t)])(
+                                types[k].ratio(
+                                    getattr(r, k, None),
+                                    getattr(compare_result, k, None)))))
+        # percent entry?
+        elif diff_results is not None and percent:
             for k in fields:
                 entry.append(
                         (getattr(r, k).table()
@@ -473,7 +504,8 @@ def table(Result, results, diff_results=None, *,
                                 types[k].ratio(
                                     getattr(r, k, None),
                                     getattr(diff_r, k, None)))))
-        else:
+        # diff entry?
+        elif diff_results is not None:
             for k in fields:
                 entry.append(getattr(diff_r, k).table()
                         if getattr(diff_r, k, None) is not None
@@ -569,13 +601,14 @@ def table(Result, results, diff_results=None, *,
                          "|   ",
                          "    "))
 
-    # total
-    r = next(iter(fold(Result, results, by=[])), None)
-    if diff_results is None:
-        diff_r = None
-    else:
-        diff_r = next(iter(fold(Result, diff_results, by=[])), None)
-    lines.append(table_entry('TOTAL', r, diff_r))
+    # total, unless we're comparing
+    if summary or not (compare is not None and diff_results is None):
+        r = next(iter(fold(Result, results, by=[])), None)
+        if diff_results is None:
+            diff_r = None
+        else:
+            diff_r = next(iter(fold(Result, diff_results, by=[])), None)
+        lines.append(table_entry('TOTAL', r, diff_r))
 
     # homogenize
     lines = [
@@ -745,6 +778,10 @@ if __name__ == "__main__":
             '-p', '--percent',
             action='store_true',
             help="Only show percentage change, not a full diff.")
+    parser.add_argument(
+            '-c', '--compare',
+            type=lambda x: tuple(v.strip() for v in x.split(',')),
+            help="Compare results to the row matching this by pattern.")
     parser.add_argument(
             '-b', '--by',
             action='append',
diff --git a/scripts/structs.py b/scripts/structs.py
index 043e4303..dceb2ba6 100755
--- a/scripts/structs.py
+++ b/scripts/structs.py
@@ -328,6 +328,7 @@ def table(Result, results, diff_results=None, *,
         summary=False,
         all=False,
         percent=False,
+        compare=None,
         **_):
     all_, all = all, __builtins__.all
 
@@ -359,8 +360,22 @@ def table(Result, results, diff_results=None, *,
                             getattr(diff_table.get(name), k, None))
                         for k in fields)]
 
+    # find compare entry if there is one
+    if compare is not None:
+        compare_result = table.get(','.join(str(k) for k in compare))
+
     # sort again, now with diff info, note that python's sort is stable
     names.sort()
+    if compare is not None:
+        names.sort(
+                key=lambda n: (
+                    table.get(n) == compare_result,
+                    tuple(
+                        types[k].ratio(
+                                getattr(table.get(n), k, None),
+                                getattr(compare_result, k, None))
+                            for k in fields)),
+                reverse=True)
     if diff_results is not None:
         names.sort(
                 key=lambda n: tuple(
@@ -412,14 +427,30 @@ def table(Result, results, diff_results=None, *,
     # entry helper
     def table_entry(name, r, diff_r=None):
         entry = [name]
-        if diff_results is None:
+        # normal entry?
+        if ((compare is None or r == compare_result)
+                and diff_results is None):
             for k in fields:
                 entry.append(
                         (getattr(r, k).table(),
                                 getattr(getattr(r, k), 'notes', lambda: [])())
                             if getattr(r, k, None) is not None
                             else types[k].none)
-        elif percent:
+        # compare entry?
+        elif compare is not None and diff_results is None:
+            for k in fields:
+                entry.append(
+                        (getattr(r, k).table()
+                                if getattr(r, k, None) is not None
+                                else types[k].none,
+                            (lambda t: ['+∞%'] if t == +mt.inf
+                                    else ['-∞%'] if t == -mt.inf
+                                    else ['%+.1f%%' % (100*t)])(
+                                types[k].ratio(
+                                    getattr(r, k, None),
+                                    getattr(compare_result, k, None)))))
+        # percent entry?
+        elif diff_results is not None and percent:
             for k in fields:
                 entry.append(
                         (getattr(r, k).table()
@@ -431,7 +462,8 @@ def table(Result, results, diff_results=None, *,
                                 types[k].ratio(
                                     getattr(r, k, None),
                                     getattr(diff_r, k, None)))))
-        else:
+        # diff entry?
+        elif diff_results is not None:
             for k in fields:
                 entry.append(getattr(diff_r, k).table()
                         if getattr(diff_r, k, None) is not None
@@ -464,13 +496,14 @@ def table(Result, results, diff_results=None, *,
                 diff_r = diff_table.get(name)
             lines.append(table_entry(name, r, diff_r))
 
-    # total
-    r = next(iter(fold(Result, results, by=[])), None)
-    if diff_results is None:
-        diff_r = None
-    else:
-        diff_r = next(iter(fold(Result, diff_results, by=[])), None)
-    lines.append(table_entry('TOTAL', r, diff_r))
+    # total, unless we're comparing
+    if summary or not (compare is not None and diff_results is None):
+        r = next(iter(fold(Result, results, by=[])), None)
+        if diff_results is None:
+            diff_r = None
+        else:
+            diff_r = next(iter(fold(Result, diff_results, by=[])), None)
+        lines.append(table_entry('TOTAL', r, diff_r))
 
     # homogenize
     lines = [
@@ -631,6 +664,10 @@ if __name__ == "__main__":
             '-p', '--percent',
             action='store_true',
             help="Only show percentage change, not a full diff.")
+    parser.add_argument(
+            '-c', '--compare',
+            type=lambda x: tuple(v.strip() for v in x.split(',')),
+            help="Compare results to the row matching this by pattern.")
     parser.add_argument(
             '-b', '--by',
             action='append',