The fair-comparison method

Fix two axes before comparing the third: same library, same clock target with slack stated, and same activity assumptions. Then area and power numbers mean the same thing.

Compare at equal timing first: both runs must meet slack of zero or better. A faster run that burns the power budget has not won anything.

Dominated and Pareto-optimal

Run P dominates run Q when P is no worse on every axis and better on at least one. A dominated run can never be the right answer on these three axes alone; an unmodelled objective can change the ranking.

The Pareto front is the set of runs nothing dominates. The method keeps the front and drops the rest from the three-axis comparison, then the budget picks among survivors.

both runs meet the same 2.0 ns target with slack >= 0 (stated EXAMPLE numbers)
run A: area 100 units, power 8.0 mW, delay 2.0 ns
run B: area 120 units, power 6.0 mW, delay 2.0 ns
A beats B on area (100 < 120); B beats A on power (6.0 < 8.0); delay ties
neither run is better on every axis, so neither dominates
an area budget picks A and a power budget picks B

A worked filter

Six EXAMPLE candidates trade area units, milliwatts, and EXAMPLE nanoseconds. Lower is better on all three axes, and the program filters them exactly.

Candidate C beats D on every axis, so D is dominated. Candidate A beats E on power and delay at equal area, so E is dominated. The front keeps A, B, C, and F.

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

import sys

CANDS = [
    ("A", 100, 8.0, 2.0),
    ("B", 120, 6.0, 2.0),
    ("C", 110, 7.0, 1.6),
    ("D", 130, 7.5, 1.8),
    ("E", 100, 9.0, 2.2),
    ("F", 140, 5.5, 1.5),
]

def dominates(p, q):
    return p[1] <= q[1] and p[2] <= q[2] and p[3] <= q[3] and (p[1] < q[1] or p[2] < q[2] or p[3] < q[3])

dominated = {}
for q in CANDS:
    by = sorted([p[0] for p in CANDS if dominates(p, q)])
    if by:
        dominated[q[0]] = by

front = sorted([c[0] for c in CANDS if c[0] not in dominated])

bad = 0
if front != ["A", "B", "C", "F"]:
    print("FAIL: front is " + str(front))
    bad = 1
if dominated.get("D") != ["C"]:
    print("FAIL: D dominated by " + str(dominated.get("D")))
    bad = 1
if dominated.get("E") != ["A"]:
    print("FAIL: E dominated by " + str(dominated.get("E")))
    bad = 1
if len(dominated) != 2:
    print("FAIL: dominated count is " + str(len(dominated)))
    bad = 1
if bad:
    sys.exit(1)

print("PASS: Pareto filter keeps A B C F and drops D E on 4 checks")

Common mistakes

Comparing runs at different timing points or activities rigs the contest. Renormalize first, or the filter compares noise.

Related topics

• Previous: Sizing and Duplication Cost

• See also: Debugging QoR