ernie-renderer 0.2.0.dev148__tar.gz → 0.2.0.dev149__tar.gz

{ernie_renderer-0.2.0.dev148 → ernie_renderer-0.2.0.dev149}/CMakeLists.txt

@@ -15,7 +15,7 @@ project(
 )
 
 # Pre-release suffix such as .dev12, written by CI.
-set(ERNIE_VERSION_SUFFIX ".dev148" CACHE STRING "Pre-release suffix of Ernie's version")
+set(ERNIE_VERSION_SUFFIX ".dev149" 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)

{ernie_renderer-0.2.0.dev148 → ernie_renderer-0.2.0.dev149}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ernie-renderer
-Version: 0.2.0.dev148
+Version: 0.2.0.dev149
 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.dev148 → ernie_renderer-0.2.0.dev149}/ernie/python/device.cpp

@@ -213,7 +213,8 @@ void BindDevice(nb::module_& module) {
             "A column over a CUDA tensor's own memory, in place, when it is exportable.");
 
     nb::class_<Column>(module, "DeviceColumn",
-                       "Rows on the device that CUDA, PyTorch and Warp read and write in place.")
+                       "Rows on the device that CUDA, PyTorch and Warp read and write in place.",
+                       nb::is_weak_referenceable())
         .def_prop_ro("name", [](const Column& self) { return self.column->Name(); })
         .def_prop_ro("shape", &Column::Shape)
         .def_prop_ro("dtype", [](const Column& self) { return TypeName(self.column->Type()); })

{ernie_renderer-0.2.0.dev148 → ernie_renderer-0.2.0.dev149}/ernie/python/render.cpp

@@ -24,13 +24,31 @@ namespace nb = nanobind;
 namespace ernie::python {
 namespace {
 
-/// A renderer and the CUDA device paired with its device. Members go in reverse: CUDA first.
+/// A renderer, the CUDA device paired with its device, and the columns bound to it, whose writes
+/// each step waits for. Members go in reverse: CUDA first.
 struct PythonRenderer {
     Renderer renderer;
     std::unique_ptr<CudaInterop> cuda;
+    std::vector<nb::weakref> bound;
 
     explicit PythonRenderer(const RendererOptions& options)
         : renderer(options), cuda(CudaInterop::Create(renderer.Context())) {}
+
+    Interop Pair() {
+        return {&renderer.Context(), cuda.get()};
+    }
+
+    /// Makes the next step wait for the bound columns' writes, forgetting columns gone.
+    void WaitForBound() {
+        std::erase_if(bound, [&](const nb::weakref& reference) {
+            const nb::object column = reference();
+            if (column.is_none()) {
+                return true;
+            }
+            renderer.WaitFor(nb::cast<const Column&>(column).written);
+            return false;
+        });
+    }
 };
 
 /// A batch of a step: its products and each var's columns, valid until the next step.
@@ -50,8 +68,9 @@ struct PythonBatch {
 };
 
 std::vector<PythonBatch> Step(PythonRenderer& self, const nb::object& owner, Scene& scene) {
+    self.WaitForBound();
     const std::span<const RenderBatch> batches = self.renderer.Step(scene);
-    const Interop interop{&self.renderer.Context(), self.cuda.get()};
+    const Interop interop = self.Pair();
     const Ticket ready = self.renderer.Context().Main().Last();
     std::vector<PythonBatch> result;
     for (const RenderBatch& batch : batches) {
@@ -117,7 +136,25 @@ void BindRender(nb::module_& module) {
             nb::arg("scene"),
             "Renders every product of the scene's first RenderSettings, products alike in size "
             "and vars in one dispatch, and returns the RenderBatches without waiting: their vars "
-            "are device columns that torch.from_dlpack views in place, or read() copies.");
+            "are device columns that torch.from_dlpack views in place, or read() copies.")
+        .def(
+            "bind_transform_op",
+            [](nb::object self, Scene& scene, const std::string& prim,
+               const std::string& attribute) {
+                auto& renderer = nb::cast<PythonRenderer&>(self);
+                const DeviceColumn& bound =
+                    renderer.renderer.BindTransformOp(scene, Path(prim), attribute);
+                auto* column = new Column(renderer.Pair(), bound, {}, Ticket{});
+                column->keeper = self;
+                nb::object handle = nb::cast(column, nb::rv_policy::take_ownership);
+                renderer.bound.emplace_back(handle);
+                return handle;
+            },
+            nb::arg("scene"), nb::arg("prim"), nb::arg("attribute"),
+            "Hands a transform op (such as xformOp:translate) of every prim in the prim's bucket "
+            "to the device: returns its DeviceColumn, a row a prim in the bucket's order, which "
+            "PyTorch or Warp write in place; call ready(stream) after writing, and the next step "
+            "renders the new poses with no copy through the host.");
 }
 
 }  // namespace ernie::python

{ernie_renderer-0.2.0.dev148 → ernie_renderer-0.2.0.dev149}/ernie/python/scene.cpp

@@ -327,6 +327,20 @@ void BindScene(nb::module_& module) {
                 return Map(self.Prims(type), &Path::String);
             },
             nb::arg("type") = "", "The paths of every prim of a type or one deriving from it.")
