diffct 2.4.1__tar.gz → 2.4.2__tar.gz

{diffct-2.4.1 → diffct-2.4.2}/CHANGELOG.md

@@ -7,6 +7,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.4.2] - 2026-10-21
+
+### Fixed
+
+- Count host world points in the streamed geometry budget only for surfaces that expand them on the host. Shared, non-trainable legacy offsets no longer shrink view batches (#40).
+- Compose shared legacy offsets with one launch per job: the frames of all views are staged in one transfer and `compose_surface` runs on a 2-D grid whose rows are views. The offset snapshot is staged once per call and pixel tile; offsets supplied by the caller, such as in the geometry VJP replay, are staged on every call (#40).
+- Count the batched frame staging in the streamed surface memory budget, and pack shared offsets into the workspace without a device staging buffer (#40).
+
 ## [2.4.1] - 2026-10-20
 
 ### Fixed

{diffct-2.4.1 → diffct-2.4.2}/CITATION.cff

@@ -13,8 +13,8 @@ authors:
     given-names: Yipeng
     email: yipeng.sun@fau.de
     alias: sypsyp97
-version: 2.4.1
-date-released: "2026-10-20"
+version: 2.4.2
+date-released: "2026-10-21"
 license: Apache-2.0
 repository-code: "https://github.com/sypsyp97/diffct"
 url: "https://sypsyp97.github.io/diffct/"

{diffct-2.4.1 → diffct-2.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: diffct
-Version: 2.4.1
+Version: 2.4.2
 Summary: Differentiable CT projection and reconstruction: precision modes, streaming, distributed execution and geometry gradients
 Project-URL: Homepage, https://github.com/sypsyp97/diffct
 Project-URL: Documentation, https://sypsyp97.github.io/diffct/

{diffct-2.4.1 → diffct-2.4.2}/diffct/__init__.py

@@ -64,7 +64,7 @@ try:
 except ImportError:
     pass
 
-__version__ = '2.4.1'
+__version__ = '2.4.2'
 
 __all__ = [
     'Projector',

{diffct-2.4.1 → diffct-2.4.2}/diffct/kernels/surface_geometry.py

@@ -51,11 +51,17 @@ def compose_surface(frames, offsets, source, points, view_index, pixel_start,
     ``frame32`` gives the arithmetic dtype of each packed frame component.
     ``offset32`` gives the offset arithmetic dtype. Values are stored exactly
     in float64 staging buffers. Results use caller-owned float32 buffers.
+
+    A launch may compose several views with the same offsets: grid row ``y``
+    writes view ``view_index + y`` from the ``y``-th of ``gridDim.y`` equal
+    frame packets in ``frames``.
     """
     pixel = cuda.grid(1)
+    view_index += cuda.blockIdx.y
+    base = cuda.blockIdx.y * (frames.size // cuda.gridDim.y)
     if pixel == 0:
         for axis in range(rank):
-            value = frames[axis]
+            value = frames[base + axis]
             if not parallel:
                 value = _surface_add(value, -centre[axis], frame32[0])
             source[view_index, axis] = np.float32(value)
@@ -85,20 +91,20 @@ def compose_surface(frames, offsets, source, points, view_index, pixel_start,
     point_squared = np.float64(0.0)
     for axis in range(rank):
         point = _surface_add(
-            frames[rank + axis],
-            _surface_multiply(tangent, frames[2 * rank + axis], tangent32),
+            frames[base + rank + axis],
+            _surface_multiply(tangent, frames[base + 2 * rank + axis], tangent32),
             frame32[1] and tangent32,
         )
         if rank == 3:
             point = _surface_add(
-                point, _surface_multiply(vertical, frames[3 * rank + axis], vertical32),
+                point, _surface_multiply(vertical, frames[base + 3 * rank + axis], vertical32),
                 point32,
             )
-            normal = frames[4 * rank + axis]
+            normal = frames[base + 4 * rank + axis]
         else:
-            normal = frames[2 * rank + 1] if axis == 0 else -frames[2 * rank]
+            normal = frames[base + 2 * rank + 1] if axis == 0 else -frames[base + 2 * rank]
         point = _surface_add(point, _surface_multiply(depth, normal, depth32), final32)
-        source_value = frames[axis]
+        source_value = frames[base + axis]
         source_native = np.float32(source_value)
         point_native = np.float32(point)
         finite = (finite and math.isfinite(source_value) and math.isfinite(point)

{diffct-2.4.1 → diffct-2.4.2}/diffct/operators.py

@@ -489,6 +489,8 @@ class Projector:
             if self.backend != "torch" and detector_surface is not None:
                 geometry, spec, surface_trainable, surface_metadata = self._surface_validation_inputs()
                 devices = self._devices or (torch.device("cuda", torch.cuda.current_device()),)
+                # Validation budgets depend on whether geometry gradients are needed.
+                self._geometry_trainable = bool(self._learnable) or surface_trainable
                 self._validate_surface_geometry(geometry, spec, devices)
         except (TypeError, ValueError, RuntimeError) as error:
             validation_error = error
@@ -769,6 +771,8 @@ class Projector:
 
         def fits(shape):
             points = surface or pixels != self.detector_shape
+            # Legacy offsets are one host snapshot; world points expand on the device.
+            host_points = points and self._host_world_points(geometry_spec)
             buffers = _pipeline_buffers(self.beam, shape, batch, pixels, points,
                                         geometry_grad=self._geometry_trainable,
                                         ray_accumulators=extra_rays, peers=peers or foreign_output)
@@ -778,7 +782,7 @@ class Projector:
                 and _reservation_bytes(buffers) <= reservation_budget
                 and _largest_buffer_bytes(self.beam, shape, batch, pixels, points) <= allocation_limit
                 and max(self._surface_work_buffers(batch, pixels, spec=geometry_spec, streamed=True), default=0) <= allocation_limit
-                and _host_geometry_bytes(self.beam, batch, pixels, points) <= _pipeline._GEOMETRY_WORK_BYTES
+                and _host_geometry_bytes(self.beam, batch, pixels, host_points) <= _pipeline._GEOMETRY_WORK_BYTES
             )
 
         while not fits(minimum_shape):
@@ -826,7 +830,11 @@ class Projector:
             rank, frames = len(self.volume_shape), 4 if self.beam == "cone" else 3
             capacity = self._surface_capacity(views, pixels)
             columns = 3 if self.beam == "cone" else 2
-            buffers = (_allocation_bytes(2 * (frames + (3 if rank == 3 else 0)) * rank),
+            shared = spec is not None and spec.kind == "offsets" and spec.shared
+            if shared:
+                capacity = math.prod(pixels)
+            # Shared offsets pack the frame packets of every view of a job.
+            buffers = (_allocation_bytes(2 * (views if shared else 1) * (frames + (3 if rank == 3 else 0)) * rank),
                        _allocation_bytes(2 * (columns * capacity + 1)))
             if self._geometry_trainable:
                 # Replay one view and a bounded detector row at a time.
@@ -850,7 +858,17 @@ class Projector:
         dtype = torch.float32
         for component in (*frames[1:], offsets):
             dtype = torch.promote_types(dtype, component.dtype)
-        return _GeometrySpec("offsets", dtype=dtype)
+        return _GeometrySpec("offsets", dtype=dtype, shared=offsets.ndim == len(self.detector_shape) + 1)
+
+    def _host_world_points(self, spec):
+        """Whether the host geometry budget must count world points of each view.
+
+        Shared legacy offsets are one host snapshot whose world points are
+        composed on the compute device; per-view offsets and geometry
+        gradients keep host work proportional to views x pixels.
+        """
+        return not (spec is not None and spec.kind == "offsets" and spec.shared
+                    and not self._geometry_trainable)
 
     def _surface_validation_inputs(self):
         """Stage frame metadata once without expanding surface world points."""
@@ -884,7 +902,7 @@ class Projector:
                 buffers = self._surface_work_buffers(batch, pixels, spec=spec)
                 return (sum(buffers) <= budget and max(buffers, default=0) <= allocation
                         and _reservation_bytes(buffers) <= reservation
-                        and _host_geometry_bytes(self.beam, batch, pixels, True)
+                        and _host_geometry_bytes(self.beam, batch, pixels, self._host_world_points(spec))
                         <= _pipeline._GEOMETRY_WORK_BYTES)
 
             if not fits():
@@ -1197,7 +1215,8 @@ class Projector:
                 estimate = size(shape, slots, retained, extra_rays)
                 reservation = (reserved(shape, slots, retained, extra_rays)
                                if estimate <= plan.gpu_budget_bytes else (1 << 63) - 1)
-                host_fits = 2 * _host_geometry_bytes(self.beam, plan.view_chunk_size, pixels, points) <= _pipeline._GEOMETRY_WORK_BYTES
+                host_points = points and self._host_world_points(spec)
+                host_fits = 2 * _host_geometry_bytes(self.beam, plan.view_chunk_size, pixels, host_points) <= _pipeline._GEOMETRY_WORK_BYTES
                 if (estimate > plan.gpu_budget_bytes
                         or reservation > plan.reservation_budget_bytes or not host_fits):
                     if schedule == "window":
@@ -1310,6 +1329,9 @@ class Projector:
         rank, frame_count = len(self.volume_shape), 4 if self.beam == "cone" else 3
         count = views.stop - views.start
         pixel_shape = tuple(selected.stop - selected.start for selected in pixels)
+        # Offsets sampled here derive from the snapshot and the pixel tile;
+        # offsets supplied by the caller may differ per batch and are not cached.
+        cacheable = offsets is None
         if offsets is None:
             offsets = _sample_offsets(self.beam, self.detector_shape, self.detector_spacing,
                                       geometry, spec, views, pixels)
@@ -1324,15 +1346,42 @@ class Projector:
             frame32 += (True,)
         offset32 = ((torch.promote_types(torch.float32, offsets.dtype)
                      if spec.kind == "offsets" else common) == torch.float32)
+        # Offsets shared by all views are staged once per call and composed
+        # with one launch for all views instead of per view and row segment.
+        shared = spec.kind == "offsets" and offsets.ndim == len(pixel_shape) + 1
+        pixel_count = math.prod(pixel_shape)
+        # One packed frame packet per view: source, center, axes, normal and
+        # float32 cross-product scratch. Shared offsets pack every view of a job.
+        stride = (frame_count + (3 if rank == 3 else 0)) * rank
         if "_surface_workspace" not in groups:
-            capacity = self._surface_capacity(count, pixel_shape)
+            capacity = pixel_count if shared else self._surface_capacity(count, pixel_shape)
             groups["_surface_workspace"] = (
-                pipe.empty((frame_count + (3 if rank == 3 else 0)) * rank, dtype=torch.float64),
+                pipe.empty((count if shared else 1) * stride, dtype=torch.float64),
                 pipe.empty((3 if rank == 3 else 2) * capacity + 1, dtype=torch.float64), capacity,
             )
         packed_frames, packed_offsets, capacity = groups["_surface_workspace"]
         columns = (0, 1, 2) if rank == 3 else (0, 2)
         source, points = targets[0].view(count, rank), targets[1].view(count, -1, rank)
+        # A workspace sized for an earlier, smaller tile keeps the segment path.
+        shared = shared and capacity >= pixel_count
+        if shared and packed_frames.numel() < count * stride:
+            # Earlier launches on the upload stream may still read the smaller buffer.
+            pipe.retain(pipe.event(pipe.upload), packed_frames, None)
+            packed_frames = pipe.empty(count * stride, dtype=torch.float64)
+            groups["_surface_workspace"] = (packed_frames, packed_offsets, capacity)
+        # Every job of a call slices the same offset snapshot: stage it once per
+        # call, pixel tile and workspace. The key holds the snapshot and the
+        # workspace, so neither a later snapshot reusing storage nor a recreated
+        # workspace can match it.
+        if shared and cacheable:
+            staged_key = (geometry[frame_count], packed_offsets, tuple((part.start, part.stop) for part in pixels))
+            restage = not ("_surface_shared_staged" in groups
+                           and groups["_surface_shared_staged"][0] is staged_key[0]
+                           and groups["_surface_shared_staged"][1] is staged_key[1]
+                           and groups["_surface_shared_staged"][2] == staged_key[2])
+        else:
+            restage = shared
+            groups.pop("_surface_shared_staged", None)
         with torch.cuda.device(pipe.device), torch.cuda.stream(pipe.upload), cuda.gpus[pipe.device.index]:
             if origin is not None:
                 pipe.upload.wait_stream(origin)
@@ -1340,7 +1389,51 @@ class Projector:
             stream = _get_numba_external_stream_for(pipe.upload)
             arrays = tuple(TorchCUDABridge.tensor_to_cuda_array(value)
                            for value in (packed_frames, packed_offsets, source, points))
-            for local in range(count):
+            if restage:
+                # Pack the float64 columns where the offsets live, then copy each
+                # column into the workspace without a device staging buffer.
+                flat = offsets.detach().reshape(pixel_count, 3)
+                if offsets.is_cuda:
+                    for column, original in enumerate(columns):
+                        packed_offsets[column * capacity:column * capacity + pixel_count].copy_(flat[:, original])
+                else:
+                    host = flat[:, list(columns)].T.to(dtype=torch.float64).contiguous()
+                    for column in range(len(columns)):
+                        _pipeline._copy(packed_offsets[column * capacity:column * capacity + pixel_count],
+                                        host[column], pipe.stats)
+                    pipe.retain(pipe.event(pipe.upload), host, packed_offsets)
+                if cacheable:
+                    groups["_surface_shared_staged"] = staged_key
+            if shared:
+                # Stage the frame packets of every view in one transfer and
+                # compose all views with one launch; grid row y composes view y.
+                block = packed_frames[:count * stride].view(count, stride)
+                packet = torch.zeros((count, stride), dtype=torch.float64)
+                for index, value in enumerate(frames):
+                    packet[:, index * rank:(index + 1) * rank].copy_(value[views].detach())
+                _pipeline._copy(block, packet, pipe.stats)
+                pipe.retain(pipe.event(pipe.upload), packet, packed_frames)
+                if rank == 3:
+                    normal = block[:, 4 * rank:5 * rank]
+                    axis_u, axis_v = block[:, 2 * rank:3 * rank], block[:, 3 * rank:4 * rank]
+                    if frame32[2] and frame32[3]:
+                        scratch = block.view(torch.float32)[:, 10 * rank:13 * rank]
+                        scratch[:, :rank].copy_(axis_u)
+                        scratch[:, rank:2 * rank].copy_(axis_v)
+                        torch.linalg.cross(scratch[:, :rank], scratch[:, rank:2 * rank], dim=1,
+                                           out=scratch[:, 2 * rank:])
+                        normal.copy_(scratch[:, 2 * rank:])
+                    else:
+                        torch.linalg.cross(axis_u, axis_v, dim=1, out=normal)
+                for first in range(0, count, 65535):
+                    rows = min(65535, count - first)
+                    compose_surface[((pixel_count + 127) // 128, rows), 128, stream](
+                        TorchCUDABridge.tensor_to_cuda_array(block[first:first + rows].reshape(-1)),
+                        *arrays[1:], first, 0, pixel_count, capacity, rank,
+                        self.beam == "parallel", frame32, offset32,
+                        tuple(centre) + (0.,) * (3 - rank), self.voxel_spacing,
+                    )
+            for local in range(0 if shared else count):
                 packet = torch.cat([value[views.start + local].detach().to(device="cpu", dtype=torch.float64)
                                     for value in frames])
                 _pipeline._copy(packed_frames[:frame_count * rank], packet, pipe.stats)
@@ -2139,6 +2232,7 @@ class Projector:
                     slot.finish()
                 pipe.reclaim_output()
                 del local_groups["_surface_workspace"]
+                local_groups.pop("_surface_shared_staged", None)
                 reduced = surface_batch_vjp(
                     self.beam, self.detector_shape, self.detector_spacing, inputs, offsets,
                     global_slice, pixels, self.voxel_spacing, pipe.device, parts,

{diffct-2.4.1 → diffct-2.4.2}/diffct/surfaces.py

@@ -10,6 +10,8 @@ class _GeometrySpec:
     kind: str
     sampler: object = None
     dtype: object = None
+    # One (U, V, 3) host offset snapshot shared by all views.
+    shared: bool = False
 
 
 class ParameterizedSurface:

{diffct-2.4.1 → diffct-2.4.2}/docs/video/README.md

@@ -1,4 +1,4 @@
-# diffct 2.3.0 introduction
+# diffct introduction
 
 The film preserves the upstream dark, serif presentation: LaTeX typography,
 numbered chapters, a thin progress rule, framed CT images and monospace code
@@ -89,7 +89,7 @@ reconstruction panels retain their recorded inputs.
 
 | Shot | Content checked | Evidence |
 |---|---|---|
-| Opening | 2.3.0 title, five chapters, measured CT surface | `pyproject.toml`, `walnut_surface.npz` |
+| Opening | Title, five chapters, measured CT surface | `walnut_surface.npz` |
 | Trajectories | Five schematic paths; source/centre/u/v tuple; valid per-view poses | [Projector](../../diffct/operators.py), unchanged [ScanDiagram](scan_diagram.py) |
 | Autograd | Simulated parallel sinogram; Siddon path sum; matched adjoint; ordinary squared-loss gradient; batch/second data derivatives | [Projector](../../diffct/operators.py), [portable traversal](../../diffct/backends.py), `make_inputs.py`, `data2d.npz` |
 | Geometry | First-order source/centre/axis gradients; schematic pose dots; log10 loss, 150 steps, angle RMSE 0.55° to 0.006° | [geometry VJP](../../diffct/kernels/geometry_vjp.py), `calib_history.json` |

{diffct-2.4.1 → diffct-2.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "diffct"
-version = "2.4.1"
+version = "2.4.2"
 description = "Differentiable CT projection and reconstruction: precision modes, streaming, distributed execution and geometry gradients"
 readme = "README.md"
 requires-python = ">=3.10"

{diffct-2.4.1 → diffct-2.4.2}/tests/test_surface_geometry_cudasim.py

@@ -85,11 +85,13 @@ class _KernelEntries:
 
     def __getitem__(self, configuration):
         launch = self.kernel[configuration]
+        grid = configuration[0]
+        rows = grid[1] if isinstance(grid, tuple) and len(grid) > 1 else 1
 
         def run(*args):
             frames, offsets, source, points, view, start, count, capacity = args[:8]
-            self.records.append(dict(frames=frames.copy(), source=source, points=points,
-                                     view=view, start=start, count=count, capacity=capacity))
+            self.records.append(dict(frames=frames.copy(), frame_storage=frames, source=source, points=points,
+                                     view=view, rows=rows, start=start, count=count, capacity=capacity))
             return launch(*args)
 
         return run
@@ -177,6 +179,8 @@ def test_fused_helper_runs_real_kernel_for_global_batches_into_reused_bounded_ta
     first_pixels = (slice(2, 7), slice(3, 8)) if beam == "cone" else (slice(2, 27),)
     tail_pixels = (slice(8, 11), slice(8, 13)) if beam == "cone" else (slice(26, 29),)
     batches = [(slice(2, 4), first_pixels), (slice(6, 7), tail_pixels)]
+    shared_offsets = kind == "offsets" and not per_view
+    packet_size = (len(case.trajectory) + (3 if rank == 3 else 0)) * rank
     centre = (.1875, -.3125, .4375)[:rank]
     source_buffer, point_buffer = torch.empty(2 * rank), torch.empty(2 * 25 * rank)
     original_storage = (source_buffer.data_ptr(), point_buffer.data_ptr())
@@ -213,26 +217,59 @@ def test_fused_helper_runs_real_kernel_for_global_batches_into_reused_bounded_ta
             assert torch.all(point_buffer[math.prod(shape):] == 77.)
             assert (source_buffer.data_ptr(), point_buffer.data_ptr()) == original_storage
             observed = entries.records[before:]
-            assert observed and {record["view"] for record in observed} == set(range(count))
+            assert observed
+            pixel_count = math.prod(shape[1:-1])
+            coverage = np.zeros((count, pixel_count), dtype=np.int64)
+            if shared_offsets:
+                assert len(observed) == math.ceil(count / 65535)
+                assert sum(record["rows"] for record in observed) == count
             for record in observed:
+                assert np.shares_memory(record["frame_storage"], groups["_surface_workspace"][0].numpy())
                 assert np.shares_memory(record["source"], source_buffer.numpy())
                 assert np.shares_memory(record["points"], point_buffer.numpy())
+                assert 0 <= record["view"] < record["view"] + record["rows"] <= count
+                assert 1 <= record["rows"] <= 65535
                 assert record["count"] <= record["capacity"]
-                assert record["start"] + record["count"] <= math.prod(shape[1:-1])
-                frame_values = [value[views.start + record["view"]].numpy() for value in case.trajectory]
-                original_prefix = np.concatenate([value.astype(np.float64) for value in frame_values])
-                np.testing.assert_array_equal(record["frames"][:original_prefix.size], original_prefix)
-                assert record["frames"].nbytes <= 512, "packed frame arena exceeded one native allocation unit"
-                if rank == 3:
-                    normal_dtype = np.result_type(np.float32, frame_values[2].dtype, frame_values[3].dtype)
-                    if kind == "sampled":
-                        normal_dtype = np.result_type(normal_dtype, *(value.dtype for value in frame_values), local_offsets.dtype)
-                    normal = np.cross(frame_values[2].astype(normal_dtype), frame_values[3].astype(normal_dtype))
-                    np.testing.assert_array_equal(record["frames"][12:15], normal.astype(np.float64))
-    assert len(pipe.allocations) == 2, "packed workspaces were allocated again for the tail batch"
+                assert 0 <= record["start"] < record["start"] + record["count"] <= pixel_count
+                if shared_offsets:
+                    assert record["start"] == 0 and record["count"] == pixel_count
+                else:
+                    assert record["rows"] == 1
+                coverage[record["view"]:record["view"] + record["rows"],
+                         record["start"]:record["start"] + record["count"]] += 1
+                packets = record["frames"].reshape(record["rows"], packet_size)
+                assert record["frames"].nbytes <= record["rows"] * packet_size * 8
+                for row, packet in enumerate(packets):
+                    frame_values = [value[views.start + record["view"] + row].numpy()
+                                    for value in case.trajectory]
+                    original_prefix = np.concatenate([value.astype(np.float64) for value in frame_values])
+                    np.testing.assert_array_equal(packet[:original_prefix.size], original_prefix)
+                    if rank == 3:
+                        normal_dtype = np.result_type(np.float32, frame_values[2].dtype, frame_values[3].dtype)
+                        if kind == "sampled":
+                            normal_dtype = np.result_type(normal_dtype, *(value.dtype for value in frame_values), local_offsets.dtype)
+                        normal = np.cross(frame_values[2].astype(normal_dtype), frame_values[3].astype(normal_dtype))
+                        np.testing.assert_array_equal(packet[12:15], normal.astype(np.float64))
+            np.testing.assert_array_equal(coverage, np.ones_like(coverage))
+    assert len(pipe.allocations) == 2, \
+        "packed workspaces were allocated again for the tail batch"
+    packed_frames, packed_offsets, capacity = groups["_surface_workspace"]
+    assert "_surface_frames" not in groups
+    assert packed_frames is pipe.allocations[0] and packed_offsets is pipe.allocations[1]
+    maximum_views = max(views.stop - views.start for views, _ in batches)
+    assert packed_frames.dtype == torch.float64
+    assert packed_frames.numel() == (maximum_views if shared_offsets else 1) * packet_size
     workspace_bytes = sum(math.ceil(value.numel() * value.element_size() / 512) * 512 for value in pipe.allocations)
     target_bytes = sum(math.ceil(value.numel() * value.element_size() / 512) * 512 for value in (source_buffer, point_buffer))
-    assert workspace_bytes <= target_bytes, "packed staging exceeded the native geometry buffer bytes"
+    maximum_bytes = target_bytes
+    if shared_offsets:
+        maximum_pixels = max(math.prod(part.stop - part.start for part in pixels) for _, pixels in batches)
+        assert capacity == maximum_pixels
+        # One packet per view and one shared offset tile plus status.
+        maximum_bytes = sum(math.ceil(size / 512) * 512 for size in (
+            maximum_views * packet_size * 8, (rank * maximum_pixels + 1) * 8,
+        ))
+    assert workspace_bytes <= maximum_bytes, "packed staging exceeded the geometry workspace budget"
     assert any(record["count"] < record["capacity"] for record in entries.records)
     assert len(samples) == (2 if kind == "sampled" else 0), "surface sampler ran more than once per native batch"
     if kind == "sampled":
@@ -246,6 +283,60 @@ def test_fused_helper_runs_real_kernel_for_global_batches_into_reused_bounded_ta
     assert bool(pipe.waits) == (offset_origin == "cuda-metadata")
 
 
+@pytest.mark.parametrize("beam", ["cone", "fan", "parallel"])
+@pytest.mark.parametrize("first_count", [1, 3], ids=["grow-frames", "reuse-frames"])
+def test_fused_helper_restages_caller_supplied_shared_offsets_for_geometry_vjp(beam, first_count):
+    case = _case(beam, views=5)
+    projector = _projector(case, backend="torch")
+    rank = len(case.shape)
+    pixels = (slice(1, 3), slice(2, 5)) if rank == 3 else (slice(1, 5),)
+    pixel_shape = tuple(part.stop - part.start for part in pixels)
+    count = 3
+    full_offsets = torch.zeros((*case.detector, 3), dtype=torch.float64)
+    geometry, spec = (*case.trajectory, full_offsets), _GeometrySpec("offsets")
+    first_offsets = torch.zeros((*pixel_shape, 3), dtype=torch.float64, requires_grad=True)
+    second_offsets = torch.tensor([.375, -.25, .625], dtype=torch.float64).expand(
+        *pixel_shape, 3).clone().requires_grad_()
+    targets = (torch.empty((count, rank)), torch.empty((count, *pixel_shape, rank)))
+    centre = (.1875, -.3125, .4375)[:rank]
+    groups, pipe = {}, _CpuGeometryPipe()
+    entries = _KernelEntries(importlib.import_module("diffct.kernels.surface_geometry").compose_surface)
+    outputs = []
+    with _cpu_geometry_transport(entries), \
+            mock.patch.object(operators, "_sample_offsets", side_effect=AssertionError("caller supplied offsets")):
+        for actual_count, offsets in ((first_count, first_offsets), (count, second_offsets)):
+            views = slice(1, 1 + actual_count)
+            selected_targets = tuple(value[:actual_count] for value in targets)
+            projector._surface_geometry_into(geometry, spec, views, pixels, centre,
+                                             selected_targets, pipe, groups, offsets=offsets)
+            frames = tuple(value[views].numpy().copy() for value in case.trajectory)
+            local_offsets = np.broadcast_to(offsets.detach().numpy(), (actual_count, *pixel_shape, 3))
+            expected = (_world(frames, local_offsets, beam) - np.asarray(centre)).astype(np.float32)
+            expected_source = frames[0] if beam == "parallel" else frames[0] - np.asarray(centre)
+            np.testing.assert_array_equal(selected_targets[0].numpy(), expected_source.astype(np.float32))
+            np.testing.assert_array_equal(selected_targets[1].numpy(), expected)
+            outputs.append(selected_targets[1].clone())
+            packet_size = (len(case.trajectory) + (3 if rank == 3 else 0)) * rank
+            packed_frames, packed_offsets, capacity = groups["_surface_workspace"]
+            assert "_surface_frames" not in groups
+            assert packed_frames.dtype == torch.float64
+            assert packed_frames.numel() == actual_count * packet_size
+            assert np.shares_memory(entries.records[-1]["frame_storage"], packed_frames.numpy())
+            if len(outputs) == 1:
+                workspace = groups["_surface_workspace"]
+                assert len(pipe.allocations) == 2
+                assert packed_frames is pipe.allocations[0] and packed_offsets is pipe.allocations[1]
+            else:
+                assert (groups["_surface_workspace"] is workspace) == (first_count == count)
+                assert (packed_frames is workspace[0]) == (first_count == count)
+                assert packed_offsets is workspace[1] and capacity == workspace[2]
+                assert len(pipe.allocations) == (3 if first_count < count else 2)
+                assert packed_frames is pipe.allocations[-1 if first_count < count else 0]
+    assert len(entries.records) == 2
+    assert [record["rows"] for record in entries.records] == [first_count, count]
+    assert not torch.equal(outputs[0], outputs[1][:first_count])
+
+
 @pytest.mark.parametrize("failure,message", [
     ("nonfinite", "finite"), ("coincident", "must differ"),
     ("near", "1e6"), ("far", "1e15"),