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

{ernie_renderer-0.2.0.dev16 → ernie_renderer-0.2.0.dev19}/.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.dev19}/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 ".dev19" 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.dev19}/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.dev19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ernie-renderer
-Version: 0.2.0.dev16
+Version: 0.2.0.dev19
 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.dev19/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.dev19/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.dev19/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.dev19/benchmarks/scene_storage.cpp

@@ -0,0 +1,118 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file scene_storage.cpp
+/// @brief The prim store at 100,000 prims: create, first sync, one edit, edit all, add and remove.
+#include "benchmarks/bench.h"
+#include "ernie/scene/storage.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.dev19}/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.dev19}/ernie/CMakeLists.txt

@@ -54,12 +54,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.dev16 → ernie_renderer-0.2.0.dev19}/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.dev19/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.dev19/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

ernie_renderer-0.2.0.dev19/ernie/scene/path.h

@@ -0,0 +1,152 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/// @file path.h
+/// @brief Prim paths, interned names, and the scene's table of paths as (parent, name) nodes.
+#pragma once
+
+#include "ernie/util/hash_index.h"
+
+#include <compare>
+#include <cstdint>
+#include <deque>
+#include <functional>
+#include <limits>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace ernie {
+
+/// @brief An absolute prim path such as `/World/Rover/Wheel_FL`, as text.
+class Path {
+  public:
+    Path() = default;
+    /// @param text An absolute path of valid names.
+    /// @throws std::invalid_argument If it is not.
+    Path(std::string_view text);
+    Path(const char* text) : Path(std::string_view(text)) {}
+    Path(const std::string& text) : Path(std::string_view(text)) {}
+
+    static Path Root();
+    /// @return Whether `name` is a valid prim name: a letter or underscore, then letters, digits
+    ///         and underscores.
+    static bool IsValidName(std::string_view name);
+
+    const std::string& String() const {
+        return text_;
+    }
+    bool IsEmpty() const {
+        return text_.empty();
+    }
+    bool IsRoot() const {
+        return text_ == "/";
+    }
+    /// @return The last name; empty for the root and the empty path.
+    std::string_view Name() const;
+    /// @return The parent; empty for the root and the empty path.
+    Path Parent() const;
+    /// @throws std::invalid_argument If this path is empty or `name` is invalid.
+    Path Child(std::string_view name) const;
+    /// @return Whether this path is `ancestor` or lies below it.
+    bool HasPrefix(const Path& ancestor) const;
+
+    auto operator<=>(const Path&) const = default;
+
+  private:
+    std::string text_;
+};
+
+/// An interned name; 0 is no name.
+using Token = std::uint32_t;
+
+/// @brief Interned strings: each distinct name is stored once and compared as a number.
+class TokenTable {
+  public:
+    TokenTable();
+    /// @return The name's token, adding it if new.
+    Token Intern(std::string_view text);
+    /// @return The name's token, if interned.
+    std::optional<Token> Find(std::string_view text) const;
+    std::string_view Text(Token token) const {
+        return texts_[token];
+    }
+    void Reserve(std::size_t count) {
+        index_.Reserve(count);
+    }
+
+  private:
+    std::deque<std::string> texts_;
+    HashIndex index_;
+};
+
+/// An interned path, a node of a `PathTable`; 0 is the root.
+using PathId = std::uint32_t;
+inline constexpr PathId kRootPath = 0;
+inline constexpr PathId kNoPath = std::numeric_limits<PathId>::max();
+
+/// @brief Every path the scene has named, as (parent, name) nodes with their children in order.
+/// Paths are never removed, so ids stay valid; prims come and go on them.
+class PathTable {
+  public:
+    PathTable();
+
+    /// @return The path's id, adding it and its ancestors if new.
+    PathId Intern(const Path& path);
+    /// @return The child's id, adding it if new.
+    PathId Child(PathId parent, Token name);
+    PathId Child(PathId parent, std::string_view name) {
+        return Child(parent, names_.Intern(name));
+    }
+    /// @return The path's id, if interned.
+    std::optional<PathId> Find(const Path& path) const;
+
+    Path ToPath(PathId id) const;
+    PathId Parent(PathId id) const {
+        return nodes_[id].parent;
+    }
+    Token Name(PathId id) const {
+        return nodes_[id].name;
+    }
+    PathId FirstChild(PathId id) const {
+        return nodes_[id].firstChild;
+    }
+    PathId NextSibling(PathId id) const {
+        return nodes_[id].nextSibling;
+    }
+    /// @return Whether `id` is `ancestor` or lies below it.
+    bool HasPrefix(PathId id, PathId ancestor) const;
+
+    std::size_t Size() const {
+        return nodes_.size();
+    }
+    /// Makes room for `count` more paths and as many new names.
+    void Reserve(std::size_t count);
+    TokenTable& Names() {
+        return names_;
+    }
+    const TokenTable& Names() const {
+        return names_;
+    }
+
+  private:
+    struct Node {
+        PathId parent = kNoPath;
+        Token name = 0;
+        PathId firstChild = kNoPath;
+        PathId lastChild = kNoPath;
+        PathId nextSibling = kNoPath;
+    };
+    static std::uint64_t Hash(PathId parent, Token name);
+
+    TokenTable names_;
+    std::vector<Node> nodes_;
+    HashIndex children_;
+};
+
+}  // namespace ernie
+
+template <> struct std::hash<ernie::Path> {
+    std::size_t operator()(const ernie::Path& path) const noexcept {
+        return std::hash<std::string>()(path.String());
+    }
+};