WorksComputer Science
GSPIM: A Temporal-Locality-Aware 4D Gaussian Splatting Accelerator with Polymorphic PIM and Multi-Frame Rendering Dataflow
Abstract
4D Gaussian Splatting (4DGS) enables high-quality real-time novel-view synthesis for dynamic scenes, supporting free-viewpoint video, mobile XR, and autonomous systems at the edge. Methods using explicit 4D distributions, keyframe interpolation, or anchor binding share two GPU data-movement bottlenecks. Temporal filtering follows model record loading, wasting LPDDR5 bandwidth on inactive data. Frame-isolated execution also overlooks highly overlapping active sets and depth relationships across adjacent frames, reloading shared attributes when working sets exceed on-chip cache capacity. To address these bottlenecks, we present GSPIM, a temporal-locality-aware 4DGS accelerator for PIM-enabled edge devices. Polymorphic PIM adapts a shared near-memory datapath to representation-specific field layouts and selection procedures. It filters and compacts valid data into contiguous inputs before the GPU accesses complete attributes, reducing ineffective transfers. Multi-Frame Rendering Dataflow reuses active attributes and stable depth relationships within a temporal window, reducing repeated work across frames. Hybrid Dataflow Scheduling overlaps near-memory data preparation with GPU rendering to reduce waiting. Evaluation combines a GPU-PIM model calibrated to Jetson AGX Orin 64 GB with a 1z DRAM physical implementation of the added circuits. Across three 4DGS methods and six dynamic scenes, GSPIM achieves a 4.15x geometric-mean speedup and a 4.99x geometric-mean energy-efficiency improvement over a fully optimized frame-by-frame GPU baseline. The maximum scene-level PSNR difference is 0.011 dB, and the added physical footprint is 18.7172 square millimeters across 32 LPDDR5 dies.
Introduction
Novel-view synthesis for dynamic scenes [2, 6, 9, 36, 57, 62] reconstructs time-varying 3D scenes from multi-view videos and generates high-quality images at arbitrary times and viewpoints, providing real-time visual content for free-viewpoint video [10], mobile XR [53], volumetric telepresence [61], and autonomous systems [46]. 3D Gaussian Splatting (3DGS) [20, 38] represents a static scene with an explicit set of Gaussians and achieves high-quality real-time rendering through projection, sorting, and forward compositing. 4D Gaussian Splatting (4DGS) [27, 34, 62, 65] further describes temporal scene variation, allowing the same dynamic representation to generate the corresponding 3D Gaussians at consecutive timestamps. Explicit 4D distributions jointly model spacetime, keyframe interpolation generates continuous motion from sparse samples, and anchors share temporal parameters to reduce redundancy. They determine activity from per-record temporal fields before loading geometry and appearance for per-frame rendering. Edge GPUs provide a programmable platform, but limited LPDDR5 bandwidth and on-chip cache capacity make large-scale Gaussian data movement a primary constraint on real-time inference.
This work was supported by National Key R&D Program of China (Grant No.2023YFB4503500), National Natural Science Foundation of China (Grant No.62502498, 62672477), Innovation Funding of ICT, CAS (Grant No. E661120).
Prior work reduces the software overhead of 4DGS through representation compression, primitive pruning, and CUDA kernel optimization [62, 65, 66], while specialized accelerators build generation and rendering datapaths around specific temporal representations [16, 60]. Existing specialized accelerators exploit spatial or inter-frame correlation but do not organize shared source attributes into multi-frame batches. Our analysis of frame-by-frame GPU execution reveals two data-access problems. First, temporal filtering occurs after data access, leaving 73.3% to 86.8% of LPDDR5 transfers unused by subsequent computation. Second, adjacent frames have highly overlapping active sets and depth relationships, yet frame-isolated execution repeatedly loads attributes shared across frames. These problems arise from late temporal decisions and a frame-by-frame GPU dataflow that does not organize shared attributes for window-level reuse.
To address these data-movement bottlenecks, we present GSPIM, an edge 4DGS accelerator that exploits temporal locality to improve throughput (see Figure 1). Polymorphic PIM (PPIM) maps local decisions for different temporal representations to a programmable bank-side datapath. Its selection results drive bank- and die-level compaction, removing inactive attributes and packing valid data contiguously before GPU access to reduce ineffective LPDDR5 transfers. Multi-Frame Rendering Dataflow groups shared attributes into batches that fit in L2. It reuses attributes and sorting results for stable primitives across frames in each window, reducing repeated loads and per-frame sorting. Hybrid Dataflow Scheduling overlaps near-memory data preparation with GPU computation across windows and batches, reducing resource idle time from serial stage execution. This work makes the following contributions.
Figure 1. 4DGS pipeline, memory-access bottlenecks, and GSPIM overview.
(i) We propose Polymorphic PIM. PPIM maps local decisions from different 4DGS representations and dataflow stages onto a shared fixed-point datapath. It produces a unified selection result that drives bank- and die-level data compaction, excluding ineffective attributes before they reach the GPU.
(ii) We propose a Multi-Frame Rendering Dataflow and its Hybrid Dataflow Scheduling. The dataflow reuses active attributes and stable depth relationships within temporal windows and sorts only primitives with substantial depth variation per frame. Double buffering sustains concurrent near-memory batch preparation and GPU multi-frame rendering across consecutive windows and batches.
(iii) We implement the near-memory hardware of GSPIM in Chisel RTL and evaluate it on a GPU–PIM simulation platform calibrated to the Jetson AGX Orin 64 GB.1 Across three 4DGS methods and six scenes, GSPIM achieves a geometric-mean speedup and a geometric-mean improvement in energy efficiency over a fully optimized frame-by-frame GPU path. The maximum scene-level PSNR difference is dB, while SSIM differs from the baseline by at most . In 1z DRAM, the added circuits have a physical footprint of mm and active power of W across 32 dies.
Background and Motivation
4D Gaussian Splatting
3D Gaussian Splatting (3DGS) [20] represents a static scene as Gaussian primitives with a 3D center, covariance, opacity, and appearance. Rendering applies projection, depth sorting, and forward compositing. 4D Gaussian Splatting (4DGS) adds temporal variation to generate 3D Gaussians across timestamps. Efficient explicit representations use 4D distributions, keyframe interpolation, or anchor binding. Explicit 4D Gaussians [62, 65, 66] jointly encode spacetime in 4D means and covariances, supporting temporal slicing. Keyframe interpolation [27] generates continuous motion from sparse attribute samples. Anchors [34] share temporal parameters within valid intervals to generate or select bound Gaussians.
Near-bank temporal filtering targets representations that explicitly store local temporal fields in Gaussian or anchor records and uses these fields to determine window activity. As shown on the left of Figure 1, temporal filtering selects active records, and 3D Gaussian generation loads their geometric and appearance attributes to construct standard 3D Gaussians at each timestamp. View projection computes screen positions and 2D footprints, depth sorting determines compositing order, and rasterization accumulates pixel color and transmittance in that order to produce the output image. Field layouts, decision procedures, and Gaussian counts per record differ, but activity determines attribute access. GPU-side temporal filtering incurs ineffective transfers before selection, while frame-by-frame sorting and rasterization reload shared attributes. Highly overlapping active sets and depth relationships across frames offer attribute and sorting reuse opportunities.
Processing in Memory
Edge GPUs commonly share LPDDR memory with CPUs and media engines, making data movement costly under limited bandwidth and cache capacity. Processing in Memory (PIM) [4, 5, 11, 19, 22, 26] adds lightweight computation to bank peripherals or intra-die datapaths, allowing filtering, reduction, and data reorganization before the GPU accesses complete data. Prior studies [1, 15, 30, 31] show that memory-intensive workloads benefit from reduced data movement and energy use.
The temporal processing of 4DGS matches these characteristics. Each of millions of model records needs only a few local temporal fields to produce a compact activity result controlling access to much larger geometric and appearance attributes. Despite differing field layouts and temporal computations, activity decisions use bounded arithmetic or interval tests over fixed ranges of local fields. Figure 2(a) shows that temporal filtering accounts for 52.4% to 63.3% of baseline execution time on Jetson AGX Orin, while sorting and rasterization together account for 26.5% to 34.8%. Their arithmetic intensities fall below the corresponding roofline ridge points in Figure 2(b), with temporal filtering lowest. Near-memory compaction and reorganization use these decisions to exclude inactive records before attribute transfer and provide contiguous inputs for sorting and rendering, reducing wasted transfers and scattered accesses during both initial filtering and subsequent data preparation. Configurable field access and decisions support different 4DGS representations on a shared PIM datapath, while the GPU generates their standard 3D Gaussians and performs projection, sorting, and rasterization.
Figure 2. Baseline stage time and roofline on AGX Orin.
Challenges in Accelerating Edge 4DGS
We analyze 4DGS-1K [65], Ex4DGS [27], and Anchored 4DGS [34] on a Jetson AGX Orin 64 GB. These methods cover explicit 4D Gaussians, keyframe interpolation, and anchor binding, respectively. We use N3V [33] and EasyVolcap [59], which include local object motion, large nonrigid motion, and varying degrees of occlusion change. All three methods use fully optimized CUDA paths under the same LPDDR5 and 4 MB L2 configuration, exposing two common limits to efficient edge 4DGS inference.
a) Challenge 1: Ineffective loads caused by GPU-side temporal filtering: Dynamic scenes exhibit inherent temporal sparsity. Foreground objects usually appear over a limited interval of the complete sequence, while static backgrounds remain active for long periods. Consequently, only a subset of model records produces valid Gaussians in any temporal window. Figure 3 shows that more than 70% of the primitives in 4DGS-1K are discarded after temporal filtering, resulting in 77.4% to 86.8% ineffective memory transfers. In Ex4DGS, keyframe intervals outside the current window cause 73.3% to 82.0% ineffective transfers. In Anchored 4DGS, each inactive anchor controls multiple Gaussians, yet its activity is known only after fetching anchor parameters and binding relations, causing 75.5% to 84.0% ineffective transfers.
Figure 3. Temporal sparsity and ineffective Gaussian loading.
Existing GPU dataflows first read temporal fields from LPDDR5 and then determine activity. Active and inactive records are interleaved by global ID across attribute arrays, so cache-line accesses also fetch adjacent inactive fields and consume limited L2 capacity. This process wastes both the temporal fields discarded after the decision and the geometric and appearance attributes unnecessarily prefetched for the current window. Temporal fields occupy only 8 B to 52 B per record across the three representations, but determine whether as many as 584 B of subsequent attributes must be accessed.
Across all three representations, GPU-side activity decisions make temporal filtering a common LPDDR5 bottleneck because ineffective accesses have already occurred.
b) Challenge 2: Frame-isolated rendering causes repeated loading of reusable Gaussians: The temporal continuity of dynamic scenes gives adjacent frames highly overlapping active sets and depth relationships [49]. Figure 4 shows that active sets retain high Jaccard similarity across all scenes within temporal windows of two to five frames. Across all evaluated methods and scenes, five-frame active-set similarity remains at least 75.3%. Actor1_4 has the lowest-overlap case because its large nonrigid motion and occlusion changes replace more Gaussians within a window. These Gaussians share model attributes, while their per-frame geometry and depth relations vary smoothly enough to remain reusable across consecutive frames in the same temporal window.
Frame-isolated 4DGS dataflows reaccess active primitives, generate projections, and construct a depth order per frame. The per-frame active working set commonly exceeds the 4 MB AGX Orin L2 cache, while projection, sorting, and rasterization intermediates consume additional capacity. Shared attributes are thus evicted before the next frame uses them. As the window grows, unique Gaussians increase slowly, but cumulative multi-frame accesses grow approximately with frame count. Limited edge cache capacity prevents temporal overlap from yielding reuse, leaving frame-isolated execution to repeat LPDDR5 accesses and attribute loads.
Our Approach
GSPIM exploits temporal locality in edge 4DGS, sharing window execution across GPU and PIM through Polymorphic PIM and Multi-Frame Rendering Dataflow.
Figure 4. Cross-frame reuse under frame-isolated rendering.
a) Polymorphic PIM: Polymorphic PIM maps the field layouts and decision procedures of different 4DGS representations onto a shared near-memory datapath and produces a uniform selection result before geometric and appearance attributes are accessed. The result drives a separate two-level path that compacts sparse valid data into contiguous stage inputs, reducing scattered access and cache-line overfetch.
b) Multi-Frame Rendering Dataflow: Multi-Frame Rendering Dataflow groups consecutive frames into a temporal window and shared attributes into batches, reducing repeated loads. The GPU reuses each batch across frames while preserving per-frame depth order, as near-memory execution prepares the next batch without increasing GPU cache pressure.
GSPIM Dataflow
GSPIM adopts a Multi-Frame Rendering Dataflow that processes consecutive frames within a temporal window in batch-major order to reuse active Gaussian primitives (Figure 5). PPIM makes activity and stability decisions, the Hierarchical Compaction Fabric (HCF) compacts, reorganizes, and packs data, and the GPU generates geometry, computes depths, sorts, merges, batches, and renders. For temporally sparse 4DGS representations with different temporal parameterizations, Stage 1 configures activity computations from local temporal fields, while later stages process standard 3D Gaussian parameters.
Figure 5. GSPIM multi-frame rendering dataflow.
Stage 1: Temporal Filtering and Compaction
Stage 1 performs temporal filtering and compaction over the current temporal window , where and denote the start and end of the window. To address the sparse, interleaved activity in Challenge 1, PPIM reads local temporal information to determine window activity and produces a one-bit result per primitive as the Active Map. HCF compacts marked primitives into a contiguous Active Buffer. Stage 2 generates all frame-specific 3D Gaussians from this buffer.
Stage 2: Multi-Frame 3D Gaussian Generation
Stage 2 uses the current temporal window as a GPU batch and generates the corresponding 3D Gaussians for all frames in parallel. The GPU configures the computation for each 4DGS representation. Frame channels reuse the active data in the Active Buffer and use their corresponding frame timestamps to compute the 3D mean and covariance of every active primitive. This stage converts representation-specific temporal variation into a uniform sequence of multi-frame 3D Gaussians, allowing subsequent stages to process a common data format and providing Stage 3 with the 3D centers of all frames in the window.
Stage 3: Depth Stability Score Classification
Stage 3 first transforms the 3D centers in the window into camera coordinates on the GPU. For camera-space depth and rendering bounds and , GSPIM forms the dimensionless sequence , where . To preserve visibility, conventional 4DGS methods commonly perform global depth sorting over all primitives in every frame, incurring substantial repeated sorting overhead. Depth changes across adjacent frames are usually smooth in natural scenes, while only a small subset of primitives experiences substantial changes because of fast motion or sudden occlusion. Based on this observation, GSPIM uses a depth stability score to describe the depth stability of each primitive within a window and maps its average depth variation into a normalized range through exponential decay:
A high indicates stable cross-frame depth, while a low value indicates substantial variation. The GPU reduces the average depth change while generating the depth sequence, and PPIM produces a classification bit through a threshold comparison equivalent to , where is the stability threshold. According to the two values of this bit, HCF organizes the indices and sorting keys of the two primitive classes into separate contiguous sequences, allowing the Stage 4 GPU to read both sorting inputs contiguously. Source attributes and per-frame geometry remain in their original regions. The mean over all window primitives reflects overall dynamics. A mean below the window-adjustment threshold indicates greater depth variation and a larger unstable proportion, so the system shortens the next window by one frame to limit reuse under fast changes. Otherwise, it adds one frame within the two-to-five-frame range, as most primitives retain stable cross-frame depth relationships and share classification and sorting across more frames.
Stage 4: Sorting and Batch Scheduling
a) Stability-aware differentiated sorting: Prior work [7] shows that depth sorting [50] is a major cost in the Gaussian Splatting pipeline. Our measurements show that follows the same trend as cross-frame position retention, with high- primitives preserving their depth ranks more consistently. than low- primitives. The stable set and unstable set produced by threshold classification therefore have different sorting requirements. GSPIM exploits this distinction through stability-aware differentiated sorting, assigning each set a separate key, frequency, and algorithm.
Let the stable and unstable sets contain and primitives, respectively. For , the relative occlusion order remains nearly unchanged within a window, so one radix sort using the per-window minimum depth serves all frames and amortizes the fixed-width sorting cost over the complete window. To preserve visibility for , GSPIM still performs per-frame local radix sorting. Most primitives remain stable within a window in our experiments, so per-frame sorting applies only to the smaller unstable set and costs per frame. The GPU uses parallel merge-path [41] to merge the shared stable sequence with per-frame unstable sequences into render order lists (ROLs) for all frames.
b) Batching: To preserve both cross-frame attribute reuse and per-frame depth order under limited L2 capacity, GSPIM uses the window-level order of stable primitives as a shared batch boundary across frames. The stable portions of the per-frame ROLs preserve a common relative order, and their differences primarily arise from where unstable primitives are inserted. A shared boundary can therefore align the same stable primitives within one batch. The GPU extends the current batch along the stable sequence and gathers primitives between the same boundaries in every frame ROL. Shared attributes are stored once, while local orders retain per-frame differences. Based on the actual space occupied by attributes, local indices, and rasterization intermediates, the system selects the largest stable interval that fits within the effective L2 capacity. One load of the same attribute batch consequently serves multiple frames in the window, while every frame still performs depth-ordered compositing according to its original ROL.
Stage 5: Batch Multi-Frame Rendering
Stage 5 renders Stage 4 batches through the standard 3DGS rasterization pipeline [20]. The GPU loads shared attributes of the current batch into L2 for reuse across window frames, combining them with per-frame dynamic fields for 2D projection, tile assignment, and forward compositing. The GPU follows per-frame local batch orders, retaining color and transmittance across batches to preserve the original ROL in the concatenated sequence. While the GPU reuses these attributes to render the current batch, HCF packs the shared attributes and per-frame fields for the next group of indices into another Batch Buffer. The next batch stays in main memory until the switch, outside L2. After batch completion, the Batch Buffers swap roles, pipelining multi-frame rendering with preparation of the next attribute batch.
GSPIM Architecture
As shown in Figure 6, GSPIM integrates Polymorphic PIM (PPIM) and a Hierarchical Compaction Fabric (HCF) within a rank. PPIM resides in PIM banks and performs representation-specific local decisions. HCF filters data within PIM banks according to the masks produced by PPIM and gathers results from multiple banks into reserved banks (Res. Banks).
Figure 6. GSPIM architecture.
Polymorphic PIM
Different temporal parameters and associations encode 4DGS scene variation, but a few local fields determine window activity and cross-frame depth stability. GSPIM places PPIM beside each PIM-bank row buffer to support these decisions through the shared near-memory computation path in Figure 6(c). The column multiplexer reads the required local fields from the row buffer of its bank. Floating-point decision fields pass through a bank-side FP32 Converter before entering PPIM registers. It aligns significands by exponent and rounds to , representing . The bank program buffer instructs shared fixed-point units through the interconnect to run short programs and generate block-level masks. Decision-field reads, conversion, computation, and mask generation remain bank-local before HCF filters and gathers selected data. Programs derived from static representation layouts are written into every PIM-bank program buffer at model loading. PPIM combines 20 fractional bits, giving a quantization step below , with six integer bits including the sign, yielding signed 26-bit operands over [−32, 32). Conversion error is at most without overflow. Program constants share this scale. Multiplication retains full 52-bit products until register writeback restores 20 fractional bits.
To translate PPIM decisions directly into fewer data reads, GSPIM modifies the original bank access path into a mask-controlled column-selection path. The column decoder selects fields from the row buffer according to the access address, and the masked multiplexer retains fields selected by the PPIM mask before forwarding them to the bank interface. Regular GPU accesses use a fully valid mask, while data compaction uses the S1 window-activity mask or the S3 depth-stability mask to filter target fields before they leave the bank. For results within one output least-significant bit of a threshold, S1 retains the Gaussian and S3 assigns it to the unstable set for per-frame sorting, limiting quantization effects on filtering and classification. The computation path adapts to different decisions through programs, while the access path controls data output through a uniform mask.
Hierarchical Compaction Fabric
To convert distributed selection results into contiguous data, HCF uses an L1 Bank-Level Compactor in each PIM bank and an L2 Die-Level Compactor in each die. L1 filters row-buffer fields by mask. Figure 7 shows L2 scanning the ActiveMap FIFO, allocating contiguous destinations, and gathering selected data across banks. The four Res. Banks share the Active Buffer, classification sequences, and ping-pong Batch Buffers according to their live ranges, with overflow redirected to GPU reorganization. The Memory Access Arbiter prioritizes refresh, then GPU over HCF for same-bank conflicts. Before all-bank refresh, the target rank stops new accesses, drains in-flight transfers, and pauses PPIM and HCF. PPIM retains its instruction position and registers, while HCF retains FIFO contents and transfer progress. After refresh, execution resumes once the required rows are reactivated under normal access timing.
Figure 7. L2 die-level compactor.
HCF reuses one path in S1, S3, and batch packing. S1 compacts window-active data into a contiguous Active Buffer so S2 skips inactive attributes. In S3, L2 allocates separate stable and unstable destinations, applying the classification mask and its inverse to form contiguous sorting metadata and narrow the S4 per-frame sorting access range. For each S4 batch, HCF gathers shared attributes and per-frame fields into a Batch Buffer for contiguous S5 GPU loads and within-window attribute reuse. These uses share selection scanning, address generation, gathering, and contiguous writeback, differing only in selection inputs and destination layouts.
Data Mapping
To allow a PPIM mask to directly locate fields accessed later, GSPIM organizes model records into fixed-size data blocks. At model loading, the runtime distributes blocks across PIM banks and allocates row regions for decision fields and their associated attributes or sorting metadata from a driver-managed physical memory pool, selecting a channel, die, and bank for each block. Field writes preserve original values, precision, Gaussian associations, and common record order. Field row bases and record strides determine the row and column positions of each record. The runtime constructs each DRAM burst address from these positions. With XOR interleaving, the physical bank-selection bits are the XOR of the target bank identifier and the corresponding interleaving term, preserving the selected bank as row and column positions change. Allocated physical pages remain fixed throughout block use, and layouts retain field row bases and record strides for reuse across windows.
S1 temporal fields are written in this layout at model loading, while the GPU writes S3 stability-decision fields and associated sorting metadata directly to preallocated positions. This shared record order allows the masked multiplexer to filter corresponding records using the mask generated from decision fields read by the column multiplexer. When one decision record corresponds to one Gaussian, its mask bit directly identifies the aligned attributes of that Gaussian. In representations where one temporal record is associated with multiple Gaussians, the model stores the start position and count of that Gaussian range within the same die, and L2 reads attributes in the corresponding range for each selected record. After S1 completes mapping and compaction, it generates an Active Index for every retained Gaussian. The multi-frame geometry from S2, classification metadata from S3, and batch selections from S4 retain this index, allowing later reorganization to locate fields regardless of how the source representation stores its records.
Figure 9. GSPIM hybrid dataflow scheduling.
GSPIM Runtime
Task Offloading Interface
GSPIM separates GPU and PPIM compilation. S2–S5 use the CUDA toolchain, whereas representation-specific decisions in S1 and S3 compile into PPIM microcode for field access, fixed-point arithmetic, comparison, and mask generation. Each model package contains the activity program, temporal-field layout, attribute mapping, and shared stability program. The runtime loads this metadata through standard LPDDR5 WRITE commands and submits two die-level tasks through reserved control addresses to the on-die command frontend. PIM_SELECT executes a PPIM program and records block masks. PIM_REORG uses HCF to count selected data, allocate contiguous ranges, and perform S1 compaction, S3 classification reorganization, or batch packing. Per-die in-order submission allows reorganization to consume the preceding selection result, while anchor-based paths allocate output space from binding lengths. Standard READ commands retrieve task status maintained by the completion unit. Task submission and completion queries reuse the existing host LPDDR5 controller and PHY. Table 1 summarizes both tasks.
| Command | Description |
| PIM_SELECT | Generate block-level masks with a PPIM program |
| PIM_REORG | Reorganize selected data into contiguous ranges |
Table 1. LIST OF GSPIM COMMANDS.
For S1 and S3, the runtime submits PIM_SELECT followed by PIM_REORG for each die. Batch preparation directly submits PIM_REORG using GPU selections. HCF exposes completed-block output ranges so the memory controller can release dependent GPU tasks, reporting the final output count when the task completes. The runtime writes source cache lines back before PIM execution and invalidates destination lines before GPU consumption. Figure 8 shows two S1 programs, whose uppercase labels denote PPIM micro-operations rather than host commands. Explicit 4D Gaussian selection sums squared, per-dimension-scaled temporal rotation-matrix row entries to obtain temporal variance. Anchor-based selection tests temporal overlap and expands selected anchors via a binding table. Both use PIM_SELECT to form masks and PIM_REORG to compact Active Buffers.
Figure 8. PPIM programming examples.
Hybrid Dataflow Scheduling
To remove resource idleness caused by window-level stage serialization, GSPIM uses Hybrid Dataflow Scheduling according to cross-stage dependencies. For S1–S3, whose dependencies are confined to the same data block, a fine-grained block pipeline starts S2 for the first Active Buffer block as soon as HCF produces it, and uses available depth results to trigger S3 classification and reorganization. This policy reduces interstage synchronization to one data block. S4–S5 require a complete window to establish global depth order, so a coarse-grained batch pipeline preserves sorting boundaries while overlapping data preparation with rendering. After S3 determines the width of the next window, PPIM begins S1 selection for that window concurrently with S4 and S5 of the current window. The GPU, PPIM, and HCF thus run continuously at each stage’s required granularity, reducing intra-window and cross-window resource waits.
Figure 9(b) illustrates the steady execution rhythm formed by the hybrid dataflow. After the first window starts, each Active Buffer block triggers its corresponding S2 and S3 tasks, overlapping GPU consumption with subsequent selection and compaction. Once S3 adjusts the next window width to , , or , GPU sorting and rendering for the current window primarily access Res. Banks, while S1 for the next window reads temporal fields from PIM banks. These accesses mainly target different banks, reducing same-bank contention. HCF processes batch packing and S1 compaction in dependency order and gathers selected data into Res. Banks. Its ActiveMap FIFO retains selection results produced early by PPIM and continues forming the Active Buffer when the reorganization path becomes available. Adjacent windows repeat this rhythm, keeping selection, data reorganization, and GPU computation continuously overlapped.
Methodology
Workloads
We evaluate three representative 4DGS workloads: 4DGS-1K (1K) [65], Ex4DGS (Ex) [27], and Anchored 4DGS (Anch.) [34]. They cover activity-mask filtering, keyframe interpolation, and anchor binding. N3V [33] and EasyVolcap [59] span indoor and outdoor scenes with local, nonrigid, and occlusion changes. For a fully optimized GPU comparison, we connect representation-specific temporal computation and common Gaussian operators to a unified CUDA backend. CUB primitives implement filtering, prefix sums, and segmented radix sorting, and gsplat [63] provides projection and rasterization. We tune thread configurations and batch sizes for each method on AGX Orin and verify frame-by-frame outputs against the original implementations. Sensitivity curves use representative smooth and nonrigid scenes, with selected thresholds verified across all workloads and datasets.
| GPU Configuration (AGX Orin) | PIM-LPDDR5 Configuration | ||
| GPU Core Frequency | 1.30 GHz | LPDDR5 Packages | 8 |
| SM Count | 16 | Dies / Package | 4 |
| L2 Cache Capacity | 4 MB | Banks / Die | 16 (12 PIM, 4 Res.) |
| LPDDR5 Bandwidth | 204.8 GB/s | Total PIM Units | 384 |
| LPDDR5 Capacity | 64 GB | PIM Frequency | 200 MHz |
| LPDDR5 Timing Parameters | |||
| = 18.75 ns, = 18.75 ns | = 42.5 ns, = 280 ns | ||
| = 5 ns, = 2.5 ns | = 5 ns, = 20 ns |
Table II. Hardware configuration of GSPIM.
Baselines
a) GPU Baselines: We evaluate the GPU paths on NVIDIA Jetson AGX Orin 64 GB in MAXN mode with fixed GPU and memory frequencies. The frame-by-frame and multi-frame versions share the optimized CUDA backend. AGX Orin + GSPIM Dataflow is a software-only GPU version implementing the complete multi-frame dataflow in CUDA. It filters and generates Gaussians by window, reuses sorting results for the stable set, and renders frames with shared attribute batches sized to fit L2. Full GSPIM retains this multi-frame flow and offloads selection and data reorganization to PPIM and HCF. All paths share parameters, rendering settings, and compilation options. After warmup, CUDA events time stages and end-to-end execution, while Nsight Systems and Compute trace kernels and memory accesses.
b) Specialized Accelerators: The specialized baselines are 3DGauCIM [16], QI-4DGS [60], and Relay-GS [23]. 3DGauCIM uses FP16, 256 KB SRAM, 144 KB DCIM, grid and tile-block sizes of 4, a grouping threshold of 0.5, and eight AII-Sort partitions. QI-4DGS uses 16 fused recursive opacity units, eight tree-rendering PE lines, and 204 KB SRAM, selecting native generation or interpolation by motion criteria. Relay-GS reuses prior-frame sorting with periodic correction, a fine-grained pipeline, and parameter-sharing rasterization. We reconstruct cycle/power models from architecture/circuit data and reproduce original workloads and reference configurations, with maximum relative throughput/power errors below 1.5%. All systems share the native explicit 4DGS model, camera path, resolution, precision, thresholds, and 256-bit LPDDR5-6400. 3DGauCIM, Relay-GS, and GSPIM retain native generation. QI-4DGS enables adaptive quadratic frame interpolation (AQFI) by default, with an AQFI-off control retaining opacity recurrence and tree rendering on the native generation path. ASIC area and power scale to 8 nm via DeepScaleTool interpolation to 10 nm and Samsung 10LPP-to-8LPP factors [47], [48]. With external memory and shared control/interconnects counted, the remaining GSPIM system area budget determines replication counts from normalized tile areas including local storage. Tile organization, frequency, and replication stay fixed across scenes, and energy efficiency includes complete systems and external memory.
Hardware Evaluation
a) Cycle Simulation: We implement PPIM, HCF, and the DRAM-side command and status circuits in Chisel RTL. Their Verilator cycle models are integrated into Ramulator 2.0 [39] for LPDDR5-6400 timing, including interface and cache-coherence overheads. The controller receives PIM_SELECT and PIM_REORG tasks and jointly schedules bank requests, GPU memory traces, and all-bank refresh under LPDDR5 timing, with refresh lasting 280 ns every 3.9 s.
b) Timing and Energy: Using tbl:II, we calibrate the timing model against AGX Orin bandwidth microbenchmarks and Nsight Compute memory traces. Under matching workloads, maximum relative errors are 1.4% for bandwidth and 1.2% for memory-access latency. We compare functional outputs with a per-primitive software implementation. We amortize window execution time per frame, accounting for task dependencies, measured GPU-stage times, simulated PIM time, refresh pauses, and GPU memory waits added by PIM traffic and refresh. GPU-side energy integrates onboard GPU and SoC rail measurements across replay execution and waiting. Replay follows the joint task schedule with functional-model inputs. PIM energy combines 1z switching-based dynamic energy and leakage over the full interval. LPDDR5 command and state traces determine read, write, refresh, and background energy. System and GPU-side efficiencies use matching frame-by-frame Orin references.
c) Physical Implementation: We synthesize, place, and route added DRAM-side circuits using a 1z DRAM peripheral-logic library under baseline LPDDR5 bank- and die-periphery constraints. PPIM and L1 compactors sit beside PIM-bank row buffers, with HCF paths, command and completion circuits shared per die. PPIM operates at 200 MHz. Power uses cycle-simulation workload VCDs at 1.05 V, TT, and 25°C. Icepak models the four-die stack, PCB, and module cooling in 3D with 40°C inlet air at 1 m/s. LPDDR5, PIM, and SoC power traces include leakage updated with temperature.
Evaluation
Performance and Quality
a) Performance: In Figure 10, window-level selection, stable-set sorting reuse, and attribute sharing give GPU dataflow speedup and 46.8%/48.2% P95/P99 reductions over AGX Orin (geometric means). GPU selection and compaction require full-set scans and intermediate writes, prolonging preparation. Early PPIM selection and contiguous HCF packing reduce inactive-attribute transfers. Overlapping preparation with GPU generation and rendering reduces window waits. Full GSPIM achieves a geometric-mean speedup over AGX Orin. Relative to GPU dataflow, mean amortized per-frame time, P95, and P99 fall by 55.2%, 44.2%, and 43.5% (geometric means). Under strong nonrigid motion in Actor1_4, Anchored 4DGS P99 falls from 7.81 to 4.77 ms.
Figure 10. Steady-state throughput and amortized per-frame execution time (P95/P99) under identical ready-window submission.
Figure 11 shows accumulated task execution and waiting times normalized to AGX Orin + GSPIM Dataflow. GSPIM offloads S1, which occupies 36.1% to 47.5% of the GPU dataflow time, to PIM and reduces S3 and S5 GPU work through HCF reorganization, reducing summed GPU stage execution time by 54.1% to 61.1%. PPIM selects next-window active records from local bank fields, alongside current-window GPU sorting and rendering that mainly access other banks. Cross-frame L2 attribute reuse and HCF preparation of the next batch in another Batch Buffer reduce repeated reads and concurrent current-batch accesses. Command handling and pre-execution queuing take 10.2 to 28.6 s and 41.4 to 49.0 s per die per window. Contention stalls average 1.8% and 7.7% of total GPU and PIM task time. PIM task execution totals 16.2% to 21.1% of GPU dataflow time and overlaps GPU execution. Block and batch pipelines hide most refresh pauses, with throughput loss relative to disabled refresh averaging approximately 0.25% and peaking at 0.35%.
Figure 11. Stage-wise GPU and PIM task execution and waiting times.
b) Energy Efficiency: In Figure 12, software-only AGX Orin + GSPIM Dataflow achieves a geometric-mean energy-efficiency improvement through sorting and attribute reuse. CUDA selection and compaction limit further savings. PPIM selection and HCF batching reduce GPU work and repeated transfers, yielding a geometric-mean energy-efficiency improvement in measured GPU task replay. Including PIM dynamic and leakage energy, together with LPDDR5 active and background energy, gives a system improvement. The AGX Orin software path could extend to desktop or server CUDA GPUs, with gains set by cross-frame reuse, cache capacity, and memory bandwidth.
Figure 12. System and measured GPU task replay energy efficiency, normalized to matching frame-by-frame AGX Orin references.
c) Comparison with Specialized Accelerators: In Figure 13, GSPIM reaches geometric-mean native 4DGS throughput over AGX Orin at equal system area. 3DGauCIM [16] combines coarse-grid selection, bucket and grouping reuse, and digital CIM. GSPIM applies record-level selection in programmable PIM before full attribute access, cutting traffic and improving throughput by 32.9% and energy efficiency by 6.4%. QI-4DGS [60] reduces computation through interpolation, sorting merges, opacity recurrence, and tree compositing. GSPIM retains native generation and batches inputs across frames, exceeding AQFI-enabled QI throughput and energy efficiency by 39.8% and 11.8%. With AQFI off, QI has geometric-mean throughput. GSPIM is as fast on the same generation path. Relay-GS [23] combines temporal sorting reuse, pipeline overlap, and rasterization parameter sharing. GSPIM batches generation inputs, attribute loads, and stable-set sorting across frames, amortizing transfers for 18.7% higher throughput and 24.4% higher energy efficiency. Temporal sparsity or large active sets amplify savings in Flame Steak, Dance3, and Actor1_4, with Dance3 reaching 3.98×. Greater per-frame generation and rasterization favor specialized arithmetic in Cook Spinach and Sear Steak. GSPIM retains at least 92.1% of baseline energy efficiency.