+        .def(
+            "bucket_paths",
+            [](const Scene& self, const Target& prim) {
+                const PrimStore& store = self.Store();
+                const Bucket& bucket = store.GetBucket(store.PrimBucket(Resolve(self, prim)));
+                std::vector<std::string> paths;
+                for (const PrimId row : bucket.prims) {
+                    paths.push_back(self.PrimPath(row).String());
+                }
+                return paths;
+            },
+            nb::arg("prim"),
+            "The paths of the prims stored with this one (its type and applied schemas), by row: "
+            "the rows of a column bound for them. Adding or removing such prims reorders them.")
         .def(
             "apply_api",
             [](Scene& self, const Target& prim, const std::string& api) {

{ernie_renderer-0.2.0.dev148 → ernie_renderer-0.2.0.dev149}/ernie/render/renderer.cpp

@@ -79,9 +79,9 @@ const RenderVarOutput* RenderBatch::Find(std::string_view name) const {
 struct Renderer::Device {
     ShaderCompiler compiler;
     std::unique_ptr<DeviceContext> context;
+    /// Where the device scene and outputs live: shared with CUDA where the device can export
+    /// memory, so bound columns and outputs map in place.
     std::unique_ptr<Arenas> arenas;
-    /// Where outputs live: shared with CUDA where the device can export memory.
-    std::unique_ptr<Arenas> outputs;
     std::unique_ptr<BindlessHeap> heap;
     std::unique_ptr<CameraPass> camera;
     /// The scene `deviceScene` follows, by `Scene::Id`: an address can be a new scene's.
@@ -89,7 +89,11 @@ struct Renderer::Device {
     std::unique_ptr<DeviceScene> deviceScene;
     std::vector<Batch> batches;
     std::vector<RenderBatch> rendered;
+    /// What the next step waits for.
+    std::vector<Ticket> waits;
 
+    /// @return The device scene following `scene`, made anew for a scene it does not follow.
+    DeviceScene& Follow(const Scene& scene);
     /// Makes the batches for `specs`, keeping last step's columns where their vars match.
     void Plan(const Scene& scene, const std::vector<ProductSpec>& specs);
     /// Sizes a batch's columns for its views, making them when there are none.
@@ -131,7 +135,7 @@ void Renderer::Device::Allocate(Batch& batch, const std::vector<std::string>& va
         const VarFormat& format = FindFormat(vars[i]);
         std::unique_ptr<DeviceColumn>& column = batch.columns[i];
         if (!column || column->Name() != format.name) {
-            column = std::make_unique<DeviceColumn>(*outputs, format.name, format.type,
+            column = std::make_unique<DeviceColumn>(*arenas, format.name, format.type,
                                                     format.channels, 0);
         }
         column->Resize(pixels, context->Main());
@@ -152,12 +156,10 @@ Renderer::Renderer(const RendererOptions& options) : device_(std::make_unique<De
         throw DeviceError(DeviceErrorKind::Unsupported,
                           device.context->Info().name + " cannot ray trace");
     }
-    device.arenas = std::make_unique<Arenas>(*device.context, MemoryUse::Device, "renderer",
-                                             std::uint64_t{16} << 20);
-    device.outputs = std::make_unique<Arenas>(
+    device.arenas = std::make_unique<Arenas>(
         *device.context,
         device.context->Capabilities().externalMemory ? MemoryUse::Shared : MemoryUse::Device,
-        "render outputs", std::uint64_t{16} << 20);
+        "renderer", std::uint64_t{16} << 20);
     device.heap = std::make_unique<BindlessHeap>(*device.context);
     device.camera = std::make_unique<CameraPass>(*device.context, device.compiler, *device.heap);
 }
@@ -170,34 +172,56 @@ DeviceContext& Renderer::Context() {
     return *device_->context;
 }
 
+DeviceScene& Renderer::Device::Follow(const Scene& scene) {
+    if (scene.Id() != sceneId) {
+        context->WaitIdle();
+        deviceScene = std::make_unique<DeviceScene>(*context, *arenas, scene, compiler);
+        sceneId = scene.Id();
+        batches.clear();
+        rendered.clear();
+    }
+    return *deviceScene;
+}
+
 std::span<const RenderBatch> Renderer::Step(Scene& scene) {
     ERNIE_ZONE("Render step");
     scene.Update();
     const std::vector<ProductSpec> specs = ReadProducts(scene);
     Device& device = *device_;
-    if (scene.Id() != device.sceneId) {
-        device.context->WaitIdle();
-        device.deviceScene =
-            std::make_unique<DeviceScene>(*device.context, *device.arenas, scene, device.compiler);
-        device.sceneId = scene.Id();
-    }
+    DeviceScene& deviceScene = device.Follow(scene);
     device.Plan(scene, specs);
     const auto highest = std::ranges::max(specs, {}, &ProductSpec::world).world;
-    device.deviceScene->Instances().ReserveWorlds(highest + 1);
-    device.deviceScene->Follow(glm::dvec3(device.batches.front().views.front().cameraToWorld[3]));
-    device.deviceScene->Execute([&](graph::Graph& graph) {
-        for (const Batch& batch : device.batches) {
-            CameraOutputs outputs;
-            for (std::size_t i = 0; i < batch.columns.size(); ++i) {
-                outputs.*FindFormat(batch.outputs.vars[i].name).output =
-                    graph.Import(*batch.columns[i]);
+    deviceScene.Instances().ReserveWorlds(highest + 1);
+    deviceScene.Follow(glm::dvec3(device.batches.front().views.front().cameraToWorld[3]));
+    deviceScene.Execute(
+        [&](graph::Graph& graph) {
+            for (const Batch& batch : device.batches) {
+                CameraOutputs outputs;
+                for (std::size_t i = 0; i < batch.columns.size(); ++i) {
+                    outputs.*FindFormat(batch.outputs.vars[i].name).output =
+                        graph.Import(*batch.columns[i]);
+                }
+                device.camera->Add(graph, batch.views, outputs);
             }
-            device.camera->Add(graph, batch.views, outputs);
-        }
-    });
+        },
+        device.waits);
+    device.waits.clear();
     return device.rendered;
 }
 
+const DeviceColumn& Renderer::BindTransformOp(Scene& scene, const Path& prim,
+                                              std::string_view attribute) {
+    DeviceScene& deviceScene = device_->Follow(scene);
+    const BucketId bucket = scene.Store().PrimBucket(scene.Require(prim));
+    const DeviceColumn& column = deviceScene.Columns().Bind(bucket, attribute);
+    deviceScene.Transforms().Bind(bucket, attribute, column);
+    return column;
+}
+
+void Renderer::WaitFor(const Ticket& ticket) {
+    device_->waits.push_back(ticket);
+}
+
 Tensor Renderer::Read(const RenderVarOutput& var) {
     DeviceContext& context = *device_->context;
     const Ticket done = context.Main().Last();

{ernie_renderer-0.2.0.dev148 → ernie_renderer-0.2.0.dev149}/ernie/render/renderer.h

@@ -27,6 +27,7 @@ namespace ernie {
 
 class DeviceColumn;
 class DeviceContext;
+struct Ticket;
 
 struct RendererOptions {
     /// The device: its UUID in hex, or part of its name; empty for the best scoring one.
@@ -79,6 +80,18 @@ class ERNIE_API Renderer {
     /// @return A var's pixels copied to the host once the last step has rendered them.
     Tensor Read(const RenderVarOutput& var);
 
+    /// @brief Hands a transform op to the device for every prim in `prim`'s bucket (the prims of
+    /// its type and applied schemas), as the device scene's columns bind it: from then on the
+    /// column is what steps read, so CUDA, PyTorch or Warp write poses in place and nothing goes
+    /// through the host. Values the host authors later still overwrite their rows. The op must
+    /// be in the prims' `xformOpOrder`.
+    /// @return The column, a row a prim in the bucket's row order, in memory CUDA can map.
+    /// @throws std::invalid_argument as `SceneColumns::Bind` and `TransformGraph::Bind`.
+    const DeviceColumn& BindTransformOp(Scene& scene, const Path& prim, std::string_view attribute);
+    /// @brief Makes the next step wait on the device for `ticket`, such as CUDA's writes to a
+    /// bound column.
+    void WaitFor(const Ticket& ticket);
+
     /// @brief Steps and reads the first product's LdrColor.
     /// @return LdrColor, height x width x 4 bytes (RGBA8, display encoded) on the host.
     /// @throws std::invalid_argument as `Step`, or when that product holds no LdrColor.

{ernie_renderer-0.2.0.dev148 → ernie_renderer-0.2.0.dev149}/ernie/render/scene_columns.cpp

@@ -121,6 +121,8 @@ const DeviceColumn& SceneColumns::Bind(BucketId bucket, std::string_view attribu
         bucket, host.attribute, scene_.Store().Version(), std::move(column), std::move(shadow)});
     uploader_.Write(binding.column->Storage(), binding.column->Range().offset,
                     std::span<const std::byte>(binding.shadow));
+    // Submitted now, so writes the device makes once it is bound land after the scene's values.
+    uploader_.Flush();
     return *binding.column;
 }
 

{ernie_renderer-0.2.0.dev148 → ernie_renderer-0.2.0.dev149}/ernie/render/scene_columns.h

@@ -46,7 +46,9 @@ class SceneColumns {
     SceneColumns(const SceneColumns&) = delete;
     SceneColumns& operator=(const SceneColumns&) = delete;
 
-    /// @brief Puts a bucket's column of `attribute` on the device, from the scene's values.
+    /// @brief Puts a bucket's column of `attribute` on the device, from the scene's values, which
+    /// are submitted at once: work on the main queue after the call, or CUDA work waiting on it,
+    /// sees them.
     /// @throws std::invalid_argument when the bucket has no such column, or its type has no
     /// device element.
     const DeviceColumn& Bind(BucketId bucket, std::string_view attribute);

{ernie_renderer-0.2.0.dev148 → ernie_renderer-0.2.0.dev149}/tests/python/test_device_torch.py

@@ -83,6 +83,39 @@ def test_exportable_tensors_are_wrapped_in_place(context, mode, allocator_config
     assert result.returncode == 0, result.stderr
 
 
+def test_pytorch_poses_move_what_a_step_renders(context):
+    scene = ernie.Scene()
+    for name in ("A", "B"):
+        scene.define(f"/World/{name}", ernie.Sphere, translate=(0, 5, 0))
+    scene.define("/World/Camera", ernie.Camera).set(
+        ernie.tokens.TRANSFORM, ernie.look_at_transform((0, 0, 0), (0, 1, 0))
+    )
+    scene.define("/Render/Product/Depth", ernie.RenderVar, sourceName="DistanceToCamera")
+    scene.define(
+        "/Render/Product",
+        ernie.RenderProduct,
+        camera="/World/Camera",
+        resolution=(33, 33),
+        orderedVars=["/Render/Product/Depth"],
+    )
+    scene.define("/Render/Settings", ernie.RenderSettings, products=["/Render/Product"])
+    try:
+        renderer = ernie.Renderer(device=context.uuid)
+    except RuntimeError as error:
+        pytest.skip(str(error))
+    translates = renderer.bind_transform_op(scene, "/World/A", "xformOp:translate")
+    rows = scene.bucket_paths("/World/A")
+    assert sorted(rows) == ["/World/A", "/World/B"] and translates.shape == [2, 3]
+
+    # PyTorch moves A 2 m nearer and B out of view, and the step renders A without the host.
+    poses = torch.from_dlpack(translates)
+    poses[rows.index("/World/A")] = torch.tensor([0.0, 3.0, 0.0])
+    poses[rows.index("/World/B")] = torch.tensor([50.0, 5.0, 0.0])
+    translates.ready(torch.cuda.current_stream(context.cuda_ordinal).cuda_stream)
+    (batch,) = renderer.step(scene)
+    assert batch["DistanceToCamera"].read()[0, 16, 16] == pytest.approx(2.0, abs=1e-4)
+
+
 def test_pytorch_reads_a_render_in_place(context):
     scene = ernie.Scene()
     scene.define("/World/Ball", ernie.Sphere, translate=(0, 5, 0))

{ernie_renderer-0.2.0.dev148 → ernie_renderer-0.2.0.dev149}/tests/render/renderer_test.cpp

@@ -2,6 +2,8 @@
 /// @file renderer_test.cpp
 /// @brief The README's first render, as written there: a rock on the ground under the sun, seen
 /// by a camera the render settings name.
+#include "ernie/device/column.h"
+#include "ernie/device/staging.h"
 #include "ernie/render/products.h"
 #include "ernie/render/renderer.h"
 #include "ernie/scene/schema/camera.h"
@@ -195,6 +197,33 @@ TEST(Renderer, EachViewSeesItsWorldAndTheSharedPrims) {
     test::ExpectClean(renderer->Context());
 }
 
+TEST(Renderer, StepsRenderPosesWrittenOnTheDevice) {
+    const std::unique_ptr<Renderer> renderer = MakeRenderer();
+    if (!renderer) {
+        GTEST_SKIP() << "No Vulkan device that ray traces";
+    }
+    Scene scene;
+    DefineSphereAhead(scene);
+    DefineCamera(scene, "/World/Camera", {0.0, 0.0, 0.0});
+    DefineProduct(scene, "/Render/Product", "/World/Camera", {9, 9},
+                  {std::string(render_vars::kDistanceToCamera)});
+    RenderSettings::Define(scene, "/Render/Settings").SetProducts({Path("/Render/Product")});
+    const DeviceColumn& translates =
+        renderer->BindTransformOp(scene, "/World/Ball", "xformOp:translate");
+    ASSERT_EQ(translates.Shape(), (std::vector<std::int64_t>{1, 3}));
+
+    // As CUDA would, a write on the device the host never sees: the ball 2 m nearer.
+    DeviceContext& context = renderer->Context();
+    Uploader uploader(context, context.Main());
+    const std::array<float, 3> nearer{0.0f, 3.0f, 0.0f};
+    uploader.Write(translates.Storage(), translates.Range().offset, std::span<const float>(nearer));
+    renderer->WaitFor(uploader.Flush());
+    const RenderBatch& batch = renderer->Step(scene).front();
+    const Tensor depth = renderer->Read(*batch.Find(render_vars::kDistanceToCamera));
+    EXPECT_NEAR(depth.As<float>()[40], 2.0f, 1e-4f);
+    test::ExpectClean(context);
+}
+
 TEST(Products, ConformTheFilmToTheImage) {
     Scene scene;
     DefineCamera(scene, "/World/Camera", {0.0, 0.0, 0.0}, {0.02, 0.01});