setup) setup && cleanup_submodules ;;

   configure) time_it "configure" configure ;;

   build_hadrian) time_it "build" build_hadrian ;;

   test_hadrian)

     fetch_perf_notes

     res=0

                                    ('metric', MetricName),

                                    ('value', float)])

 # The type of exceptions which are thrown when computing the current stat value

 # fails.

  else:

         return get_allowed_perf_changes()

 # Get the baseline of a test at a given commit. This is the expected value

 # *before* the commit is applied (i.e. on the parent commit).

 #                      instead when looking for ci results)

 # metric: str - test metric

 # way: str - test way

 #          BaselineSearchDepth commits and since the last expected change

 #          (ignoring any expected change in the given commit).

 def baseline_metric(commit: GitHash,

                     metric: MetricName,

                     way: WayName,

                     baseline_ref: Optional[GitRef]

     # For performance reasons (in order to avoid calling commit_hash), we assert

     # commit is already a commit hash.

     assert is_commit_hash(commit)

     # Searches through previous commits trying local then ci for each commit in.

     def find_baseline(namespace: NoteNamespace,

                       test_env: TestEnv

         if baseline_commit is not None:

         for depth, current_commit in list(enumerate(commit_hashes)):

             if current_commit == commit: continue

             # Check for a metric on this commit.

             current_metric = get_commit_metric(namespace, current_commit, test_env, name, metric, way)

             if current_metric is not None:

             # Stop if there is an expected change at this commit. In that case

             # metrics on ancestor commits will not be a valid baseline.

     # Test environment to use when comparing against CI namespace

     ci_test_env = best_fit_ci_test_env()

     if baseline is None and ci_test_env is not None:

         baseline = find_baseline(CiNamespace, ci_test_env)

     result = get_commit_metric(gitNoteRef, commit, test_env, name, metric, way)

     if result is None:

         return None

 # gitNoteRef: git notes ref space e.g. "perf" or "ci/perf"

 # ref: git commit

 # test_env: test environment

 # name: test name

 # metric: test metric

 # way: test way

 def get_commit_metric(gitNoteRef,

                       ref: Union[GitRef, GitHash],

                       test_env: TestEnv,

                       name: TestName,

                       metric: MetricName,

                       way: WayName

     global _commit_metric_cache

     assert test_env != None

     commit = commit_hash(ref)

         return _commit_metric_cache[cacheKeyA].get(cacheKeyB)

     # Cache miss.

     # Note that the git note may contain data for other tests. All tests'

     allCommitMetrics = get_perf_stats(ref, gitNoteRef)

     # Collect recorded values by cacheKeyB.

         currentValues = values_by_cache_key_b.setdefault(currentCacheKey, [])

         currentValues.append(float(perfStat.value))

     for currentCacheKey, currentValues in values_by_cache_key_b.items():

 def check_stats_change(actual: PerfStat,

                        acceptance_window: MetricAcceptanceWindow,

                        allowed_perf_changes: Dict[TestName, List[AllowedPerfChange]] = {},

                        force_print = False

     Parameters:

     actual: the PerfStat with actual value

     acceptance_window: allowed deviation of the actual value from the expected

         value.

     allowed_perf_changes: allowed changes in stats. This is a dictionary as

                 ' baseline @ %s' % baseline.commit

         print(actual.metric, error + ':')

         dev = 100.0 if expected_val == 0 else round(((float(actual.value) * 100) / int(expected_val)) - 100, 1)

         change_line = (f'{actual.metric} {change.value} from {baseline.perfStat.test_env} '

                        f'baseline @ {baseline.commit[:7]}: {expected_val} -> {actual.value} '

         result = failBecause('stat ' + change_line, tag='stat')

     if not change_allowed or force_print:

             print(descr, str(val).rjust(length), extra)

         display('    Expected    ' + full_name + ' ' + actual.metric + ':', expected_val, acceptance_window.describe())

         display('    Lower bound ' + full_name + ' ' + actual.metric + ':', lowerBound, '')

         display('    Upper bound ' + full_name + ' ' + actual.metric + ':', upperBound, '')

         display('    Actual      ' + full_name + ' ' + actual.metric + ':', actual.value, '')

     # HEAD~2           21234                 21234

     # HEAD~3           20000                 20000

     def strMetric(x):

     # Data is in column major format, so transpose and pass to print_table.

     T = TypeVar('T')

     def transpose(xss: List[List[T]]) -> List[List[T]]:

 from my_typing import *

 from pathlib import Path

 from datetime import datetime

 # -----------------------------------------------------------------------------

 PerfMetric = NamedTuple('PerfMetric',

                         [('change', MetricChange),

                          ('stat', PerfStat),

 class TestRun:

    def __init__(self) -> None: