ernie-renderer 0.2.0.dev16__tar.gz → 0.2.0.dev20__tar.gz

{ernie_renderer-0.2.0.dev16 → ernie_renderer-0.2.0.dev20}/.github/workflows/ci.yml

@@ -96,7 +96,7 @@ jobs:
       - name: Build
         run: cmake --build --preset ci --parallel 4
       # The installed library used as end users use it: its headers compile alone and a program
-      # links and runs against it (QA-072). Windows finds ernie.dll on the PATH.
+      # links and runs against it. Windows finds ernie.dll on the PATH.
       - name: Install and build a consumer
         shell: bash
         run: |

{ernie_renderer-0.2.0.dev16 → ernie_renderer-0.2.0.dev20}/CMakeLists.txt

@@ -15,10 +15,11 @@ project(
 )
 
 # Pre-release suffix such as .dev12, written by CI.
-set(ERNIE_VERSION_SUFFIX ".dev16" CACHE STRING "Pre-release suffix of Ernie's version")
+set(ERNIE_VERSION_SUFFIX ".dev20" CACHE STRING "Pre-release suffix of Ernie's version")
 set(ERNIE_VERSION "${PROJECT_VERSION}${ERNIE_VERSION_SUFFIX}")
 
 option(ERNIE_BUILD_TESTS "Build Ernie's tests" OFF)
+option(ERNIE_BUILD_BENCHMARKS "Build Ernie's benchmarks" OFF)
 option(ERNIE_BUILD_PYTHON "Build Ernie's Python module" OFF)
 option(ERNIE_BUILD_APP "Build the ernie program" ON)
 option(ERNIE_WARNINGS_AS_ERRORS "Treat compiler warnings as errors" OFF)
@@ -110,6 +111,9 @@ if(ERNIE_BUILD_TESTS)
     enable_testing()
     add_subdirectory(tests)
 endif()
+if(ERNIE_BUILD_BENCHMARKS)
+    add_subdirectory(benchmarks)
+endif()
 
 if(PROJECT_IS_TOP_LEVEL AND NOT SKBUILD)
     include(cmake/ErniePackaging.cmake)

{ernie_renderer-0.2.0.dev16 → ernie_renderer-0.2.0.dev20}/CMakePresets.json

@@ -15,6 +15,7 @@
       "cacheVariables": {
         "CMAKE_BUILD_TYPE": "RelWithDebInfo",
         "ERNIE_BUILD_TESTS": "ON",
+        "ERNIE_BUILD_BENCHMARKS": "ON",
         "ERNIE_BUILD_PYTHON": "ON",
         "ERNIE_BUILD_APP": "ON"
       }

{ernie_renderer-0.2.0.dev16 → ernie_renderer-0.2.0.dev20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ernie-renderer
-Version: 0.2.0.dev16
+Version: 0.2.0.dev20
 Summary: Efficient Renderer for Natural and Interplanetary Environments: a physically based, spectral Vulkan ray tracer
 Author: Alex Maietta
 License-Expression: BSD-3-Clause

ernie_renderer-0.2.0.dev20/benchmarks/CMakeLists.txt

@@ -0,0 +1,3 @@
+# SPDX-License-Identifier: BSD-3-Clause
+add_executable(ernie_benchmarks main.cpp scene/storage.cpp)
+target_link_libraries(ernie_benchmarks PRIVATE ernie_static ernie_build_options)

ernie_renderer-0.2.0.dev20/benchmarks/bench.h

@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file bench.h
+/// @brief Registering and timing benchmarks, which report against a target and never fail on time.
+#pragma once
+
+#include <algorithm>
+#include <chrono>
+#include <functional>
+#include <string>
+#include <vector>
+
+namespace ernie::bench {
+
+/// What a benchmark measured: its fastest run and the time it aims for, in milliseconds.
+struct Timing {
+    double ms = 0.0;
+    double targetMs = 0.0;
+};
+
+struct Benchmark {
+    std::string name;
+    std::function<Timing()> run;
+};
+
+/// @return Every benchmark registered at static initialization.
+inline std::vector<Benchmark>& Registry() {
+    static std::vector<Benchmark> benchmarks;
+    return benchmarks;
+}
+
+/// Registers a benchmark from a namespace-scope `const bool`.
+inline bool Register(std::string name, std::function<Timing()> run) {
+    Registry().push_back({std::move(name), std::move(run)});
+    return true;
+}
+
+/// @brief Times `step` `runs` times, after `setup` before each, to see past a noisy machine.
+/// @return The fastest run, in milliseconds.
+template <typename Setup, typename Step>
+double Fastest(const Setup& setup, const Step& step, int runs = 5) {
+    double best = 1e30;
+    for (int run = 0; run < runs; ++run) {
+        setup();
+        const auto start = std::chrono::steady_clock::now();
+        step();
+        const auto elapsed = std::chrono::steady_clock::now() - start;
+        best = std::min(best, std::chrono::duration<double, std::milli>(elapsed).count());
+    }
+    return best;
+}
+
+}  // namespace ernie::bench

ernie_renderer-0.2.0.dev20/benchmarks/main.cpp

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file main.cpp
+/// @brief Runs the registered benchmarks whose names contain the first argument, and prints each
+/// fastest time beside its target.
+#include "benchmarks/bench.h"
+
+#include <cstdio>
+#include <string_view>
+
+int main(int argc, char** argv) {
+    const std::string_view filter = argc > 1 ? argv[1] : "";
+    std::printf("%-48s %12s %12s\n", "benchmark", "ms", "target ms");
+    for (const ernie::bench::Benchmark& benchmark : ernie::bench::Registry()) {
+        if (benchmark.name.find(filter) == std::string::npos) {
+            continue;
+        }
+        const ernie::bench::Timing timing = benchmark.run();
+        std::printf("%-48s %12.3f %12.3f%s\n", benchmark.name.c_str(), timing.ms, timing.targetMs,
+                    timing.ms > timing.targetMs ? "  over" : "");
+    }
+    return 0;
+}

ernie_renderer-0.2.0.dev20/benchmarks/scene/storage.cpp

@@ -0,0 +1,118 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file storage.cpp
+/// @brief The prim store at 100,000 prims: create, first sync, one edit, edit all, add and remove.
+#include "ernie/scene/storage.h"
+#include "benchmarks/bench.h"
+
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace ernie::bench {
+namespace {
+
+constexpr std::uint32_t kPrims = 100'000;
+
+/// 100,000 instanced robots, one per environment, with transforms.
+struct Robots {
+    std::unique_ptr<PrimStore> store;
+    AttributeId transform = 0;
+    BucketId bucket = 0;
+    std::vector<PrimId> prims;
+
+    void Reset() {
+        store = std::make_unique<PrimStore>();
+        transform = store->Tokens().Intern("xformOp:transform");
+        bucket = store->AddBucket(
+            {store->Tokens().Intern("Xform"), {}},
+            std::vector<ColumnLayout>{ColumnLayout::Of<glm::dmat4>(transform, glm::dmat4(1.0))});
+        prims.clear();
+    }
+
+    void Create() {
+        PathTable& paths = store->Paths();
+        const PathId world = paths.Child(kRootPath, "World");
+        const Token robot = store->Tokens().Intern("robot");
+        std::vector<PathId> robots(kPrims);
+        paths.Reserve(2 * kPrims);
+        for (std::uint32_t i = 0; i < kPrims; ++i) {
+            robots[i] = paths.Child(paths.Child(world, "env_" + std::to_string(i)), robot);
+        }
+        prims = store->DefineMany(robots, bucket);
+        const std::span<glm::dmat4> transforms = store->Write<glm::dmat4>(bucket, transform);
+        for (std::uint32_t i = 0; i < kPrims; ++i) {
+            transforms[i] = glm::dmat4(1.0);
+            transforms[i][3] = glm::dvec4(i, 0.0, 0.0, 1.0);
+        }
+    }
+
+    void Fresh() {
+        Reset();
+        Create();
+    }
+};
+
+const bool kCreate = Register("scene.storage.create_100k", [] {
+    Robots robots;
+    return Timing{Fastest([&] { robots.Reset(); }, [&] { robots.Create(); }), 50.0};
+});
+
+const bool kFirstSync = Register("scene.storage.first_sync_100k", [] {
+    Robots robots;
+    return Timing{Fastest([&] { robots.Fresh(); }, [&] { robots.store->ChangesSince(0); }), 50.0};
+});
+
+const bool kOneEdit = Register("scene.storage.one_edit_of_100k", [] {
+    Robots robots;
+    robots.Fresh();
+    std::uint64_t cursor = 0;
+    const double ms =
+        Fastest([&] { cursor = robots.store->Version(); },
+                [&] {
+                    robots.store->Set(robots.prims[54'321], robots.transform, glm::dmat4(2.0));
+                    robots.store->ChangesSince(cursor);
+                });
+    return Timing{ms, 1.0};
+});
+
+const bool kEditAll = Register("scene.storage.edit_all_100k", [] {
+    Robots robots;
+    robots.Fresh();
+    std::uint64_t cursor = 0;
+    const double ms = Fastest([&] { cursor = robots.store->Version(); },
+                              [&] {
+                                  for (glm::dmat4& transform : robots.store->Write<glm::dmat4>(
+                                           robots.bucket, robots.transform)) {
+                                      transform[3].y += 1.0;
+                                  }
+                                  robots.store->ChangesSince(cursor);
+                              });
+    return Timing{ms, 10.0};
+});
+
+const bool kAddRemove = Register("scene.storage.add_remove_1000_of_100k", [] {
+    Robots robots;
+    std::uint64_t cursor = 0;
+    const double ms = Fastest(
+        [&] {
+            robots.Fresh();
+            cursor = robots.store->Version();
+        },
+        [&] {
+            for (std::uint32_t i = 0; i < 1000; ++i) {
+                robots.store->Remove(robots.prims[i * 97]);
+            }
+            PathTable& paths = robots.store->Paths();
+            const PathId spawned = paths.Child(kRootPath, "Spawned");
+            std::vector<PathId> added(1000);
+            for (std::uint32_t i = 0; i < 1000; ++i) {
+                added[i] = paths.Child(spawned, "p" + std::to_string(i));
+            }
+            robots.store->DefineMany(added, robots.bucket);
+            robots.store->ChangesSince(cursor);
+        });
+    return Timing{ms, 5.0};
+});
+
+}  // namespace
+}  // namespace ernie::bench

{ernie_renderer-0.2.0.dev16 → ernie_renderer-0.2.0.dev20}/cmake/ErnieTesting.cmake

@@ -4,7 +4,7 @@ include_guard(GLOBAL)
 include("${CMAKE_CURRENT_LIST_DIR}/third_party/googletest.cmake")
 include(GoogleTest)
 
-# Hard timeouts per label; the time budgets tests aim for are far smaller.
+# Hard timeouts per label, to catch hangs; timings are tracked by benchmarks/.
 set(ERNIE_TEST_TIMEOUT_unit 10)
 set(ERNIE_TEST_TIMEOUT_gpu 60)
 set(ERNIE_TEST_TIMEOUT_accuracy 120)

{ernie_renderer-0.2.0.dev16 → ernie_renderer-0.2.0.dev20}/ernie/CMakeLists.txt

@@ -22,6 +22,7 @@ set_target_properties(
 
 # One object library per layer; a layer links only the layers below it.
 add_subdirectory(util)
+add_subdirectory(geometry)
 add_subdirectory(physics)
 add_subdirectory(io)
 add_subdirectory(scene)
@@ -31,6 +32,7 @@ add_subdirectory(render)
 
 set(ernie_layers
     ernie_util
+    ernie_geometry
     ernie_physics
     ernie_io
     ernie_scene
@@ -54,12 +56,8 @@ if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
     target_link_options(ernie PRIVATE "LINKER:--exclude-libs,ALL")
 endif()
 
-# The same objects as one static library, for in-tree programs and tests, which may also reach
-# internal APIs, and for the Python module, which carries everything itself.
 add_library(ernie_static STATIC)
 target_link_libraries(ernie_static PUBLIC ${ernie_layers})
-# Its objects export the API (ERNIE_API), so on Windows every program linking it would also write
-# an import library; the ernie program's would collide with libernie's own ernie.lib and ernie.exp.
 target_link_options(ernie_static INTERFACE "$<$<CXX_COMPILER_ID:MSVC>:/NOIMPLIB;/NOEXP>")
 
 if(ERNIE_BUILD_APP)

ernie_renderer-0.2.0.dev20/ernie/geometry/CMakeLists.txt

@@ -0,0 +1,3 @@
+# SPDX-License-Identifier: BSD-3-Clause
+add_library(ernie_geometry INTERFACE)
+target_link_libraries(ernie_geometry INTERFACE ernie_util)

ernie_renderer-0.2.0.dev20/ernie/geometry/bounds.h

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file bounds.h
+/// @brief Axis-aligned boxes in double precision.
+#pragma once
+
+#include <glm/glm.hpp>
+
+#include <cmath>
+#include <limits>
+
+namespace ernie {
+
+/// @brief An axis-aligned box; the default one is empty and grows to hold what it is given.
+struct Box {
+    glm::dvec3 min{std::numeric_limits<double>::infinity()};
+    glm::dvec3 max{-std::numeric_limits<double>::infinity()};
+
+    static Box Around(const glm::dvec3& center, const glm::dvec3& halfSize) {
+        return {center - halfSize, center + halfSize};
+    }
+
+    bool Empty() const {
+        return !(min.x <= max.x && min.y <= max.y && min.z <= max.z);
+    }
+    glm::dvec3 Center() const {
+        return 0.5 * (min + max);
+    }
+    glm::dvec3 Size() const {
+        return Empty() ? glm::dvec3(0.0) : max - min;
+    }
+
+    Box& Extend(const glm::dvec3& point) {
+        min = glm::min(min, point);
+        max = glm::max(max, point);
+        return *this;
+    }
+    Box& Extend(const Box& other) {
+        if (!other.Empty()) {
+            min = glm::min(min, other.min);
+            max = glm::max(max, other.max);
+        }
+        return *this;
+    }
+    Box Grown(double margin) const {
+        return Empty() ? *this : Box{min - margin, max + margin};
+    }
+
+    /// @return The box holding this one after `transform` (Arvo's method, exact for affine maps).
+    Box Transformed(const glm::dmat4& transform) const {
+        if (Empty()) {
+            return *this;
+        }
+        const glm::dvec3 translation(transform[3]);
+        Box out{translation, translation};
+        for (int column = 0; column < 3; ++column) {
+            for (int row = 0; row < 3; ++row) {
+                const double a = transform[column][row] * min[column];
+                const double b = transform[column][row] * max[column];
+                out.min[row] += std::min(a, b);
+                out.max[row] += std::max(a, b);
+            }
+        }
+        return out;
+    }
+
+    bool operator==(const Box&) const = default;
+};
+
+}  // namespace ernie

{ernie_renderer-0.2.0.dev16 → ernie_renderer-0.2.0.dev20}/ernie/io/CMakeLists.txt

@@ -10,7 +10,7 @@ add_library(
 )
 target_link_libraries(
     ernie_io
-    PUBLIC ernie_util
+    PUBLIC ernie_geometry
     PRIVATE
         ernie_build_options
         ernie_basisu

{ernie_renderer-0.2.0.dev16 → ernie_renderer-0.2.0.dev20}/ernie/io/nanovdb.cpp

@@ -222,22 +222,12 @@ bool NanoVdbGrid::Vector() const {
     return type == NanoVdbType::Vec3f;
 }
 
-void NanoVdbGrid::GridBounds(glm::dvec3& min, glm::dvec3& max) const {
-    min = glm::dvec3(std::numeric_limits<double>::infinity());
-    max = -min;
+Box NanoVdbGrid::GridBounds() const {
     if (Empty()) {
-        min = max = glm::dvec3(indexToGrid[3]);
-        return;
-    }
-    const glm::dvec3 lo = glm::dvec3(indexMin) - 1.0;
-    const glm::dvec3 hi = glm::dvec3(indexMax) + 1.0;
-    for (int corner = 0; corner < 8; ++corner) {
-        const glm::dvec3 index{(corner & 1) != 0 ? hi.x : lo.x, (corner & 2) != 0 ? hi.y : lo.y,
-                               (corner & 4) != 0 ? hi.z : lo.z};
-        const glm::dvec3 point = glm::dvec3(indexToGrid * glm::dvec4(index, 1.0));
-        min = glm::min(min, point);
-        max = glm::max(max, point);
+        const glm::dvec3 origin(indexToGrid[3]);
+        return {origin, origin};
     }
+    return Box{glm::dvec3(indexMin) - 1.0, glm::dvec3(indexMax) + 1.0}.Transformed(indexToGrid);
 }
 
 std::vector<NanoVdbGrid> ParseNanoVdbGrids(std::span<const std::uint8_t> bytes) {

{ernie_renderer-0.2.0.dev16 → ernie_renderer-0.2.0.dev20}/ernie/io/nanovdb.h

@@ -3,6 +3,8 @@
 /// @brief NanoVDB grids: reading .nvdb/.vdb files and building grids.
 #pragma once
 
+#include "ernie/geometry/bounds.h"
+
 #include <glm/glm.hpp>
 
 #include <cstdint>
@@ -79,11 +81,9 @@ struct NanoVdbGrid {
     bool Scalar() const;
     /// @return Whether volumes sample a 3-vector per voxel.
     bool Vector() const;
-    /// @brief Active bounds in the grid frame, grown by a voxel on
-    /// each side for trilinear sampling.
-    /// @param min Receives the lower corner.
-    /// @param max Receives the upper corner.
-    void GridBounds(glm::dvec3& min, glm::dvec3& max) const;
+    /// @return Active bounds in the grid frame, grown by a voxel on each side for trilinear
+    /// sampling; the grid's origin when it has no active voxels.
+    Box GridBounds() const;
 };
 
 /// @brief Reads every grid of a NanoVDB file, in file order.

{ernie_renderer-0.2.0.dev16 → ernie_renderer-0.2.0.dev20}/ernie/physics/cloud.cpp

@@ -491,8 +491,7 @@ CloudTransportTable SimulateCloudTransport(const DropletPhaseTable& phase,
     ParallelFor(shape.lightCosines * shape.thicknesses, [&](std::size_t job) {
         const std::size_t light = job % shape.lightCosines;
         const std::size_t thickness = shape.thicknesses - 1 - job / shape.lightCosines;
-        const std::uint64_t seed =
-            options.seed * 0x100000001b3ull + static_cast<std::uint64_t>(job) * 0x9e3779b9ull;
+        const std::uint64_t seed = HashCombine(options.seed, job);
         const SlabTallies tallies =
             SimulateSlab(shape, sampler, light, thickness, options.photons, seed);
         StoreSlab(tallies, light, thickness, options.photons, table);

ernie_renderer-0.2.0.dev20/ernie/scene/CMakeLists.txt

@@ -0,0 +1,3 @@
+# SPDX-License-Identifier: BSD-3-Clause
+add_library(ernie_scene OBJECT path.cpp storage.cpp)
+target_link_libraries(ernie_scene PUBLIC ernie_physics ernie_io PRIVATE ernie_build_options)

ernie_renderer-0.2.0.dev20/ernie/scene/path.cpp

@@ -0,0 +1,193 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file path.cpp
+/// @brief Path parsing, token interning and the path table.
+#include "ernie/scene/path.h"
+
+#include "ernie/util/random.h"
+#include "ernie/util/text.h"
+
+#include <algorithm>
+#include <stdexcept>
+
+namespace ernie {
+
+namespace {
+
+/// Calls `visit(name)` for each name of an absolute path's text; "/a/" ends in an empty name.
+template <typename Visit> void ForEachName(std::string_view text, const Visit& visit) {
+    if (text.size() <= 1) {
+        return;
+    }
+    for (std::size_t start = 1; start <= text.size();) {
+        const std::size_t end = std::min(text.find('/', start), text.size());
+        visit(text.substr(start, end - start));
+        start = end + 1;
+    }
+}
+
+}  // namespace
+
+bool Path::IsValidName(std::string_view name) {
+    return IsIdentifier(name);
+}
+
+Path::Path(std::string_view text) {
+    if (text.empty() || text.front() != '/') {
+        throw std::invalid_argument("Prim path '" + std::string(text) + "' is not absolute");
+    }
+    ForEachName(text, [&](std::string_view name) {
+        if (!IsValidName(name)) {
+            throw std::invalid_argument("Prim path '" + std::string(text) +
+                                        "' has an invalid name");
+        }
+    });
+    text_ = text;
+}
+
+Path Path::Root() {
+    return Path("/");
+}
+
+std::string_view Path::Name() const {
+    if (text_.size() <= 1) {
+        return {};
+    }
+    return std::string_view(text_).substr(text_.rfind('/') + 1);
+}
+
+Path Path::Parent() const {
+    if (text_.size() <= 1) {
+        return {};
+    }
+    const std::size_t slash = text_.rfind('/');
+    return slash == 0 ? Root() : Path(std::string_view(text_).substr(0, slash));
+}
+
+Path Path::Child(std::string_view name) const {
+    if (IsEmpty() || !IsValidName(name)) {
+        throw std::invalid_argument("Cannot append '" + std::string(name) + "' to '" + text_ + "'");
+    }
+    Path child;
+    child.text_ = IsRoot() ? "/" + std::string(name) : text_ + "/" + std::string(name);
+    return child;
+}
+
+bool Path::HasPrefix(const Path& ancestor) const {
+    if (ancestor.IsEmpty() || IsEmpty()) {
+        return false;
+    }
+    if (ancestor.IsRoot()) {
+        return true;
+    }
+    return text_.starts_with(ancestor.text_) &&
+           (text_.size() == ancestor.text_.size() || text_[ancestor.text_.size()] == '/');
+}
+
+TokenTable::TokenTable() {
+    Intern("");
+}
+
+Token TokenTable::Intern(std::string_view text) {
+    const auto next = static_cast<Token>(texts_.size());
+    const Token token = index_.Insert(std::hash<std::string_view>()(text), next,
+                                      [&](Token other) { return texts_[other] == text; });
+    if (token == next) {
+        texts_.emplace_back(text);
+    }
+    return token;
+}
+
+std::optional<Token> TokenTable::Find(std::string_view text) const {
+    return index_.Find(std::hash<std::string_view>()(text),
+                       [&](Token other) { return texts_[other] == text; });
+}
+
+PathTable::PathTable() : nodes_(1) {}
+
+std::uint64_t PathTable::Hash(PathId parent, Token name) {
+    return Mix64(std::uint64_t{parent} << 32 | name);
+}
+
+void PathTable::Reserve(std::size_t count) {
+    nodes_.reserve(nodes_.size() + count);
+    children_.Reserve(children_.Size() + count);
+    names_.Reserve(count);
+}
+
+PathId PathTable::Child(PathId parent, Token name) {
+    const auto next = static_cast<PathId>(nodes_.size());
+    const PathId id = children_.Insert(Hash(parent, name), next, [&](PathId other) {
+        return nodes_[other].parent == parent && nodes_[other].name == name;
+    });
+    if (id != next) {
+        return id;
+    }
+    nodes_.push_back({parent, name});
+    Node& above = nodes_[parent];
+    if (above.firstChild == kNoPath) {
+        above.firstChild = id;
+    } else {
+        nodes_[above.lastChild].nextSibling = id;
+    }
+    above.lastChild = id;
+    return id;
+}
+
+PathId PathTable::Intern(const Path& path) {
+    if (path.IsEmpty()) {
+        throw std::invalid_argument("An empty path names no prim");
+    }
+    PathId id = kRootPath;
+    ForEachName(path.String(), [&](std::string_view name) { id = Child(id, name); });
+    return id;
+}
+
+std::optional<PathId> PathTable::Find(const Path& path) const {
+    if (path.IsEmpty()) {
+        return std::nullopt;
+    }
+    PathId id = kRootPath;
+    bool found = true;
+    ForEachName(path.String(), [&](std::string_view name) {
+        const std::optional<Token> token = found ? names_.Find(name) : std::nullopt;
+        const std::optional<PathId> child =
+            token ? children_.Find(Hash(id, *token),
+                                   [&](PathId other) {
+                                       return nodes_[other].parent == id &&
+                                              nodes_[other].name == *token;
+                                   })
+                  : std::nullopt;
+        found = child.has_value();
+        if (found) {
+            id = *child;
+        }
+    });
+    return found ? std::optional(id) : std::nullopt;
+}
+
+Path PathTable::ToPath(PathId id) const {
+    if (id == kRootPath) {
+        return Path::Root();
+    }
+    std::vector<std::string_view> names;
+    for (; id != kRootPath; id = nodes_[id].parent) {
+        names.push_back(names_.Text(nodes_[id].name));
+    }
+    std::string text;
+    for (auto name = names.rbegin(); name != names.rend(); ++name) {
+        text += '/';
+        text += *name;
+    }
+    return Path(text);
+}
+
+bool PathTable::HasPrefix(PathId id, PathId ancestor) const {
+    for (; id != kNoPath; id = nodes_[id].parent) {
+        if (id == ancestor) {
+            return true;
+        }
+    }
+    return false;
+}
+
+}  // namespace ernie