rename Metrics to Runtime and put runtime function parameters first

`Runtime` will encompass other aspects of execution state.

PiperOrigin-RevId: 601084631
Change-Id: Idf81dd2f613ffa53c955452db528ad1d59aa8a18

23 files changed, 220 insertions, 221 deletions

diff --git a/abigail_reader.cc b/abigail_reader.cc
index 062f396..96be54d 100644
--- a/abigail_reader.cc
+++ b/abigail_reader.cc
@@ -1285,14 +1285,14 @@ Id Abigail::BuildSymbols() {
   return graph_.Add<Interface>(symbols);
 }
 
-Document Read(const std::string& path, Metrics& metrics) {
+Document Read(Runtime& runtime, const std::string& path) {
   // Open input for reading.
   const FileDescriptor fd(path.c_str(), O_RDONLY);
 
   // Read the XML.
   Document document(nullptr, xmlFreeDoc);
   {
-    const Time t(metrics, "abigail.libxml_parse");
+    const Time t(runtime, "abigail.libxml_parse");
     const std::unique_ptr<
         std::remove_pointer_t<xmlParserCtxtPtr>, void(*)(xmlParserCtxtPtr)>
         context(xmlNewParserCtxt(), xmlFreeParserCtxt);
@@ -1305,8 +1305,8 @@ Document Read(const std::string& path, Metrics& metrics) {
   return document;
 }
 
-Id Read(Graph& graph, const std::string& path, Metrics& metrics) {
-  const Document document = Read(path, metrics);
+Id Read(Runtime& runtime, Graph& graph, const std::string& path) {
+  const Document document = Read(runtime, path);
   const xmlNodePtr root = xmlDocGetRootElement(document.get());
   Check(root != nullptr) << "XML document has no root element";
   return Abigail(graph).ProcessRoot(root);
diff --git a/abigail_reader.h b/abigail_reader.h
index 21ada8d..e9e26ce 100644
--- a/abigail_reader.h
+++ b/abigail_reader.h
@@ -146,7 +146,7 @@ class Abigail {
   Id BuildSymbols();
 };
 
-Id Read(Graph& graph, const std::string& path, Metrics& metrics);
+Id Read(Runtime& runtime, Graph& graph, const std::string& path);
 
 // Exposed for testing.
 void Clean(xmlNodePtr root);
@@ -154,7 +154,7 @@ bool EqualTree(xmlNodePtr left, xmlNodePtr right);
 bool SubTree(xmlNodePtr left, xmlNodePtr right);
 using Document =
     std::unique_ptr<std::remove_pointer_t<xmlDocPtr>, void(*)(xmlDocPtr)>;
-Document Read(const std::string& path, Metrics& metrics);
+Document Read(Runtime& runtime, const std::string& path);
 
 }  // namespace abixml
 }  // namespace stg
diff --git a/abigail_reader_test.cc b/abigail_reader_test.cc
index d86703c..e71a0be 100644
--- a/abigail_reader_test.cc
+++ b/abigail_reader_test.cc
@@ -39,13 +39,13 @@ std::filesystem::path filename_to_path(const char* f) {
 }
 
 stg::abixml::Document Read(const char* input) {
-  stg::Metrics metrics(std::cerr, false);
-  return stg::abixml::Read(filename_to_path(input), metrics);
+  stg::Runtime runtime(std::cerr, false);
+  return stg::abixml::Read(runtime, filename_to_path(input));
 }
 
 stg::Id Read(stg::Graph& graph, const char* input) {
-  stg::Metrics metrics(std::cerr, false);
-  return stg::abixml::Read(graph, filename_to_path(input), metrics);
+  stg::Runtime runtime(std::cerr, false);
+  return stg::abixml::Read(runtime, graph, filename_to_path(input));
 }
 
 struct EqualTreeTestCase {
diff --git a/comparison.h b/comparison.h
index 8481003..07e91a2 100644
--- a/comparison.h
+++ b/comparison.h
@@ -258,15 +258,15 @@ struct ResolveQualifier {
 };
 
 struct Compare {
-  Compare(const Graph& graph, const Ignore& ignore, Metrics& metrics)
+  Compare(Runtime& runtime, const Graph& graph, const Ignore& ignore)
       : graph(graph), ignore(ignore),
-        queried(metrics, "compare.queried"),
-        already_compared(metrics, "compare.already_compared"),
-        being_compared(metrics, "compare.being_compared"),
-        really_compared(metrics, "compare.really_compared"),
-        equivalent(metrics, "compare.equivalent"),
-        inequivalent(metrics, "compare.inequivalent"),
-        scc_size(metrics, "compare.scc_size") {}
+        queried(runtime, "compare.queried"),
+        already_compared(runtime, "compare.already_compared"),
+        being_compared(runtime, "compare.being_compared"),
+        really_compared(runtime, "compare.really_compared"),
+        equivalent(runtime, "compare.equivalent"),
+        inequivalent(runtime, "compare.inequivalent"),
+        scc_size(runtime, "compare.scc_size") {}
   std::pair<bool, std::optional<Comparison>>  operator()(Id id1, Id id2);
 
   Comparison Removed(Id id);
diff --git a/deduplication.cc b/deduplication.cc
index 464e8d0..0238b62 100644
--- a/deduplication.cc
+++ b/deduplication.cc
@@ -33,21 +33,21 @@
 
 namespace stg {
 
-Id Deduplicate(Graph& graph, Id root, const Hashes& hashes, Metrics& metrics) {
+Id Deduplicate(Runtime& runtime, Graph& graph, Id root, const Hashes& hashes) {
   // Partition the nodes by hash.
   std::unordered_map<HashValue, std::vector<Id>> partitions;
   {
-    const Time x(metrics, "partition nodes");
+    const Time x(runtime, "partition nodes");
     for (const auto& [id, fp] : hashes) {
       partitions[fp].push_back(id);
     }
   }
-  Counter(metrics, "deduplicate.nodes") = hashes.size();
-  Counter(metrics, "deduplicate.hashes") = partitions.size();
+  Counter(runtime, "deduplicate.nodes") = hashes.size();
+  Counter(runtime, "deduplicate.hashes") = partitions.size();
 
-  Histogram hash_partition_size(metrics, "deduplicate.hash_partition_size");
-  Counter min_comparisons(metrics, "deduplicate.min_comparisons");
-  Counter max_comparisons(metrics, "deduplicate.max_comparisons");
+  Histogram hash_partition_size(runtime, "deduplicate.hash_partition_size");
+  Counter min_comparisons(runtime, "deduplicate.min_comparisons");
+  Counter max_comparisons(runtime, "deduplicate.max_comparisons");
   for (const auto& [fp, ids] : partitions) {
     const auto n = ids.size();
     hash_partition_size.Add(n);
@@ -56,12 +56,12 @@ Id Deduplicate(Graph& graph, Id root, const Hashes& hashes, Metrics& metrics) {
   }
 
   // Refine partitions of nodes with the same fingerprints.
-  EqualityCache cache(hashes, metrics);
+  EqualityCache cache(runtime, hashes);
   Equals<EqualityCache> equals(graph, cache);
-  Counter equalities(metrics, "deduplicate.equalities");
-  Counter inequalities(metrics, "deduplicate.inequalities");
+  Counter equalities(runtime, "deduplicate.equalities");
+  Counter inequalities(runtime, "deduplicate.inequalities");
   {
-    const Time x(metrics, "find duplicates");
+    const Time x(runtime, "find duplicates");
     for (auto& [fp, ids] : partitions) {
       while (ids.size() > 1) {
         std::vector<Id> todo;
@@ -80,8 +80,8 @@ Id Deduplicate(Graph& graph, Id root, const Hashes& hashes, Metrics& metrics) {
   }
 
   // Keep one representative of each set of duplicates.
-  Counter unique(metrics, "deduplicate.unique");
-  Counter duplicate(metrics, "deduplicate.duplicate");
+  Counter unique(runtime, "deduplicate.unique");
+  Counter duplicate(runtime, "deduplicate.duplicate");
   auto remap = [&cache](Id& id) {
     // update id to representative id, avoiding silent stores
     const Id fid = cache.Find(id);
@@ -91,7 +91,7 @@ Id Deduplicate(Graph& graph, Id root, const Hashes& hashes, Metrics& metrics) {
   };
   Substitute substitute(graph, remap);
   {
-    const Time x(metrics, "rewrite");
+    const Time x(runtime, "rewrite");
     for (const auto& [id, fp] : hashes) {
       const Id fid = cache.Find(id);
       if (fid != id) {
diff --git a/deduplication.h b/deduplication.h
index 73e0dea..423c2ea 100644
--- a/deduplication.h
+++ b/deduplication.h
@@ -31,7 +31,7 @@ namespace stg {
 
 using Hashes = std::unordered_map<Id, HashValue>;
 
-Id Deduplicate(Graph& graph, Id root, const Hashes& hashes, Metrics& metrics);
+Id Deduplicate(Runtime& runtime, Graph& graph, Id root, const Hashes& hashes);
 
 }  // namespace stg
 
diff --git a/elf_reader.cc b/elf_reader.cc
index 2913007..384f856 100644
--- a/elf_reader.cc
+++ b/elf_reader.cc
@@ -191,23 +191,23 @@ namespace {
 
 class Reader {
  public:
-  Reader(Graph& graph, const std::string& path, ReadOptions options,
-         const std::unique_ptr<Filter>& file_filter, Metrics& metrics)
+  Reader(Runtime& runtime, Graph& graph, const std::string& path,
+         ReadOptions options, const std::unique_ptr<Filter>& file_filter)
       : graph_(graph),
         dwarf_(path),
         elf_(dwarf_.GetElf()),
         options_(options),
         file_filter_(file_filter),
-        metrics_(metrics) {}
+        runtime_(runtime) {}
 
-  Reader(Graph& graph, char* data, size_t size, ReadOptions options,
-         const std::unique_ptr<Filter>& file_filter, Metrics& metrics)
+  Reader(Runtime& runtime, Graph& graph, char* data, size_t size,
+         ReadOptions options, const std::unique_ptr<Filter>& file_filter)
       : graph_(graph),
         dwarf_(data, size),
         elf_(dwarf_.GetElf()),
         options_(options),
         file_filter_(file_filter),
-        metrics_(metrics) {}
+        runtime_(runtime) {}
 
   Id Read();
 
@@ -223,7 +223,7 @@ class Reader {
     // the nodes in consideration to the ones allocated by the DWARF processor
     // here and any symbol or type roots that follow. This is done by setting
     // the starting node ID to be the current graph limit.
-    Unification unification(graph_, graph_.Limit(), metrics_);
+    Unification unification(runtime_, graph_, graph_.Limit());
 
     const dwarf::Types types = dwarf::Process(
         dwarf_, elf_.IsLittleEndianBinary(), file_filter_, graph_);
@@ -289,7 +289,7 @@ class Reader {
     }
     roots.push_back(root);
 
-    stg::ResolveTypes(graph_, unification, {roots}, metrics_);
+    stg::ResolveTypes(runtime_, graph_, unification, {roots});
 
     unification.Update(root);
     return root;
@@ -392,7 +392,7 @@ class Reader {
   elf::ElfLoader elf_;
   ReadOptions options_;
   const std::unique_ptr<Filter>& file_filter_;
-  Metrics& metrics_;
+  Runtime& runtime_;
 };
 
 Id Reader::Read() {
@@ -437,14 +437,14 @@ Id Reader::Read() {
 }  // namespace
 }  // namespace internal
 
-Id Read(Graph& graph, const std::string& path, ReadOptions options,
-        const std::unique_ptr<Filter>& file_filter, Metrics& metrics) {
-  return internal::Reader(graph, path, options, file_filter, metrics).Read();
+Id Read(Runtime& runtime, Graph& graph, const std::string& path,
+        ReadOptions options, const std::unique_ptr<Filter>& file_filter) {
+  return internal::Reader(runtime, graph, path, options, file_filter).Read();
 }
 
-Id Read(Graph& graph, char* data, size_t size, ReadOptions options,
-        const std::unique_ptr<Filter>& file_filter, Metrics& metrics) {
-  return internal::Reader(graph, data, size, options, file_filter, metrics)
+Id Read(Runtime& runtime, Graph& graph, char* data, size_t size,
+        ReadOptions options, const std::unique_ptr<Filter>& file_filter) {
+  return internal::Reader(runtime, graph, data, size, options, file_filter)
       .Read();
 }
 
diff --git a/elf_reader.h b/elf_reader.h
index 12d5711..8cb702b 100644
--- a/elf_reader.h
+++ b/elf_reader.h
@@ -37,10 +37,10 @@
 namespace stg {
 namespace elf {
 
-Id Read(Graph& graph, const std::string& path, ReadOptions options,
-        const std::unique_ptr<Filter>& file_filter, Metrics& metrics);
-Id Read(Graph& graph, char* data, size_t size, ReadOptions options,
-        const std::unique_ptr<Filter>& file_filter, Metrics& metrics);
+Id Read(Runtime& runtime, Graph& graph, const std::string& path,
+        ReadOptions options, const std::unique_ptr<Filter>& file_filter);
+Id Read(Runtime& runtime, Graph& graph, char* data, size_t size,
+        ReadOptions options, const std::unique_ptr<Filter>& file_filter);
 
 // For unit tests only
 namespace internal {
diff --git a/equality_cache.h b/equality_cache.h
index 0b15b39..7eb9dbc 100644
--- a/equality_cache.h
+++ b/equality_cache.h
@@ -46,25 +46,25 @@ namespace stg {
 // Node hashes such as those generated by the Fingerprint function object may be
 // supplied to avoid equality testing when hashes differ.
 struct EqualityCache {
-  EqualityCache(const std::unordered_map<Id, HashValue>& hashes,
-                Metrics& metrics)
+  EqualityCache(Runtime& runtime,
+                const std::unordered_map<Id, HashValue>& hashes)
       : hashes(hashes),
-        query_count(metrics, "cache.query_count"),
-        query_equal_ids(metrics, "cache.query_equal_ids"),
-        query_unequal_hashes(metrics, "cache.query_unequal_hashes"),
-        query_equal_representatives(metrics,
+        query_count(runtime, "cache.query_count"),
+        query_equal_ids(runtime, "cache.query_equal_ids"),
+        query_unequal_hashes(runtime, "cache.query_unequal_hashes"),
+        query_equal_representatives(runtime,
                                     "cache.query_equal_representatives"),
-        query_inequality_found(metrics, "cache.query_inequality_found"),
-        query_not_found(metrics, "cache.query_not_found"),
-        find_halved(metrics, "cache.find_halved"),
-        union_known(metrics, "cache.union_known"),
-        union_rank_swap(metrics, "cache.union_rank_swap"),
-        union_rank_increase(metrics, "cache.union_rank_increase"),
-        union_rank_zero(metrics, "cache.union_rank_zero"),
-        union_unknown(metrics, "cache.union_unknown"),
-        disunion_known_hash(metrics, "cache.disunion_known_hash"),
-        disunion_known_inequality(metrics, "cache.disunion_known_inequality"),
-        disunion_unknown(metrics, "cache.disunion_unknown") {}
+        query_inequality_found(runtime, "cache.query_inequality_found"),
+        query_not_found(runtime, "cache.query_not_found"),
+        find_halved(runtime, "cache.find_halved"),
+        union_known(runtime, "cache.union_known"),
+        union_rank_swap(runtime, "cache.union_rank_swap"),
+        union_rank_increase(runtime, "cache.union_rank_increase"),
+        union_rank_zero(runtime, "cache.union_rank_zero"),
+        union_unknown(runtime, "cache.union_unknown"),
+        disunion_known_hash(runtime, "cache.disunion_known_hash"),
+        disunion_known_inequality(runtime, "cache.disunion_known_inequality"),
+        disunion_unknown(runtime, "cache.disunion_unknown") {}
 
   std::optional<bool> Query(const Pair& comparison) {
     ++query_count;
@@ -226,11 +226,11 @@ struct EqualityCache {
 };
 
 struct SimpleEqualityCache {
-  explicit SimpleEqualityCache(Metrics& metrics)
-      : query_count(metrics, "simple_cache.query_count"),
-        query_equal_ids(metrics, "simple_cache.query_equal_ids"),
-        query_known_equality(metrics, "simple_cache.query_known_equality"),
-        known_equality_inserts(metrics, "simple_cache.known_equality_inserts") {
+  explicit SimpleEqualityCache(Runtime& runtime)
+      : query_count(runtime, "simple_cache.query_count"),
+        query_equal_ids(runtime, "simple_cache.query_equal_ids"),
+        query_known_equality(runtime, "simple_cache.query_known_equality"),
+        known_equality_inserts(runtime, "simple_cache.known_equality_inserts") {
   }
 
   std::optional<bool> Query(const Pair& comparison) {
diff --git a/fingerprint.cc b/fingerprint.cc
index 8a8fc05..ef763c1 100644
--- a/fingerprint.cc
+++ b/fingerprint.cc
@@ -36,10 +36,11 @@ namespace stg {
 namespace {
 
 struct Hasher {
-  Hasher(const Graph& graph, std::unordered_map<Id, HashValue>& hashes,
-         std::unordered_set<Id>& todo, Metrics& metrics)
+  Hasher(Runtime& runtime, const Graph& graph,
+         std::unordered_map<Id, HashValue>& hashes,
+         std::unordered_set<Id>& todo)
       : graph(graph), hashes(hashes), todo(todo),
-        non_trivial_scc_size(metrics, "fingerprint.non_trivial_scc_size") {}
+        non_trivial_scc_size(runtime, "fingerprint.non_trivial_scc_size") {}
 
   // Graph function implementation
   HashValue operator()(const Special& x) {
@@ -219,11 +220,11 @@ struct Hasher {
 }  // namespace
 
 std::unordered_map<Id, HashValue> Fingerprint(
-    const Graph& graph, Id root, Metrics& metrics) {
-  const Time x(metrics, "hash nodes");
+    Runtime& runtime, const Graph& graph, Id root) {
+  const Time x(runtime, "hash nodes");
   std::unordered_map<Id, HashValue> hashes;
   std::unordered_set<Id> todo;
-  Hasher hasher(graph, hashes, todo, metrics);
+  Hasher hasher(runtime, graph, hashes, todo);
   todo.insert(root);
   while (!todo.empty()) {
     for (auto id : std::exchange(todo, {})) {
diff --git a/fingerprint.h b/fingerprint.h
index f5f8042..6d8f098 100644
--- a/fingerprint.h
+++ b/fingerprint.h
@@ -35,7 +35,7 @@ namespace stg {
 // Given any mutual dependencies between hashes, it falls back to a very poor
 // but safe hash for the affected nodes: the size of the SCC.
 std::unordered_map<Id, HashValue> Fingerprint(
-    const Graph& graph, Id root, Metrics& metrics);
+    Runtime& runtime, const Graph& graph, Id root);
 
 }  // namespace stg
 
diff --git a/fuzz/elf_reader_fuzzer.cc b/fuzz/elf_reader_fuzzer.cc
index 4134eac..751cfb4 100644
--- a/fuzz/elf_reader_fuzzer.cc
+++ b/fuzz/elf_reader_fuzzer.cc
@@ -33,11 +33,11 @@ extern "C" int LLVMFuzzerTestOneInput(char* data, size_t size) {
     // read and write access to memory.
     // Luckily, such trivial copy can be easily tracked by fuzzer.
     std::ostringstream os;
-    stg::Metrics metrics(os, false);
+    stg::Runtime runtime(os, false);
     stg::Graph graph;
     std::vector<char> data_copy(data, data + size);
-    stg::elf::Read(graph, data_copy.data(), size, stg::ReadOptions(), nullptr,
-                   metrics);
+    stg::elf::Read(runtime, graph, data_copy.data(), size, stg::ReadOptions(),
+                   nullptr);
   } catch (const stg::Exception&) {
     // Pass as this is us catching invalid ELF properly.
   }
diff --git a/input.cc b/input.cc
index 5f2595c..e100834 100644
--- a/input.cc
+++ b/input.cc
@@ -36,24 +36,24 @@ namespace stg {
 
 namespace {
 
-Id ReadInternal(Graph& graph, InputFormat format, const char* input,
-                ReadOptions options, const std::unique_ptr<Filter>& file_filter,
-                Metrics& metrics) {
+Id ReadInternal(Runtime& runtime, Graph& graph, InputFormat format,
+                const char* input, ReadOptions options,
+                const std::unique_ptr<Filter>& file_filter) {
   switch (format) {
     case InputFormat::ABI: {
-      const Time read(metrics, "read ABI");
-      return abixml::Read(graph, input, metrics);
+      const Time read(runtime, "read ABI");
+      return abixml::Read(runtime, graph, input);
     }
     case InputFormat::BTF: {
-      const Time read(metrics, "read BTF");
+      const Time read(runtime, "read BTF");
       return btf::ReadFile(graph, input, options);
     }
     case InputFormat::ELF: {
-      const Time read(metrics, "read ELF");
-      return elf::Read(graph, input, options, file_filter, metrics);
+      const Time read(runtime, "read ELF");
+      return elf::Read(runtime, graph, input, options, file_filter);
     }
     case InputFormat::STG: {
-      const Time read(metrics, "read STG");
+      const Time read(runtime, "read STG");
       return proto::Read(graph, input);
     }
   }
@@ -61,11 +61,10 @@ Id ReadInternal(Graph& graph, InputFormat format, const char* input,
 
 }  // namespace
 
-Id Read(Graph& graph, InputFormat format, const char* input,
-        ReadOptions options, const std::unique_ptr<Filter>& file_filter,
-        Metrics& metrics) {
+Id Read(Runtime& runtime, Graph& graph, InputFormat format, const char* input,
+        ReadOptions options, const std::unique_ptr<Filter>& file_filter) {
   try {
-    return ReadInternal(graph, format, input, options, file_filter, metrics);
+    return ReadInternal(runtime, graph, format, input, options, file_filter);
   } catch (Exception& e) {
     std::ostringstream os;
     os << "processing file '" << input << '\'';
diff --git a/input.h b/input.h
index 51894a2..558e987 100644
--- a/input.h
+++ b/input.h
@@ -31,9 +31,8 @@ namespace stg {
 
 enum class InputFormat { ABI, BTF, ELF, STG };
 
-Id Read(Graph& graph, InputFormat format, const char* input,
-        ReadOptions options, const std::unique_ptr<Filter>& file_filter,
-        Metrics& metrics);
+Id Read(Runtime& runtime, Graph& graph, InputFormat format, const char* input,
+        ReadOptions options, const std::unique_ptr<Filter>& file_filter);
 
 }  // namespace stg
 
diff --git a/metrics.cc b/metrics.cc
index a727d90..83be4b5 100644
--- a/metrics.cc
+++ b/metrics.cc
@@ -47,8 +47,8 @@ std::ostream& operator<<(std::ostream& os, const Nanoseconds& value) {
             << std::setfill(' ') << " ms";
 }
 
-Time::Time(Metrics& metrics, const char* name)
-    : metrics_(metrics), name_(name) {
+Time::Time(Runtime& runtime, const char* name)
+    : runtime_(runtime), name_(name) {
   clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &start_);
 }
 
@@ -58,23 +58,23 @@ Time::~Time() {
   const auto seconds = finish.tv_sec - start_.tv_sec;
   const auto nanos = finish.tv_nsec - start_.tv_nsec;
   const Nanoseconds value(seconds * 1'000'000'000 + nanos);
-  metrics_.PrintMetric(name_, value);
+  runtime_.PrintMetric(name_, value);
 }
 
-Counter::Counter(Metrics& metrics, const char* name)
-    : metrics_(metrics), name_(name), value_(0) {
+Counter::Counter(Runtime& runtime, const char* name)
+    : runtime_(runtime), name_(name), value_(0) {
 }
 
 Counter::~Counter() {
-  metrics_.PrintMetric(name_, value_);
+  runtime_.PrintMetric(name_, value_);
 }
 
-Histogram::Histogram(Metrics& metrics, const char* name)
-    : metrics_(metrics), name_(name) {
+Histogram::Histogram(Runtime& runtime, const char* name)
+    : runtime_(runtime), name_(name) {
 }
 
 Histogram::~Histogram() {
-  metrics_.PrintMetric(name_, frequencies_);
+  runtime_.PrintMetric(name_, frequencies_);
 }
 
 }  // namespace stg
diff --git a/metrics.h b/metrics.h
index 9207765..3a96c03 100644
--- a/metrics.h
+++ b/metrics.h
@@ -37,8 +37,8 @@ struct Frequencies {
   std::map<size_t, size_t> counts;
 };
 
-struct Metrics {
-  Metrics(std::ostream& output, bool print_metrics)
+struct Runtime {
+  Runtime(std::ostream& output, bool print_metrics)
       : output(output), print_metrics(print_metrics) {}
   template <typename V>
   void PrintMetric(const char* name, const V& value) {
@@ -54,20 +54,20 @@ struct Metrics {
 
 class Time {
  public:
-  Time(Metrics& metrics, const char* name);
+  Time(Runtime& runtime, const char* name);
   Time(Time&& other) = delete;
   Time& operator=(Time&& other) = delete;
   ~Time();
 
  private:
-  Metrics& metrics_;
+  Runtime& runtime_;
   const char* name_;
   struct timespec start_;
 };
 
 class Counter {
  public:
-  Counter(Metrics& metrics, const char* name);
+  Counter(Runtime& runtime, const char* name);
   Counter(Counter&& other) = delete;
   Counter& operator=(Counter&& other) = delete;
   ~Counter();
@@ -88,14 +88,14 @@ class Counter {
   }
 
  private:
-  Metrics& metrics_;
+  Runtime& runtime_;
   const char* name_;
   size_t value_;
 };
 
 class Histogram {
  public:
-  Histogram(Metrics& metrics, const char* name);
+  Histogram(Runtime& runtime, const char* name);
   Histogram(Histogram&& other) = delete;
   Histogram& operator=(Histogram&& other) = delete;
   ~Histogram();
@@ -105,7 +105,7 @@ class Histogram {
   }
 
  private:
-  Metrics& metrics_;
+  Runtime& runtime_;
   const char* name_;
   Frequencies frequencies_;
 };
diff --git a/metrics_test.cc b/metrics_test.cc
index 6bcfa7b..37c967b 100644
--- a/metrics_test.cc
+++ b/metrics_test.cc
@@ -31,7 +31,7 @@ namespace Test {
 TEST_CASE("empty") {
   std::ostringstream os;
   {
-    const stg::Metrics metrics(os, true);
+    const stg::Runtime runtime(os, true);
   }
   CHECK(os.str().empty());
 }
@@ -40,28 +40,28 @@ TEST_CASE("times") {
   const size_t count = 20;
   std::ostringstream os;
   {
-    stg::Metrics metrics(os, true);
+    stg::Runtime runtime(os, true);
     const std::array<const stg::Time, count> timers = {
-      stg::Time(metrics, "name"),
-      stg::Time(metrics, "name"),
-      stg::Time(metrics, "name"),
-      stg::Time(metrics, "name"),
-      stg::Time(metrics, "name"),
-      stg::Time(metrics, "name"),
-      stg::Time(metrics, "name"),
-      stg::Time(metrics, "name"),
-      stg::Time(metrics, "name"),
-      stg::Time(metrics, "name"),
-      stg::Time(metrics, "name"),
-      stg::Time(metrics, "name"),
-      stg::Time(metrics, "name"),
-      stg::Time(metrics, "name"),
-      stg::Time(metrics, "name"),
-      stg::Time(metrics, "name"),
-      stg::Time(metrics, "name"),
-      stg::Time(metrics, "name"),
-      stg::Time(metrics, "name"),
-      stg::Time(metrics, "name"),
+      stg::Time(runtime, "name"),
+      stg::Time(runtime, "name"),
+      stg::Time(runtime, "name"),
+      stg::Time(runtime, "name"),
+      stg::Time(runtime, "name"),
+      stg::Time(runtime, "name"),
+      stg::Time(runtime, "name"),
+      stg::Time(runtime, "name"),
+      stg::Time(runtime, "name"),
+      stg::Time(runtime, "name"),
+      stg::Time(runtime, "name"),
+      stg::Time(runtime, "name"),
+      stg::Time(runtime, "name"),
+      stg::Time(runtime, "name"),
+      stg::Time(runtime, "name"),
+      stg::Time(runtime, "name"),
+      stg::Time(runtime, "name"),
+      stg::Time(runtime, "name"),
+      stg::Time(runtime, "name"),
+      stg::Time(runtime, "name"),
     };
   }
   std::istringstream is(os.str());
@@ -90,12 +90,12 @@ TEST_CASE("times") {
 TEST_CASE("counters") {
   std::ostringstream os;
   {
-    stg::Metrics metrics(os, true);
-    stg::Counter a(metrics, "a");
-    stg::Counter b(metrics, "b");
-    stg::Counter c(metrics, "c");
-    const stg::Counter d(metrics, "d");
-    stg::Counter e(metrics, "e");
+    stg::Runtime runtime(os, true);
+    stg::Counter a(runtime, "a");
+    stg::Counter b(runtime, "b");
+    stg::Counter c(runtime, "c");
+    const stg::Counter d(runtime, "d");
+    stg::Counter e(runtime, "e");
     c = 17;
     ++b;
     ++b;
@@ -110,8 +110,8 @@ TEST_CASE("counters") {
 TEST_CASE("histogram") {
   std::ostringstream os;
   {
-    stg::Metrics metrics(os, true);
-    stg::Histogram h(metrics, "h");
+    stg::Runtime runtime(os, true);
+    stg::Histogram h(runtime, "h");
     h.Add(13);
     h.Add(14);
     h.Add(13);
diff --git a/stg.cc b/stg.cc
index 74a8cd6..cee6f4c 100644
--- a/stg.cc
+++ b/stg.cc
@@ -55,10 +55,10 @@ struct GetInterface {
   }
 };
 
-Id Merge(Graph& graph, const std::vector<Id>& roots, Metrics& metrics) {
+Id Merge(Runtime& runtime, Graph& graph, const std::vector<Id>& roots) {
   bool failed = false;
   // this rewrites the graph on destruction
-  Unification unification(graph, Id(0), metrics);
+  Unification unification(runtime, graph, Id(0));
   unification.Reserve(graph.Limit());
   std::map<std::string, Id> symbols;
   std::map<std::string, Id> types;
@@ -99,10 +99,10 @@ void FilterSymbols(Graph& graph, Id root, const Filter& filter) {
   std::swap(interface.symbols, symbols);
 }
 
-void Write(const Graph& graph, Id root, const char* output, Metrics& metrics) {
+void Write(Runtime& runtime, const Graph& graph, Id root, const char* output) {
   std::ofstream os(output);
   {
-    const Time x(metrics, "write");
+    const Time x(runtime, "write");
     proto::Writer writer(graph);
     writer.Write(root, os);
     os << std::flush;
@@ -204,30 +204,30 @@ int main(int argc, char* argv[]) {
 
   try {
     stg::Graph graph;
-    stg::Metrics metrics(std::cerr, opt_metrics);
+    stg::Runtime runtime(std::cerr, opt_metrics);
     std::vector<stg::Id> roots;
     roots.reserve(inputs.size());
     for (auto& [format, input] : inputs) {
-      roots.push_back(stg::Read(graph, format, input, opt_read_options,
-                                opt_file_filter, metrics));
+      roots.push_back(stg::Read(runtime, graph, format, input, opt_read_options,
+                                opt_file_filter));
     }
     stg::Id root =
-        roots.size() == 1 ? roots[0] : stg::Merge(graph, roots, metrics);
+        roots.size() == 1 ? roots[0] : stg::Merge(runtime, graph, roots);
     if (opt_symbol_filter) {
       stg::FilterSymbols(graph, root, *opt_symbol_filter);
     }
     if (!opt_keep_duplicates) {
       {
-        stg::Unification unification(graph, stg::Id(0), metrics);
+        stg::Unification unification(runtime, graph, stg::Id(0));
         unification.Reserve(graph.Limit());
-        stg::ResolveTypes(graph, unification, {root}, metrics);
+        stg::ResolveTypes(runtime, graph, unification, {root});
         unification.Update(root);
       }
-      const auto hashes = stg::Fingerprint(graph, root, metrics);
-      root = stg::Deduplicate(graph, root, hashes, metrics);
+      const auto hashes = stg::Fingerprint(runtime, graph, root);
+      root = stg::Deduplicate(runtime, graph, root, hashes);
     }
     for (auto output : outputs) {
-      stg::Write(graph, root, output, metrics);
+      stg::Write(runtime, graph, root, output);
     }
     return 0;
   } catch (const stg::Exception& e) {
diff --git a/stgdiff.cc b/stgdiff.cc
index 0db51a3..13606e9 100644
--- a/stgdiff.cc
+++ b/stgdiff.cc
@@ -52,12 +52,12 @@ using Inputs = std::vector<std::pair<stg::InputFormat, const char*>>;
 using Outputs =
     std::vector<std::pair<stg::reporting::OutputFormat, const char*>>;
 
-std::vector<stg::Id> Read(const Inputs& inputs, stg::Graph& graph,
-                          stg::ReadOptions options, stg::Metrics& metrics) {
+std::vector<stg::Id> Read(stg::Runtime& runtime, const Inputs& inputs,
+                          stg::Graph& graph, stg::ReadOptions options) {
   std::vector<stg::Id> roots;
   for (const auto& [format, filename] : inputs) {
-    roots.push_back(stg::Read(graph, format, filename, options, nullptr,
-                              metrics));
+    roots.push_back(stg::Read(runtime, graph, format, filename, options,
+                              nullptr));
   }
   return roots;
 }
@@ -76,10 +76,10 @@ int RunFidelity(const char* filename, const stg::Graph& graph,
   return diffs_reported ? kFidelityChange : 0;
 }
 
-int RunExact(const Inputs& inputs, stg::ReadOptions options,
-             stg::Metrics& metrics) {
+int RunExact(stg::Runtime& runtime, const Inputs& inputs,
+             stg::ReadOptions options) {
   stg::Graph graph;
-  const auto roots = Read(inputs, graph, options, metrics);
+  const auto roots = Read(runtime, inputs, graph, options);
 
   struct PairCache {
     std::optional<bool> Query(const stg::Pair& comparison) const {
@@ -96,25 +96,25 @@ int RunExact(const Inputs& inputs, stg::ReadOptions options,
     std::unordered_set<stg::Pair> equalities;
   };
 
-  const stg::Time compute(metrics, "equality check");
+  const stg::Time compute(runtime, "equality check");
   PairCache equalities;
   return stg::Equals<PairCache>(graph, equalities)(roots[0], roots[1])
              ? 0
              : kAbiChange;
 }
 
-int Run(const Inputs& inputs, const Outputs& outputs, stg::Ignore ignore,
-        stg::ReadOptions options, std::optional<const char*> fidelity,
-        stg::Metrics& metrics) {
+int Run(stg::Runtime& runtime, const Inputs& inputs, const Outputs& outputs,
+        stg::Ignore ignore, stg::ReadOptions options,
+        std::optional<const char*> fidelity) {
   // Read inputs.
   stg::Graph graph;
-  const auto roots = Read(inputs, graph, options, metrics);
+  const auto roots = Read(runtime, inputs, graph, options);
 
   // Compute differences.
-  stg::Compare compare{graph, ignore, metrics};
+  stg::Compare compare{runtime, graph, ignore};
   std::pair<bool, std::optional<stg::Comparison>> result;
   {
-    const stg::Time compute(metrics, "compute diffs");
+    const stg::Time compute(runtime, "compute diffs");
     result = compare(roots[0], roots[1]);
   }
   stg::Check(compare.scc.Empty()) << "internal error: SCC state broken";
@@ -126,7 +126,7 @@ int Run(const Inputs& inputs, const Outputs& outputs, stg::Ignore ignore,
   for (const auto& [format, filename] : outputs) {
     std::ofstream output(filename);
     if (comparison) {
-      const stg::Time report(metrics, "report diffs");
+      const stg::Time report(runtime, "report diffs");
       const stg::reporting::Options options{format, kMaxCrcOnlyChanges};
       const stg::reporting::Reporting reporting{graph, compare.outcomes,
         options, names};
@@ -140,7 +140,7 @@ int Run(const Inputs& inputs, const Outputs& outputs, stg::Ignore ignore,
 
   // Compute fidelity diff if requested.
   if (fidelity) {
-    const stg::Time report(metrics, "fidelity");
+    const stg::Time report(runtime, "fidelity");
     status |= RunFidelity(*fidelity, graph, roots);
   }
 
@@ -263,10 +263,10 @@ int main(int argc, char* argv[]) {
   }
 
   try {
-    stg::Metrics metrics(std::cerr, opt_metrics);
-    return opt_exact ? RunExact(inputs, opt_read_options, metrics)
-                     : Run(inputs, outputs, opt_ignore, opt_read_options,
-                           opt_fidelity, metrics);
+    stg::Runtime runtime(std::cerr, opt_metrics);
+    return opt_exact ? RunExact(runtime, inputs, opt_read_options)
+                     : Run(runtime, inputs, outputs, opt_ignore,
+                           opt_read_options, opt_fidelity);
   } catch (const stg::Exception& e) {
     std::cerr << e.what();
     return 1;
diff --git a/stgdiff_test.cc b/stgdiff_test.cc
index 7c61dc4..383af97 100644
--- a/stgdiff_test.cc
+++ b/stgdiff_test.cc
@@ -47,10 +47,10 @@ std::string filename_to_path(const std::string& f) {
   return std::filesystem::path("testdata") / f;
 }
 
-stg::Id Read(stg::Graph& graph, stg::InputFormat format,
-             const std::string& input, stg::Metrics& metrics) {
-  return stg::Read(graph, format, filename_to_path(input).c_str(),
-                   stg::ReadOptions(), nullptr, metrics);
+stg::Id Read(stg::Runtime& runtime, stg::Graph& graph, stg::InputFormat format,
+             const std::string& input) {
+  return stg::Read(runtime, graph, format, filename_to_path(input).c_str(),
+                   stg::ReadOptions(), nullptr);
 }
 
 TEST_CASE("ignore") {
@@ -239,15 +239,15 @@ TEST_CASE("ignore") {
 
   SECTION(test.name) {
     std::ostringstream os;
-    stg::Metrics metrics(os, false);
+    stg::Runtime runtime(os, false);
 
     // Read inputs.
     stg::Graph graph;
-    const auto id0 = Read(graph, test.format0, test.file0, metrics);
-    const auto id1 = Read(graph, test.format1, test.file1, metrics);
+    const auto id0 = Read(runtime, graph, test.format0, test.file0);
+    const auto id1 = Read(runtime, graph, test.format1, test.file1);
 
     // Compute differences.
-    stg::Compare compare{graph, test.ignore, metrics};
+    stg::Compare compare{runtime, graph, test.ignore};
     const auto& [equals, comparison] = compare(id0, id1);
 
     // Write SMALL reports.
@@ -294,15 +294,15 @@ TEST_CASE("short report") {
 
   SECTION(test.name) {
     std::ostringstream os;
-    stg::Metrics metrics(os, false);
+    stg::Runtime runtime(os, false);
 
     // Read inputs.
     stg::Graph graph;
-    const auto id0 = Read(graph, stg::InputFormat::ABI, test.xml0, metrics);
-    const auto id1 = Read(graph, stg::InputFormat::ABI, test.xml1, metrics);
+    const auto id0 = Read(runtime, graph, stg::InputFormat::ABI, test.xml0);
+    const auto id1 = Read(runtime, graph, stg::InputFormat::ABI, test.xml1);
 
     // Compute differences.
-    stg::Compare compare{graph, {}, metrics};
+    stg::Compare compare{runtime, graph, {}};
     const auto& [equals, comparison] = compare(id0, id1);
 
     // Write SHORT reports.
@@ -326,14 +326,14 @@ TEST_CASE("short report") {
 
 TEST_CASE("fidelity diff") {
   std::ostringstream os;
-  stg::Metrics metrics(os, false);
+  stg::Runtime runtime(os, false);
 
   // Read inputs.
   stg::Graph graph;
   const auto id0 =
-      Read(graph, stg::InputFormat::STG, "fidelity_diff_0.stg", metrics);
+      Read(runtime, graph, stg::InputFormat::STG, "fidelity_diff_0.stg");
   const auto id1 =
-      Read(graph, stg::InputFormat::STG, "fidelity_diff_1.stg", metrics);
+      Read(runtime, graph, stg::InputFormat::STG, "fidelity_diff_1.stg");
 
   // Compute fidelity diff.
   auto fidelity_diff = stg::GetFidelityTransitions(graph, id0, id1);
diff --git a/type_resolution.cc b/type_resolution.cc
index b32d535..9f7c715 100644
--- a/type_resolution.cc
+++ b/type_resolution.cc
@@ -35,13 +35,13 @@ namespace {
 
 // Collect named type definition and declaration nodes.
 struct NamedTypes {
-  NamedTypes(const Graph& graph, Metrics& metrics)
+  NamedTypes(Runtime& runtime, const Graph& graph)
       : graph(graph),
         seen(Id(0)),
-        nodes(metrics, "named_types.nodes"),
-        types(metrics, "named_types.types"),
-        definitions(metrics, "named_types.definitions"),
-        declarations(metrics, "named_types.declarations") {
+        nodes(runtime, "named_types.nodes"),
+        types(runtime, "named_types.types"),
+        definitions(runtime, "named_types.definitions"),
+        declarations(runtime, "named_types.declarations") {
     seen.Reserve(graph.Limit());
   }
 
@@ -184,24 +184,24 @@ struct NamedTypes {
 
 }  // namespace
 
-void ResolveTypes(Graph& graph, Unification& unification,
-                  const std::vector<Id>& roots, Metrics& metrics) {
-  const Time total(metrics, "resolve.total");
+void ResolveTypes(Runtime& runtime, Graph& graph, Unification& unification,
+                  const std::vector<Id>& roots) {
+  const Time total(runtime, "resolve.total");
 
   // collect named types
-  NamedTypes named_types(graph, metrics);
+  NamedTypes named_types(runtime, graph);
   {
-    const Time time(metrics, "resolve.collection");
+    const Time time(runtime, "resolve.collection");
     for (const Id& root : roots) {
       named_types(root);
     }
   }
 
   {
-    const Time time(metrics, "resolve.unification");
-    Counter definition_unified(metrics, "resolve.definition.unified");
-    Counter definition_not_unified(metrics, "resolve.definition.not_unified");
-    Counter declaration_unified(metrics, "resolve.declaration.unified");
+    const Time time(runtime, "resolve.unification");
+    Counter definition_unified(runtime, "resolve.definition.unified");
+    Counter definition_not_unified(runtime, "resolve.definition.not_unified");
+    Counter declaration_unified(runtime, "resolve.declaration.unified");
     for (auto& [_, info] : named_types.type_info) {
       // try to unify the type definitions
       auto& definitions = info.definitions;
diff --git a/type_resolution.h b/type_resolution.h
index 326b241..7caf837 100644
--- a/type_resolution.h
+++ b/type_resolution.h
@@ -28,8 +28,8 @@
 
 namespace stg {
 
-void ResolveTypes(Graph& graph, Unification& unification,
-                  const std::vector<Id>& roots, Metrics& metrics);
+void ResolveTypes(Runtime& runtime, Graph& graph, Unification& unification,
+                  const std::vector<Id>& roots);
 
 }  // namespace stg
 
diff --git a/unification.h b/unification.h
index 3f6ee9a..e0c6f07 100644
--- a/unification.h
+++ b/unification.h
@@ -34,15 +34,15 @@ namespace stg {
 // destruction.
 class Unification {
  public:
-  Unification(Graph& graph, Id start, Metrics& metrics)
+  Unification(Runtime& runtime, Graph& graph, Id start)
       : graph_(graph),
         start_(start),
         mapping_(start),
-        metrics_(metrics),
-        find_query_(metrics, "unification.find_query"),
-        find_halved_(metrics, "unification.find_halved"),
-        union_known_(metrics, "unification.union_known"),
-        union_unknown_(metrics, "unification.union_unknown") {}
+        runtime_(runtime),
+        find_query_(runtime, "unification.find_query"),
+        find_halved_(runtime, "unification.find_halved"),
+        union_known_(runtime, "unification.union_known"),
+        union_unknown_(runtime, "unification.union_unknown") {}
 
   ~Unification() {
     if (std::uncaught_exceptions() > 0) {
@@ -50,9 +50,9 @@ class Unification {
       return;
     }
     // apply substitutions to the entire graph
-    const Time time(metrics_, "unification.rewrite");
-    Counter removed(metrics_, "unification.removed");
-    Counter retained(metrics_, "unification.retained");
+    const Time time(runtime_, "unification.rewrite");
+    Counter removed(runtime_, "unification.removed");
+    Counter retained(runtime_, "unification.retained");
     auto remap = [&](Id& id) {
       Update(id);
     };
@@ -118,7 +118,7 @@ class Unification {
   Graph& graph_;
   Id start_;
   DenseIdMapping mapping_;
-  Metrics& metrics_;
+  Runtime& runtime_;
   Counter find_query_;
   Counter find_halved_;
   Counter union_known_;