Primitive-level synchronization removes global barriers in distributed PBNR training and returns computations to the critical path.
In distributed PBNR training, the system is limited not by rendering but by synchronization. Point-based neural rendering operates with sparse dependencies at the primitive level (primitive index), but most implementations use global barriers at the iteration level. This creates a structural conflict: each view updates only a subset of the scene but is forced to wait for the publication of all updates. As rendering optimization (latency reduction) progresses, the share of communication increases, and idle time between GPUs can reach 26%. The barrier turns local imbalance into systemic waiting.
The key issue is the granularity of synchronization. In PBNR, dependency is defined not by layers or tensors but by specific primitives. However, at the planning stage, it is unknown which specific primitives will be active: geometry provides only an upper estimate, while actual activity and gradients appear too late. As a result, systems choose a safe but coarse option—global synchronization.
Odin offers a shift in the boundary: primitive-level synchronization instead of iteration-level barrier. This is not a rejection of synchronization but a refinement of it. The system plans possible communication-computation overlap windows in advance, using stable locality (co-visibility), and then validates them at runtime before reading the state. If dependencies do not intersect, tasks are executed in parallel. If they do intersect, locking is applied only to specific primitives.
Architecturally, the solution is divided into two levels: planning and execution. At the ahead-of-time scheduler stage, a Relative Locality Graph (RLG) is constructed, where the nodes are views, and the edges reflect the probability of conflict through co-observability (SfM tracks). This is a trade-off: more accurate than geometry but cheaper and more stable than runtime tracing. The scheduler then groups tasks and orders them so that loosely connected views are processed consecutively, increasing the chance of overlap.
At the runtime stage, the system checks assumptions. Before a task reads the state, intersection checks are performed: read-after-write (RAW), write-after-write (WAW), write-after-read (WAR). If a conflict exists, waiting is limited only to the necessary primitive updates. This replaces the global barrier with point synchronization.
The key execution mechanism is the Shadow Graph. It provides each task with a logical representation of the state without full model replication. Updates are first written to a staging buffer and then published after validation. This eliminates aliasing and allows safe overlapping of computations and communication without increasing memory footprint.
An interesting trade-off is two operating modes:
- Quality-first: strict synchronization at the primitive level. Guarantees equivalence to synchronous training.
- Throughput-first: allows limited delayed reads if their impact is minimal. The solution is based on two conditions: small intersection size and low gradient (importance locality).
This is an important engineering trade-off. Instead of general async training, a domain-specific heuristic is used: in PBNR, the contribution of primitives is uneven due to occlusion and compositing.
From an implementation perspective, Odin is minimally invasive. It does not require changes to renderer kernels, optimizers, or models. Integration boils down to three hooks:
- access to candidate primitives before reading the state
- collection of active primitives and gradients after backward
- fixing the moment of publishing updates
Results show that synchronization was indeed the bottleneck. On average, the system provides 1.22× throughput on 8 GPUs and up to 1.89× in mixed-parallel scenarios (64 GPUs). Meanwhile, quality remains within ±1% of the baseline. Importantly, the acceleration is achieved not by reducing data or model size but by eliminating unnecessary waiting: up to 82% of the time on the critical path is hidden.
The system’s behavior depends on the scene structure. In dense scenes with high connectivity (many intersections among primitives), the gain is smaller—the system more frequently reverts to synchronization. In sparse scenes, the effect is maximized. This underscores that Odin optimizes the dependency structure rather than computations.
From an engineering standpoint, Odin fills an important gap. Most distributed training optimizations operate at the tensor or layer level. In PBNR, this level simply does not exist—the dependency lies deeper. Primitive-level synchronization effectively introduces a new level of dependency management.
In a broader context, this points to a trend: systems with explicit mutable state require more precise synchronization models. Global barriers become too costly as computations accelerate.
Information source
arXiv is the largest open preprint repository (since 1991, under the auspices of Cornell), where researchers quickly post working versions of papers; the materials are publicly accessible but do not undergo full peer review, so results should be considered preliminary and, where possible, checked against updated versions or peer‑reviewed journals. arxiv.org