Figure 13. Iso-area throughput and energy efficiency.
d) Quality: Table 3 reports scene-level quality relative to AGX Orin. GPU dataflow and full GSPIM differ from the baseline by at most 0.006 dB in PSNR and 0.0001 in SSIM at the reported precision. Conservative PPIM boundary handling adds no further difference at this precision. tbl:4 evaluates a separate native 4DGS model on the same six scenes, accounting for different Orin reference PSNRs from the three models in Table 3. GSPIM differences peak at 0.010 dB and 0.0003, each below 0.04%.
| Workload | Dataset | PSNR↑ Base / Dataflow / GSPIM | SSIM↑ Base / Dataflow / GSPIM |
| 4DGS-1K | Coffee Martini | 27.890 / 27.889 / 27.889 | 0.9166 / 0.9166 / 0.9166 |
| 4DGS-1K | Cook Spinach | 32.947 / 32.945 / 32.945 | 0.9561 / 0.9560 / 0.9560 |
| 4DGS-1K | Sear Steak | 33.094 / 33.094 / 33.094 | 0.9627 / 0.9627 / 0.9627 |
| 4DGS-1K | Flame Steak | 33.271 / 33.268 / 33.268 | 0.9614 / 0.9614 / 0.9614 |
| 4DGS-1K | Dance3 | 29.226 / 29.224 / 29.224 | 0.9063 / 0.9063 / 0.9063 |
| 4DGS-1K | Actor1_4 | 28.137 / 28.135 / 28.135 | 0.8449 / 0.8449 / 0.8449 |
| Ex4DGS | Coffee Martini | 28.684 / 28.684 / 28.684 | 0.9184 / 0.9184 / 0.9184 |
| Ex4DGS | Cook Spinach | 33.096 / 33.093 / 33.093 | 0.9563 / 0.9563 / 0.9563 |
| Ex4DGS | Sear Steak | 33.435 / 33.434 / 33.434 | 0.9602 / 0.9602 / 0.9602 |
| Ex4DGS | Flame Steak | 33.796 / 33.790 / 33.790 | 0.9628 / 0.9628 / 0.9628 |
| Ex4DGS | Dance3 | 29.310 / 29.309 / 29.309 | 0.9067 / 0.9067 / 0.9067 |
| Ex4DGS | Actor1_4 | 28.153 / 28.153 / 28.153 | 0.8454 / 0.8454 / 0.8454 |
| Anchored 4DGS | Coffee Martini | 27.937 / 27.937 / 27.937 | 0.9047 / 0.9047 / 0.9047 |
| Anchored 4DGS | Cook Spinach | 30.355 / 30.355 / 30.355 | 0.9387 / 0.9387 / 0.9387 |
| Anchored 4DGS | Sear Steak | 32.559 / 32.559 / 32.559 | 0.9590 / 0.9590 / 0.9590 |
| Anchored 4DGS | Flame Steak | 31.616 / 31.616 / 31.616 | 0.9489 / 0.9489 / 0.9489 |
| Anchored 4DGS | Dance3 | 28.195 / 28.195 / 28.195 | 0.8944 / 0.8944 / 0.8944 |
| Anchored 4DGS | Actor1_4 | 27.334 / 27.334 / 27.334 | 0.8207 / 0.8207 / 0.8207 |
Table 3. GSPIM rendering quality versus baseline.
e) Worst-Case Error Analysis: In the 24-frame Dance3 camera-motion sequence with 4DGS-1K, nearby stable Gaussians can exchange depth order despite small depth changes, amplifying differences at high-contrast overlaps. Camera-space depth accounts for pose. Preserved attributes and per-frame projections confine errors to alpha-compositing order, weighted by opacity and foreground transmittance 2. In Figure 14(a), PSNR loss peaks at 0.030 dB (frame 11) and LPIPS increase at approximately 0.0013. Consistent stable-set order avoids reordering jumps. Frames 11–12 yield mean motion-compensated temporal warping error (TWE) of approximately (Figure 14(c,Figure 14d)). Figure 14(b) shows GPU window dataflow at 1.88× (full sorting) and 2.39× (reuse) over Orin, a 1.27× gain. Full GSPIM reaches 4.73× throughput near-memory selection, reorganization, and pipeline overlap.
Figure 14. Sorting-reuse quality, execution time, and temporal error.
Source of Performance Gain
a) Ablation Study: Figure 15 isolates multi-frame dataflow, near-memory execution, and pipeline scheduling with five configurations. PIM alone preserves frame order while offloading activity decisions and compaction to PPIM and HCF. Combining dataflow and PIM starts each GPU stage after its PIM task, without cross-window or batch overlap. The keyframe intervals in Ex4DGS and anchor selection in Anchored 4DGS exclude more subsequent attributes with one decision. Enabling both designs yields 3.10×–4.87× speedup. Full GSPIM overlaps near-memory preparation across windows and batches, adding 1.18×–1.60× to reach 3.75×–7.78× over the AGX Orin baseline.
Figure 15. Ablation results across workloads and datasets.
b) Polymorphic PIM Analysis: Figure 16 shows GPU-visible DRAM traffic and transaction reductions from early PPIM selection and HCF compaction. Across all workloads, these metrics decrease by 69.2% and 62.7% on average. Modeled PIM_SELECT/PIM_REORG service latencies average –– DRAM cycles, including control and execution per dice-level call. Selection latency varies with programs and record counts. Reorganization means include compaction and packing calls. Ex4DGS and Anchored 4DGS exclude more associated attributes per decision. Temporal sparsity benefits Flame Steak, while shorter windows and larger active sets limit gains in Dance3.
c) Multi-Frame Rendering Dataflow Analysis: In Figure 17, stable-set internal rank retention across window frames reaches at least 95.8% in Dance3 and 95.1% in Actor1_4. Threshold-boundary handling routes at most 0.0031% of S3 Gaussians into per-frame sorting. Adjacent-window size changes and immediate three-window returns peak at 12.7% and 3.18%, with 13 s/window control overhead in Actor1_4. Motion-induced short windows raise attribute loads to 31.0%–35.2%, versus 15.4%–16.9% in Sear Steak. Cross-frame anchor sharing lowers mean Anchored 4DGS loads to 23.5%.
Figure 17. Dataflow stability, loads, and window adaptation.
Scalability
a) Scalability to 3DGS: Figure 18 evaluates GSPIM on static 3DGS [20]. Consecutive views share visible sets and depth orders, enabling reuse of visibility selection, sorting, and attribute loading. Across six Tanks and Temples scenes [24], the GPU dataflow and full GSPIM achieve geometric-mean speedups of and , respectively. Full GSPIM improves over the of 3DGauCIM [16] by because visibility-driven compaction excludes primitives retained by coarse grids and reuses their layout and depth order.
Figure 18. 3DGS scalability relative to AGX Orin.
Figure 16. PIM traffic reductions and mean command latency.
Figure 20. Scene scale and resolution.
b) Scalability Across GPU Platforms: Figure 19 reports full GSPIM speedups of on Nano/NX and Dataflow-only energy-efficiency gains of on RTX4090/H100 (geometric means over optimized per-GPU baselines). Small Nano/NX caches increase baseline reloads, favoring PPIM filtering/HCF compaction. Sharing L2-sized batches and stable-set orders within a window reduces memory traffic and sorting energy. H100 bandwidth reduces baseline stalls and relative energy savings from attribute reuse.
Figure 19. Scalability across GPU platforms.
c) Scene Scale and Resolution: Figure 20 compares Actor1_4, MatrixCity [35] (23.7M Gaussians), and Waymo [51] at 720p, 1080p, and 4K with fixed hardware. GPU+Dataflow and GSPIM reach geometric-mean speedups of and over Orin. GSPIM exceeds 3DGauCIM, QI-4DGS, and Relay-GS by , , and . PPIM selection and HCF compaction avoid GPU transfers of inactive data. Depth-based classification and window adjustment adapt sorting reuse to camera and object motion while sorting unstable primitives per frame. L2-sized batches retain attribute reuse as intermediate data grows with scale and resolution. At 4K, attribute reuse reduces repeated loads while HCF prepares the next batch during pixel compositing.
Sensitivity Study
a) Stability Threshold: Figure 21 sweeps around 0.98. (1) bounds mean normalized depth variation for stable primitives by , or 0.0202 at . Common positive affine transforms of camera depths and clipping bounds preserve and classification across depth units. The local criterion omits Gaussian count and image resolution. Lower thresholds admit more depth variation, while higher thresholds reduce throughput for at most 0.01 dB gain. Across all cases, 0.98 stays within 0.6% of peak FPS and 0.012 dB of full-sorting PSNR.
Figure 21. Sensitivity to the stability threshold .
b) Window Adjustment Threshold: Figure 22 sweeps with the same 0.98 reference. Replicating the stability-score distribution leaves its mean unchanged, tying window adjustment to depth dynamics rather than primitive count. One-frame changes within the two-to-five-frame range bound the control response. Lower thresholds allow longer windows with greater variation, while higher thresholds shorten cross-frame reuse. Motion changes adjustment frequency, but all groups preserve the same unimodal trend. Across all representations and datasets, 0.98 remains within 0.8% of peak FPS and 0.012 dB of full-sorting PSNR.
Figure 22. Sensitivity to the window-adjustment threshold .
c) Reserved Workspace Capacity: Figure 23 varies the HCF workspace for the Active Buffer, classification sequences, and Batch Buffers. Live-range sharing sizes capacity for peak occupancy, and L2-sized batches bound Batch Buffer storage. Active Buffer and classification storage scale with the active set. Smaller allocations trigger GPU reorganization, reducing preparation-rendering overlap. Throughput saturates at 25% (four Res. Banks), within 0.1% of larger capacities across all three scenes. Reorganization preserves attributes, record associations, render order, and PSNR.
Figure 23. Sensitivity to reserved workspace capacity.
Hardware Overhead
Across 32 dies, Table V reports 15.9096 mm added cell area, 89.9% in bank-level circuits, chiefly PPIM and L1 compactors replicated in 384 PIM banks. Including routing, power distribution, and spacing, the 18.7172 mm physical footprint is 0.5849 mm per die, or 0.96% of a 60.92 mm 16 Gb LPDDR5 reference die [14]. The masked column-selection logic adds 0.28 ns within column-access timing margins, preserving external read/write latencies and column-command intervals. Added active power is 3.8363 W (3.2582 W dynamic, 0.5781 W leakage), or 0.120 W per die and 0.480
| Component | Area (mm) | Power (mW) | Component | Area (mm) | Power (mW) |
| Bank Logic, (14.3064 mm, 3,169.1 mW) | |||||
| Program Buf. | 7.2762 | 313.9 | Instr. Seq. | 0.3073 | 159.8 |
| Fixed Datapath | 3.5143 | 1,437.9 | Working RF | 1.3980 | 194.6 |
| Reduction Unit | 0.3132 | 169.8 | Selection Unit | 0.1724 | 87.3 |
| L1 Compactor | 0.8011 | 504.1 | Mask Col. Path | 0.1053 | 52.1 |
| Bank Interface | 0.1657 | 102.9 | FP32 Converter | 0.2529 | 146.7 |
| Die Logic, (1.6028 mm, 665.8 mW) | |||||
| Layout Regs | 0.0414 | 2.6 | Map Scanner | 0.6156 | 52.9 |
| Dest. Allocator | 0.0224 | 12.6 | Addr. Gen. | 0.0282 | 14.5 |
| Read Coalescer | 0.1780 | 51.1 | Data Router | 0.0783 | 47.6 |
| Write Packer | 0.2021 | 62.4 | Task Scheduler | 0.0256 | 13.3 |
| Task RF | 0.1588 | 26.0 | Access Arbiter | 0.0173 | 8.6 |
| Cmd. Frontend | 0.0668 | 129.9 | Completion Unit | 0.0414 | 23.3 |
| Bank Ctrl | 0.0711 | 36.8 | Clock Ctrl | 0.0558 | 184.2 |
| Clock Div. () | 0.0004 | 1.4 | Total | 15.9096 | 3,836.3 |
Table V. AREA AND POWER BREAKDOWN OF GSPIM ADDITIONS TO LPDDR5.
W per four-die package, with 50.6% in the fixed-point datapath and L1 compactor. Thermal analysis gives an approximately 70°C steady-state peak package case temperature, about 15°C below the 85°C WT-grade operating limit [40].
Related Work
a) 3DGS Hardware Acceleration: 3DGS hardware spans dedicated and GPU-attached rendering [3, 18, 29, 37, 43, 44, 45, 55, 64], cross-view reuse [8, 42], NPU execution [32], ray-based and large-scale rendering [67] [28], and training or SLAM [12, 13, 17, 25, 52, 54, 56, 58]. These accelerate generated static Gaussians or online reconstruction. Neo, closest in depth reuse, updates fixed-scene order across views. GSPIM filters dynamic records before generation and compacts attributes for multi-frame execution.
b) 4DGS Hardware Acceleration: 3DGauCIM [16] combines coarse spatiotemporal indexing, preceding-frame reuse, and digital CIM rendering. QI-4DGS [60] generates intermediate-frame 2DGS through adaptive quadratic interpolation, accelerating opacity computation and rendering. Relay-GS [23] selectively reuses preceding-frame sorting with periodic correction. Specter [21] unifies modeling and rendering, skips modeling undeformed tiles, and renders by contribution. Relay-GS is closest in depth reuse but specializes sorting for one rendering path. GSPIM retains native GPU generation across representations, combining configurable temporal selection, near-memory compaction, and window-level depth reuse.
Conclusion
GSPIM accelerates edge 4DGS with representation-specific PPIM selection and HCF compaction of active attributes before GPU loads. Cross-frame attribute and stable-set sorting reuse reduces repeated work within L2-sized batches, while hybrid scheduling overlaps near-memory preparation and GPU rendering. Across three 4DGS methods and six dynamic scenes, speedup and energy-efficiency gains over AGX Orin reach 5.36 and 4.99 (geometric means), with scene-level PSNR differences at most 0.006 dB. Across 32 1z DRAM dies, the added physical footprint and active power total 18.7172 mm and 3.8363 W.
References
Appendix: Artifact Appendix
Abstract
This artifact reproduces the speedup comparison in Figure 10, the ablation study in Figure 15, and the rendering quality in Table 3 of GSPIM. It includes CUDA rendering, GPU execution capture, trace construction, a Ramulator2-based GPU/PIM scheduling model, released checkpoints, and report generation. Evaluation covers 4DGS-1K, Ex4DGS, and Anchored 4DGS on six scenes. GPU execution is measured on Jetson AGX Orin. PIM and memory execution are simulated using captured GPU events and physical memory requests.
Artifact check-list (meta-information)
Algorithm: Temporal selection, multi-frame rendering, data reorganization, and overlapping GPU/PIM scheduling.
Program: Python, C++, and CUDA. Chisel hardware and model-training sources are also included.
Compilation: GCC/G++ 13.3, CMake, Ninja, and CUDA 13.2. Native components build automatically.
Model: 18 released checkpoints for three models.
Data set: Coffee Martini, Cook Spinach, Sear Steak, Flame Steak, Dance3, and Actor1_4.
Run-time environment: Ubuntu 24.04 / L4T R39.2, Python 3.12, and PyTorch 2.14.0+cu132.
Hardware: Jetson AGX Orin 64 GB, aarch64, compute capability 8.7, and an external SSD.
Run-time state: MAXN, platform frequency governor without clock locking, and no concurrent GPU workloads.
Metrics and output: Speedups, PSNR, SSIM, Markdown tables, and PNG/PDF figures.
Disk space: Approximately 100 GB, including about 48 GB of prepared data and 4 GB of extracted checkpoints.
Preparation time: About 44 min with local raw inputs. Downloads, installation, and initial compilation add time.
Experiment time: About 3 h 33 min for performance with fresh traces/schedules and compiled extensions, then 24 min for full-sequence quality using those caches.
Publicly available: Source and checkpoints.
Licenses: GSPIM source is MIT. Third-party code, models, and data retain their terms in
LICENSES/THIRD_PARTY.md.Workflow:
python -m gspim.demo.Archived: https://doi.org/10.5281/zenodo.21447096.
Description
How to access
How to access: The Zenodo record contains source v1.0, four checkpoint archives v1.1, and SHA256SUMS (3.74 GB total). Source v1.0 corresponds to commit
ef5191b86f32, with the full revision inARCHIVE.md. The project repository also provides development source and the checkpoint release. Preserve the bundled Git metadata used to verify pinned dependencies. Input hashes and upstream revisions are recorded inintegrations/manifest.py.
Hardware and software dependencies
Hardware and software dependencies: Use the Orin platform and software stack above with CUDA and Conda installed. Python dependencies include gsplat 1.5.3, NumPy 2.0.1, Pillow 12.1.1, OpenCV 5.0.0.93, and Matplotlib. Conda-forge FFmpeg 5.1.0 provides H.264/HEVC software decoding. Package installation needs network access and system packages need administrator privileges. Preparation initializes pinned Ramulator2 and Golden-Ratio sources.
Data sets and models
Data sets and models: Preparation downloads the four Neural 3D Video scenes. Request Dance3 and Actor1_4 through the Mobile-Stage and ENeRF-Outdoor forms in
docs/data.md. Released checkpoints cover all 18 model/scene combinations. Held-out cameras are 00 for Neural 3D Video and Actor1_4, and 04 for Dance3. Prepared images are 1352 × 1014 and 960 × 540, respectively. Representation-specific resizing and camera conventions followdocs/data.mdin the archived source.
Installation
Download all five archives and SHA256SUMS from Zenodo into one directory. In Bash, install the build tools, verify every archive, and extract the source:
sudo apt-get install build-essential cmake \
ninja-build git zstd
sha256sum -c SHA256SUMS
tar --zstd -xf gspim-ae-v1.0-source.tar.zst
export GSPIM_STORAGE=/mnt/ssd/gspim-ae
mkdir -p "$GSPIM_STORAGE"/{datasets,checkpoints,\
cache/downloads,cache/tmp,results}
for a in gspim-checkpoints-v1.1-*.tar.zst; do
tar --zstd -xf "$a" -C "$GSPIM_STORAGE"
done
cd GSPIM
conda create --prefix "$GSPIM_STORAGE/env" \
--override-channels -c conda-forge \
python=3.12 pip ffmpeg=5.1.0 -y
conda activate "$GSPIM_STORAGE/env"
export CUDA_HOME=/usr/local/cuda
export PATH="$CUDA_HOME/bin:$PATH"
export TMPDIR="$GSPIM_STORAGE/cache/tmp"
python -m pip install torch==2.14.0 \
--index-url https://download.pytorch.org/whl/cu132
python -m pip install -e '.[cuda]'
python -m pip install \
opencv-python-headless==5.0.0.93
ln -s "$GSPIM_STORAGE/datasets" datasets
ln -s "$GSPIM_STORAGE/checkpoints" checkpoints
Place the two requested scene archives in this cache directory:
$GSPIM_STORAGE/cache/downloads/
dance3_libx265.tar.gz
actor1_4_libx265.tar.gz
Prepare inputs and check checkpoints from the repository root:
python -m gspim.demo --prepare \
--cache "$GSPIM_STORAGE/cache"
Experiment workflow
Figure 10 speedups and Figure 15 ablation
Figure 10 speedups and Figure 15 ablation: The run uses the first 10 consecutive held-out frames, 100 warmup windows, and four measurement repetitions per combination. CUDA events measure Baseline and Dataflow, alternating their measurement order. Timing excludes loading, compilation, preprocessing, and quality evaluation.
python -m gspim.demo \
--cache "$GSPIM_STORAGE/cache" \
--out "$GSPIM_STORAGE/results/performance"
PIM-only uses independent-frame traces. Serial combines Dataflow and PIM with batch/window completion barriers. Full overlaps preparation and GPU work subject to producer dependencies and buffer ownership. Speedup is the ratio of Baseline mean per-frame time to the measured or simulated mean per-frame time of each configuration.
Table 3 quality
The run evaluates 300 frames per scene and 200 for Actor1_4, totaling 5,100 frames across all models. PSNR and RGB SSIM are computed per frame against held-out images and averaged per model/scene. SSIM uses an 11 × 11 Gaussian window with standard deviation 1.5.
python -m gspim.demo --frames 300 \
--cache "$GSPIM_STORAGE/cache" \
--out "$GSPIM_STORAGE/results/quality"
This pass reuses the 10-frame PIM traces/schedules and collects fresh full-sequence GPU measurements and quality metrics. Full quality uses Dataflow-rendered images because modeled PIM operations select and reorganize records. Captured-frame RGB hashes and window decisions are checked against current rendering before evaluation.
Evaluation and expected results
Both runs produce verification.md, per-combination summary.md files, and performance.{png,pdf} and ablation.{png,pdf}. Use the performance directory for Figure 10 and Figure 15, and the quality section of the quality report for Table III. Progress appears in the terminal. Traces, schedules, and raw measurements remain in the external cache.
Figure 10 compares Baseline, Dataflow, and Full. Figure 15 also includes PIM-only and Serial. Reference geometric-mean speedups over all 18 combinations are:
| Baseline | Dataflow | PIM-only | Serial | Full |
| 1.00× | 2.40× | 3.19× | 4.10× | 5.36× |
Table 2.
Compare the 72 nonbaseline model/scene speedups with the paper. The archived README gives a ±5% relative speedup tolerance for this shorter run against the paper results. Table III has 108 quality values. Maximum scene-mean Dataflow/Full decreases in the reference run are 0.0059251 dB PSNR and 0.0000194526 SSIM. Reports show three PSNR decimals and four SSIM decimals. Compare with Table III at this precision, where differences peak at 0.006 dB and 0.0001.
Experiment customization
Use --workload 4dgs1k, ex4dgs, or anchored, and a --scene selector. A single-combination check adds --workload anchored --scene dance3 with a separate output directory. Compatible caches are reused. GPU measurements and quality are collected on each invocation. --repeats and --warmup control sampling.
References
- [1]K. Afzuzzaman, N. R. Miniskar, A. R. Young, F. Liu, and J. S. Vetter, “A survey on processing-in-memory techniques: Advances and challenges,” Memories - Materials, Devices, Circuits and Systems, vol. 4, p. 100022, 2023. [Online]. Available: https://www.sciencedirect.com/science/article/pii/S2667304622000160
- [2]A. Cao and J. Johnson, “HexPlane: A fast representation for dynamic scenes,” in IEEE/CVF Conference on Computer Vision and Pattern Recognition, CVPR 2023, Vancouver, BC, Canada, June 17-24, 2023. IEEE, 2023, pp. 130–141. [Online]. Available: https://doi.org/10.1109/CVPR52729.2023.00021
- [3]F.-C. Chang and T.-S. Chang, “A 129 FPS Full HD real-time accelerator for 3D Gaussian splatting,” IEEE Transactions on Visualization and Computer Graphics, vol. 32, no. 7, pp. 6537–6547, 2026.DOI
- [4]D. Christ, L. Steiner, M. Jung, and N. Wehn, “PIMSys: A virtual prototype for processing in memory,” in Proceedings of the International Symposium on Memory Systems, MEMSYS 2024, Washington, DC, USA, 20 September 2024 - 3 October 2024. ACM, 2024, pp. 26–33. [Online]. Available: https://doi.org/10.1145/3695794.3695797
- [5]E. Cukurtas, K. Ranawella, K. Skadron, and M. Stan, “IMPRINT: in-memory processing with indirect addressing techniques for GPU-hosted HBM-PIM,” in Proceedings of the International Symposium on Memory Systems, MemSys 2025, Washington, USA, October 6-8, 2025. ACM, 2025, pp. 165–176. [Online]. Available: https://doi.org/10.1145/3767110.3767121
- [6]J. Duan, F. Wei, Q. Dai, Y. He, W. Chen, and B. Chen, “4D-rotor Gaussian splatting: Towards efficient novel view synthesis for dynamic scenes,” in ACM SIGGRAPH 2024 Conference Papers, SIGGRAPH 2024, Denver, CO, USA, 27 July 2024- 1 August 2024, A. Burbano, D. Zorin, and W. Jarosz, Eds. ACM, 2024, pp. 87:1–87:11. [Online]. Available: https://doi.org/10.1145/3645159.3657463
- [7]G. Feng, S. Chen, R. Fu, Z. Liao, Y. Wang, T. Liu, B. Hu, L. Xu, Z. Pei, H. Li, X. Li, N. Sun, X. Zhang, and B. Dai, “FlashGS: Efficient 3D Gaussian splatting for large-scale and high-resolution rendering,” in IEEE/CVF Conference on Computer Vision and Pattern Recognition, CVPR 2025, Nashville, TN, USA, June 11-15, 2025. Computer Vision Foundation / IEEE, 2025, pp. 26652–26662. [Online]. Available: https://opencaccess.thecvf.com/content/CVPR2025/html/Feng_FlashGS_Efficient_3D_Gaussian_Splatting_for_Large-scale_and_High-resolution_Rendering_CVPR_2025_paper.htmlarxiv.org/abs/2408.07967
- [8]Y. Feng, W. Lin, Y. Cheng, Z. Liu, J. Leng, M. Guo, C. Chen, S. Sun, and Y. Zhu, “Lumina: Real-time neural rendering by exploiting computational redundancy,” in Proceedings of the 52nd Annual International Symposium on Computer Architecture. ACM, 2025, pp. 1925–1939.DOI
- [9]S. Friedrich-Keil, G. Meanti, F. R. Barch, B. Recht, and A. Kanazawa, “K-Planes: Explicit radiance fields in space, time, and appearance,” in IEEE/CVF Conference on Computer Vision and Pattern Recognition, CVPR 2023, Vancouver, BC, Canada, June 17-24, 2023. IEEE, 2023, pp. 12479–12488. [Online]. Available: https://doi.org/10.1109/CVPR52729.2023.01201
- [10]S. Girish, T. Li, A. Mazumdar, A. Shrivastava, D. Luebke, and S. D. Mello, “QUEEN: quantized efficient encoding of dynamic Gaussians for streaming free-viewpoint videos,” in Advances in Neural Information Processing Systems, A. Globerson, L. Mackey, D. Belgrave, A. Fan, U. Paquet, J. M. Tomczak, and C. Zhang, Eds., vol. 37, 2024, pp. 43435–43467. [Online]. Available: https://papers.neurips.cc/paper_files/paper/2024/hash/4c9477b9e2c7ec0ad3f4f15077aaf85a-Abstract-Conference.htmlarxiv.org/abs/2412.04469
- [11]Y. Gu, A. Khadem, S. Umesh, N. Liang, X. Servot, O. Mutlu, R. R. Iyer, and R. Das, “PIM is all you need: A CXL-enabled GPU-free system for large language model inference,” in Proceedings of the 30th ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume 2, ASPLOS 2025, Rotterdam, Netherlands, 30 March 2025 - 3 April 2025, L. Eeckhout, G. Smaragdakis, K. Liang, A. Sampson, M. A. Kim, and C. J. Rossbach, Eds. ACM, 2025, pp. 862–881. [Online]. Available: https://doi.org/10.1145/3676641.3716267
- [12]H. He, N. Jing, L. Jiang, X. Liang, and Z. Song, “AGS: Accelerating 3D Gaussian splatting SLAM via CODEC-assisted frame covisibility detection,” in Proceedings of the 31st ACM International Conference on Architectural Support for Programming Languages and Operating Systems. ACM, 2026, pp. 20–34.arxiv.org/abs/2509.00433
- [13]H. He, G. Li, F. Liu, L. Jiang, X. Liang, and Z. Song, “GSArch: Breaking memory barriers in 3D Gaussian splatting training via architectural support,” in Proceedings of the IEEE International Symposium on High Performance Computer Architecture. IEEE, 2025, pp. 366–379.DOI
- [14]S. He, Z. Zhu, Y. He, and T. Jia, “LP-Spec: Leveraging LPDDR PIM for efficient LLM mobile speculative inference with architecture-dataflow co-optimization,” in 2025 IEEE/ACM International Conference on Computer Aided Design (ICCAD). IEEE, 2025, pp. 1–9. [Online]. Available: https://doi.org/10.1109/ICCAD66269.2025.11240889
- [15]G. Heo, S. Lee, J. Cho, H. Choi, S. Lee, H. Ham, G. Kim, D. Mahajan, and J. Park, “NeuPIMs: NPU-PIM heterogeneous acceleration for batched LLM inferencing,” in Proceedings of the 29th ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume 3, ASPLOS 2024, La Jolla, CA, USA, 27 April 2024 - 1 May 2024, R. Gupta, N. B. Abu-Ghazaleh, M. Musuvathi, and D. Tsafrir, Eds. ACM, 2024, pp. 722–737. [Online]. Available: https://doi.org/10.1145/3620666.3651380
- [16]W.-H. Huang, C.-J. Shih, J.-W. Su, S. Wang, V. Garg, Y. Kong, J.-C. Tien, N. Li, A. Raychowdhury, M.-F. Chang, Y. C. Lin, and S. Yu, “3DGauCIM: Accelerating static/dynamic 3D gaussian splatting via digital CIM for high frame rate real-time edge rendering,” ACM Trans. Des. Autom. Electron. Syst., vol. 31, no. 4, pp. 81:1–81:18, Mar. 2026. [Online]. Available: https://doi.org/10.1145/3793555
- [17]X. Huang, H. Zhu, T. Ma, Y. Xiong, F. Liu, Z. He, Y. Gan, Z. Liu, J. Leng, Y. Feng, and M. Guo, “SPLATONIC: Architectural support for 3D Gaussian splatting SLAM via sparse processing,” in Proceedings of the IEEE International Symposium on High Performance Computer Architecture. IEEE, 2026, pp. 1–14.DOI
- [18]J. Jo and J. Park, “GS-TG: 3D Gaussian splatting accelerator with tile grouping for reducing redundant sorting while preserving rasterization efficiency,” in Proceedings of the 62nd ACM/IEEE Design Automation Conference. IEEE, 2025, pp. 1–7.arxiv.org/abs/2509.00911
- [19]J. G. Jonatan, H. Cho, H. Son, X. Wu, N. Livesay, E. Mora, K. Shvidikar, J. L. Abellán, A. Joshi, D. R. Kaeli, and J. Kim, “Scalability limitations of processing-in-memory using real system evaluations,” Proc. ACM Meas. Anal. Comput. Syst., vol. 8, no. 1, pp. 5:1–5:28, 2024. [Online]. Available: https://doi.org/10.1145/3639046
- [20]B. Kerbl, G. Kopanas, T. Leimkühler, and G. Drettakis, “3D Gaussian splatting for real-time radiance field rendering,” ACM Trans. Graph., vol. 42, no. 4, pp. 139:1–139:14, 2023. [Online]. Available: https://doi.org/10.1145/3598433
- [21]J.-Y. Kim, T. Suh, J. Lim, M. Park, H. Choi, J. Min, D. Kim, and J.-Y. Kim, “Specer: 376 fps 2.67 nJ/Pixel 4DGS processor for spatiotemporal reconstruction with contribution-ordered rendering and deformation-aware modeling,” in Proceedings of the IEEE/JSAP Symposium on VLSI Technology and Circuits. IEEE, 2026, pp. 1–3.DOI
- [22]J. H. Kim, S. Kang, S. Lee, H. Kim, W. Song, Y. Ro, S. Lee, D. Wang, H. Shin, B. Phuah, J. Choi, J. So, Y. Cho, J. Cho, S. Choi, J. Cho, K. Sohn, Y. Sohn, K. Park, and N. S. Kim, “Aquabolt-XL: Samsung HBM2-PIM with in-memory processing for ML accelerators and beyond,” in IEEE Hot Chips 33 Symposium, HCS 2021, Palo Alto, CA, USA, August 22-24, 2021. IEEE, 2021, pp. 1–26. [Online]. Available: https://doi.org/10.1109/HCS52781.2021.9567191
- [23]Y. Kim, S. Ki, S. Jeon, and S. Ryu, “Relay-GS: Reusing temporal sort information for 4D Gaussian splatting acceleration,” in Proceedings of the 63rd ACM/IEEE Design Automation Conference. ACM, 2026, pp. 1–7. [Online]. Available: https://doi.org/10.1145/3770743.3804261
- [24]A. Knapitsch, J. Park, Q. Zhou, and V. Koltun, “Tanks and Temples: Benchmarking large-scale scene reconstruction,” ACM Transactions on Graphics, vol. 36, no. 4, pp. 78:1–78:13, 2017.
- [25]H. Kweon, J. Kim, and J. Park, “BOA-3DGS: Backward-striding optimized accelerator for reduced memory contention in 3D Gaussian splatting training,” in Proceedings of the 31st Asia and South Pacific Design Automation Conference. IEEE, 2026, pp. 341–347.DOI
- [26]H. Lee, D. Baek, J. Son, J. Choi, K. Moon, and M. Jang, “PAISE: PIM-accelerated inference scheduling engine for transformer-based LLM,” in IEEE International Symposium on High Performance Computer Architecture, HPCA 2025, Las Vegas, NV, USA, March 1-5, 2025. IEEE, 2025, pp. 1707–1719. [Online]. Available: https://doi.org/10.1109/HPCA61900.2025.00126
- [27]J. Lee, C. Won, H. Jung, I. Bae, and H.-G. Jeon, “Fully explicit dynamic Gaussian splatting,” in Advances in Neural Information Processing Systems, vol. 37, 2024, pp. 5384–5409. [Online]. [28] J. Lee, S. Jeon, J. Lee, J. Park, and J. Sim, “GRTX: Efficient ray tracing for 3D Gaussian-based rendering,” in Proceedings of the IEEE International Symposium on High Performance Computer Architecture. IEEE, 2026, pp. 1–14.
- [29]J. Lee, S. Lee, J. Lee, J. Park, and J. Sim, “GSCore: Efficient radiance field rendering via architectural support for 3D Gaussian splatting,” in Proceedings of the 29th ACM International Conference on Architectural Support for Programming Languages and Operating Systems. ACM, 2024, pp. 497–511.DOI
- [30]C. Li, Z. Zhou, Y. Wang, F. Yang, T. Cao, M. Yang, Y. Liang, and G. Sun, “PIM-DL: Expanding the applicability of commodity DRAM-pims for deep learning via algorithm-system co-optimization,” in Proceedings of the 29th ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume 2, ser. ASPLOS ’24. New York, NY, USA: Association for Computing Machinery, 2024, p. 879–896. [Online]. Available: https://doi.org/10.1145/3620665.3640376
- [31]C. Li, Z. Zhou, S. Zheng, J. Zhang, Y. Liang, and G. Sun, “SpecPIM: Accelerating speculative inference on PIM-enabled system via architecture-dataflow co-exploration,” in Proceedings of the 29th ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume 3, ASPLOS 2024, La Jolla, CA, USA, 27 April - 1 May 2024, R. Gupta, N. B. Abu-Ghazaleh, M. Musuvathi, and D. Tsafrir, Eds. ACM, 2024, pp. 950–965. [Online]. Available: https://doi.org/10.1145/3620666.3651352
- [32]H. Li, Y. Liang, F. Liu, B. Zhu, Z. Wang, Y. Feng, L. Lu, L. Jiang, and H. Guan, “ORANGE: Exploring ockham’s razor for neural rendering by accelerating 3DGS on NPUs with GEMM-friendly blending and balanced workloads,” in Proceedings of the IEEE International Symposium on High Performance Computer Architecture. IEEE, 2026, pp. 1–15.DOI
- [33]T. Li, M. Slavcheva, M. Zollhöfer, S. Green, C. Lassner, K. Kim, T. Schmidt, S. Leovgore, M. Goesele, R. A. Newcombe, and Z. Lv, “Neural 3D video synthesis from multi-view video,” in IEEE/CVF Conference on Computer Vision and Pattern Recognition, CVPR 2022, New Orleans, LA, USA, June 18-24, 2022. IEEE, 2022, pp. 5511–5521. [Online]. Available: https://doi.org/10.1109/CVPR52688.2022.00544
- [34]Y. Li, B. Pang, Y. Chen, and G. Wang, “Anchored 4D Gaussian splatting for dynamic novel view synthesis,” in Proceedings of the SIGGRAPH Asia 2025 Conference Papers, SA Conference Papers 2025, Hong Kong, December 15-18, 2025, T. Komura, M. Wimmer, and H. Fu, Eds. ACM, 2025, pp. 73:1–73:11. [Online]. Available: https://doi.org/10.1145/3757377.3763898
- [35]Y. Li, L. Jiang, L. Xu, Y. Xiangli, Z. Wang, D. Lin, and B. Dai, “MatrixCity: A large-scale city dataset for city-scale neural rendering and beyond,” in Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), 2023, pp. 3205–3215. [Online]. Available: https://openaccess.thecvf.com/content/ICCV2023/html/Li_MatrixCity_A_Large-scale_City_Dataset_for_City-scale_Neural_Rendering_and_ICCV_2023_paper.htmlarxiv.org/abs/2309.16553
- [36]Z. Li, Z. Chen, Z. Li, and Y. Xu, “SparseVoxel? Gaussian feature splatting for real-time dynamic view synthesis,” in IEEE/CVF Conference on Computer Vision and Pattern Recognition, CVPR 2024, Seattle, WA, USA, June 16-22, 2024. IEEE, 2024, pp. 8508–8520. [Online]. Available: https://doi.org/10.1109/CVPR52733.2024.00813
- [37]Y. Lin, W. Lu, C. Chen, X. Zeng, and H. Zhu, “GauRPre: A pattern-based rendering engine for Gaussian splatting on edge device,” in Proceedings of the IEEE/ACM International Conference on Computer-Aided Design. IEEE, 2025, pp. 1–9.
- [38]T. Lu, M. Yu, L. Xu, Y. Xiangli, L. Wang, D. Lin, and B. Dai, “Scaffold-GS: Structured 3D Gaussians for view-adaptive rendering,” in IEEE/CVF Conference on Computer Vision and Pattern Recognition, CVPR 2024, Seattle, WA, USA, June 16-22, 2024. IEEE, 2024, pp. 20654–20664. [Online]. Available: https://doi.org/10.1109/CVPR52733.2024.01952
- [39]H. Luo, Y. C. Tuğrul, F. N. Bostanci, A. Olgun, A. G. Yağlıkçı, and O. Mutlu, “Ramulator 2.0: A modern, modular, and extensible DRAM simulator,” IEEE Computer Architecture Letters, vol. 23, no. 1, pp. 112–116, 2024. [Online]. Available: https://doi.org/10.1109/LCA.2023.3333759
- [40]Available: https://proceedings.neurips.cc/paper_files/paper/2024/hash/09b47a77997b7dd7d2b26bd8ff769392-Abstract-Conference.html [40] Micron Technology, Inc., LPDDR5 SDRAM, May 2021, y31m_lpddr5_multi_pkg.pdf, Rev. A. [Online]. Available: https://mm.digikey.com/Volume0/0pasdata/d220001/medias/docus/8885/441b-315b-y31m-lpddr5-multi-pkg.pdf
- [41]S. Odeh, O. Green, Z. Mwassi, O. Shmueli, and Y. Birk, “Merge Path - parallel merging made simple,” in 26th IEEE International Parallel and Distributed Processing Symposium Workshops & PhD Forum, IPDPS 2012, Shanghai, China, May 21-25, 2012. IEEE Computer Society, 2012, pp. 1611–1618. [Online]. Available: https://doi.org/10.1109/IPDPSW.2012.202
- [42]C. Oh, S. Oh, J. Hwang, Y. Kim, H. Sharma, and J. Park, “Neo: Real-time on-device 3D Gaussian splatting with reuse-and-update sorting acceleration,” in Proceedings of the 31st ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume 2. ACM, 2026, pp. 1268–1284. [Online]. Available: https://doi.org/10.1145/3779212.3790192
- [43]W. Ou, Z. Wu, Y. Zhang, D. Wu, F. Z. Hong, and C. P. Yue, “FLICKER: A fine-grained contribution-aware accelerator for real-time 3D Gaussian splatting,” in Proceedings of the Design, Automation and Test in Europe Conference. IEEE, 2026, pp. 1–7.
- [44]M. Pei, G. Li, J. Si, Z. Zhu, Z. Mo, P. Wang, Z. Song, X. Liang, and J. Cheng, “GCC: A 3DGS inference architecture with Gaussian-wise and cross-stage conditional processing,” in Proceedings of the 58th IEEE/ACM International Symposium on Microarchitecture, MICRO 2025, Seoul, Republic of Korea, October 18-22, 2025. ACM, 2025, pp. 1824–1837. [Online]. Available: https://doi.org/10.1145/3752843.3756072
- [45]M. Pei, G. Li, Z. Zhu, S. Wang, J. Si, Z. Song, Y. Feng, F. Liu, X. Liang, and J. Cheng, “DeGS: A scalable 3DGS architecture via decoupled workload parsing and reorganization,” in 2026 59th IEEE/ACM International Symposium on Microarchitecture (MICRO). IEEE, 2026, pp. 848–862. [Online]. Available: https://doi.org/10.1109/MICRO67795.2026.00070
- [46]C. Peng, C. Zhang, Y. Wang, C. Xu, Y. Xie, W. Zheng, K. Keutzer, M. Tomizuka, and W. Zhan, “DeSiRe-GS: 4D street Gaussians for static-dynamic decomposition and surface reconstruction for urban driving scenes,” in IEEE/CVF Conference on Computer Vision and Pattern Recognition, CVPR 2025, Nashville, TN, USA, June 11-15, 2025. Computer Vision Foundation / IEEE, 2025, pp. 6782–6791. [Online]. Available: https://openaccess.thecvf.com/content/CVPR2025/html/Peng_DeSiRe-GS_4D_Street_Gaussians_for_Static-Dynamic_Decomposition_and_Surface_Reconstruction_CVPR_2025_paper.htmlarxiv.org/abs/2411.11921
- [47]Samsung Electronics, “Samsung completes qualification of 8nm LPP process,” Samsung Global Newsroom, October 2017. [Online]. Available: https://news.samsung.com/global/samsung-completes-qualification-of-8nm-lpp-process
- [48]S. Sarangi and B. M. Baas, “DeepScaleTool: A tool for the accurate estimation of technology scaling in the deep-submicron era,” in 2021 IEEE International Symposium on Circuits and Systems (ISCAS), 2021, pp. 1–5.DOI
- [49]D. Scherzer, L. Yang, O. Mattausch, D. Nehab, P. V. Sander, M. Wimmer, and E. Eisemann, “Temporal coherence methods in real-time rendering,” Comput. Graph. Forum, vol. 31, no. 8, pp. 2378–2408, 2012. [Online]. Available: https://doi.org/10.1111/j.1467-8659.2012.03075.x
- [50]E. Stehle and H. Jacobsen, “A memory bandwidth-efficient hybrid radix sort on GPUs,” in Proceedings of the 2017 ACM International Conference on Management of Data, SIGMOD Conference 2017, Chicago, IL, USA, May 14-19, 2017, S. Salihoglu, W. Zhou, R. Chirkova, J. Yang, and D. Suciu, Eds. ACM, 2017, pp. 417–432. [Online]. Available: https://doi.org/10.1145/3035918.3064043
- [51]P. Sun, H. Kretzschmar, X. Dotiwalla, A. Chouard, V. Patnaik, P. Tsui, J. Guo, Y. Zhou, Y. Chai, B. Caine, V. Vasudevan, W. Han, J. Ngiam, H. Zhao, A. Timofeev, S. Ettinger, M. Krikova, A. Gao, A. Joshi, Y. Zhang, J. Shlens, Z. Chen, and D. Anguelov, “Scalability in perception for autonomous driving: Waymo open dataset,” in Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), 2020, pp. 2446–2454. [Online]. Available: https://openaccess.thecvf.com/content_CVPR_2020/html/Sun_Scalability_in_Perception_for_Autonomous_Driving-_Waymo_Open_Dataset_CVPR_2020_paper.htmlarxiv.org/abs/1912.04838
- [52]Y. Sun, Q. Zhi, J. Jing, L. Ye, R. Huang, and T. Jia, “Local-GS: An order-independent Gaussian splatting training accelerator exploiting splat locality,” in Proceedings of the 62nd ACM/IEEE Design Automation Conference. IEEE, 2025, pp. 1–7.DOI
- [53]Y. T. Tefera, D. Mazzanti, S. Anastasi, D. G. Caldwell, P. Fiorini, and N. Deshpande, “Towards gaze-contingent visualization of real-time 3D reconstructed remote scenes in mixed reality,” in Proceedings of the 2023 6th International Conference on Advances in Robotics, AIR 2023, Ropar, India, July 5-8, 2023. ACM, 2023, pp. 21:1–21:6. [Online]. Available: https://doi.org/10.1145/3610419.3610440
- [54]H. Wang, Z. Zhu, T. Zhao, Y. Xiang, Z. Wang, J. Yu, H. Yang, Y. Xie, and Y. Wang, “REACT3D: Real-time edge accelerator for incremental training in 3D Gaussian splatting based SLAM systems,” in Proceedings of the 58th IEEE/ACM International Symposium on Microarchitecture. ACM, 2025, pp. 1852–1866.DOI
- [55]L. Wei, J. Tang, F. Fei, B. Shi, R. Wang, and M. Li, “No redundancy, no stall: Lightweight streaming 3D Gaussian splatting for real-time rendering,” in 2025 IEEE/ACM International Conference On Computer Aided Design (ICCAD), 2025, pp. 1–9.
- [56]R. Wen, Z. Yue, T. Liu, X. Song, J. Li, D. Huang, J. Guo, X. Hu, Z. Du, Q. Guo, and T. Chen, “Cambricon-GS: An accelerator for 3D Gaussian splatting training with Gaussian-pixel hybrid parallelism,” in Proceedings of the IEEE International Symposium on High Performance Computer Architecture. IEEE, 2026, pp. 1–14.DOI
- [57]G. Wu, T. Yi, J. Fang, L. Xie, X. Zhang, W. Wei, W. Liu, Q. Tian, and X. Wang, “4D Gaussian splatting for real-time dynamic scene rendering,” in IEEE/CVF Conference on Computer Vision and Pattern Recognition, CVPR 2024, Seattle, WA, USA, June 16-22, 2024. IEEE, 2024, pp. 20310–20320. [Online]. Available: https://doi.org/10.1109/CVPR52733.2024.01920
- [58]L. Wu, H. Zhu, S. He, J. Zheng, C. Chen, and X. Zeng, “GauSPU: 3D Gaussian splatting processor for real-time SLAM systems,” in Proceedings of the 57th IEEE/ACM International Symposium on Microarchitecture. IEEE, 2024, pp. 1562–1573.DOI
- [59]Z. Xu, T. Xie, S. Peng, H. Lin, Q. Shuai, Z. Yu, G. He, J. Sun, H. Bao, and X. Zhou, “EasyVolcap: Accelerating neural volumetric video research,” in SIGGRAPH Asia 2023 Technical Communications, SA Technical Communications 2023, Sydney, NSW, Australia, December 12-15, 2023, J. Kim and R. Sharma, Eds. ACM, 2023, pp. 22:1–22:4. [Online]. Available: https://doi.org/10.1145/3610543.3626173
- [60]X. Yang, Y. Wang, W. Xu, Y. Qin, H. Wang, R. Guo, Z. Yue, J. Gu, S. Wei, Y. Hu, and S. Yin, “2.9 A 0.24mJ/Frame quadratic interpolation 4DGS processor with recursive computation reuse and tree-based parallel-rendering,” in IEEE International Solid-State Circuits Conference, ISSCC 2026, San Francisco, CA, USA, February 15-19, 2026. IEEE, 2026, pp. 58–60. [Online]. Available: https://doi.org/10.1109/ISSCC49663.2026.11409230
- [61]Y. Yang, Q. Feng, Y. Lai, and K. Li, “Real-time 3D human reconstruction and rendering system from a single RGB camera,” in SIGGRAPH Asia 2024 Technical Communications, SA 2024, Tokyo, Japan, December 3-6, 2024, T. Igarashi and R. Hu, Eds. ACM, 2024, pp. 6:1–6:4. [Online]. Available: https://doi.org/10.1145/3681758.3697993
- [62]Z. Yang, H. Yang, Z. Pan, and L. Zhang, “Real-time photorealistic dynamic scene representation and rendering with 4D Gaussian splatting,” in The Twelfth International Conference on Learning Representations, ICLR 2024, Vienna, Austria, May 7-11, 2024. OpenReview.net, 2024. [Online]. Available: https://openreview.net/forum?id=WhgB5SisPVarxiv.org/abs/2310.10642
- [63]V. Ye, R. Li, J. Kerr, M. Turkulainen, B. Yi, Z. Pan, O. Seiskari, J. Ye, J. Hu, M. Tančik, and A. Kanazawa, “gsplat: An open-source library for Gaussian splatting,” Journal of Machine Learning Research, vol. 26, no. 34, pp. 1–17, 2025. [Online]. Available: https://jmlr.org/papers/v26/24-1476.htmlarxiv.org/abs/2409.06765
- [64]Z. Ye, Y. Fu, J. Zhang, L. Li, Y. Zhang, S. Li, C. Wan, C. Wan, C. Li, S. Pratiphati, and Y. C. Lin, “Gaussian Blending Unit: An edge GPU plug-in for real-time Gaussian-based rendering in AR/VR,” in Proceedings of the 31st IEEE International Symposium on High Performance Computer Architecture. IEEE, 2025, pp. 353–365.
- [65]Y. Yuan, Q. Shen, X. Yang, and X. Wang, “1000+ FPS 4D Gaussian splatting for dynamic scene rendering,” in Advances in Neural Information Processing Systems, vol. 38, 2025, pp. 83135–83153. [Online]. Available: https://proceedings.neurips.cc/paper_files/paper/2025/hash/6c39d1a7eecfd98570d74bf7efec1be7-Abstract-Conference.htmlarxiv.org/abs/2503.16422
- [66]X. Zhang, Z. Liu, Y. Zhang, X. Ge, D. He, T. Xu, Y. Wang, Z. Lin, S. Yan, and J. Zhang, “MEGA: Memory-efficient 4D Gaussian splatting for dynamic scenes,” in Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), October 2025, pp. 8728–27 838. [Online]. Available: https://openaccess.thecvf.com/content/ICCV2025/html/Zhang_MEGA_Memory-Efficient_4D_Gaussian_Splatting_for_Dynamic_Scenes_ICCV_2025_paper.htmlarxiv.org/abs/2410.13613
- [67]H. Zhu, Z. Liu, X. Li, A. Wu, J. Zhao, F. Liu, Y. Gan, J. Leng, and Y. Feng, “Nebula: Infinite-scale 3D Gaussian splatting in VR via collaborative rendering and accelerated stereo rasterization,” in Proc. 31st ACM ASPLOS. ACM, 2026, pp. 1235–1250.DOI





















