VR-Bench: XRFlux for 6-DoF VR Delivery

• VR-Bench is an open-source, Unity-based framework that systematically evaluates edge-cloud caching for 6-DoF VR by simulating dynamic fields of view and interactive multiuser environments.
• It comprises a VR simulation environment featuring realistic mobility models for principals and groupies, dual FoV tracking, and replayable demand traces for precise caching strategy analysis.
• Its modular architecture supports various caching policies, including LRU, LFU, and predictive prefetching, significantly enhancing cache hit rates and reducing latency.

XRFlux is a Unity-based open-source benchmark to systematically evaluate edge-cloud caching systems for Virtual Reality (VR) delivery, with particular support for true 6-degree-of-freedom (6-DoF: rotational and translational) user motion and multiuser interaction scenarios. XRFlux addresses the inadequacy of existing caching and streaming benchmarks—which often ignore VR-unique demands such as dynamic fields of view (FoVs), spatiotemporal access patterns, multiuser synchronization, and ultra-low-latency Quality of Experience (QoE) requirements—by providing a detailed simulation, workload capture, and cache-playback framework. This tool facilitates research and design of caching strategies tailored for the operational realities of edge-assisted VR streaming (Alfares et al., 25 Dec 2024).

1. Rationale and Unique Challenges in VR Edge Delivery

The primary motivation behind XRFlux is the absence of VR-specific benchmarks capable of reflecting the distinctive demands placed on edge-cloud caching architectures by interactive 6-DoF VR applications. Conventional cloud-based content delivery, such as off-site AWS S3, typically struggles with sub-100ms end-to-end latency, essential to avoiding motion-to-photon delays and cyber-sickness. VR users, both solo and in synchronized ensemble scenarios (with "principal" and "groupie" avatars), produce non-stationary, rapidly shifting FoVs, inducing complex, temporally and spatially correlated asset access profiles. These patterns fundamentally undermine assumptions—like independent Poisson object arrivals—central to previous caching benchmarks (e.g., VBench, IRM models). XRFlux was established to reproduce these behaviors, capture demand traces, and enable replay through customizable cache frameworks to assess real-world QoEs (Alfares et al., 25 Dec 2024).

2. System Architecture and Fundamental Components

XRFlux consists of two integrated subsystems: a Unity-based VR simulation environment and an edge-cloud caching/playback framework.

Unity Simulation Environment:

• Universe: A cubic space $[-1,1]^3$ randomly populated with ShapeNet 3D objects.
• User Avatars: Each avatar employs two synchronized Unity cameras, one tracking actual (immediate) FoV and the other the predicted FoV.
• Mobility Models:
  • Principals: Move linearly at constant speed, reflectively bouncing off cube walls.
  • Position update: $\mathbf p_{t+d} = \mathbf p_t + \mathbf v\,d$
  • Groupies: Follow the nearest principal with stochastic diffusion.
  • Velocity update: $$\mathbf v_{t+d} = \mathbf v_t + (\mathbf a + \mathbf f)d$$
  • Attraction: $$\mathbf a = \min(F_{\max},\|\mathbf p-\mathbf g\|)\,\frac{\mathbf p-\mathbf g}{\|\mathbf p - \mathbf g\|}$$
• FoV Modeling:
  • Immediate FoV: Defined by angular width (e.g., 110°) and depth cutoff $S$.
  • Predicted FoV: Superset with wider view (e.g., 140°) and depth $D$, perturbed by Gaussian head movement noise.

Edge-Cloud Caching Framework:

• Edge Controller: Handles cache misses, fetches from remote cloud, and manages resource allocation.
• Cache Module: Default LRU policy; can be replaced with LFU, segmented, shared, or predictive (e.g., FoV-based prefetch) strategies.
• Renderer: Dynamically adapts object Level of Detail (LoD), enabling spatial/temporal fidelity-latency tradeoffs.
• API Endpoints: Clients request object IDs; cache fulfills from local storage or relays to the remote cloud.
• Remote Cloud: S3-style multi-resolution object storage and controller.

Data Logging:

• Each timestep and user triggers logging of:
  • Objects entering/exiting immediate and predicted FoVs
  • Timestamp, object ID, position, and avatar-relative distance
  • FoV update events

This data forms a "demand trace" for cache-playback experiments.

3. Caching, Trace Replay, and Evaluation Methodology

XRFlux replays captured demand traces through its edge-cache API in an offline, repeatable testing harness:

• At each request for object $o$, the cache responds from local storage (hit) or invokes the controller to retrieve from the origin server (miss), updating the cache accordingly.
• Latency is emulated based on established wireless models and measured cloud round-trips.

Supported Caching Policies:

• LRU (default)
• LFU
• Segmented/shared entourage caches
• Predictive (e.g., prefetching into the predicted FoV)—requires only swapping the cache module

Key Evaluation Metrics:

• Cache hit ratio: $H = \frac{N_{\sf hits}}{N_{\sf requests}}$
• Miss ratio: $M = 1 - H$
• Average response time: $T = T_{\sf cache} H + T_{\sf origin} M$

4. Quality of Experience (QoE) Metrics

XRFlux quantifies both network and application performance via stringent QoE indicators:

• Per-object request latency $L_i$: Time to asset arrival.
• Average latency:

$\overline{L} = \frac{1}{N}\sum_{i=1}^N L_i$

• Frame/missing-object events: Asset unavailable before frame deadline.
• Rebuffering events: Scene stalls due to waiting on resources.
• Multiuser synchronization error: Divergence in FoV object sets.
• Multiuser synchronization QoE:

$$Q_{\rm sync} = \frac{1}{T} \sum_{t=1}^T \frac{\left| \bigcap_{u \in U} F_u(t) \right|}{\left| \bigcup_{u \in U} F_u(t) \right|}$$

Latency variance and tail latency metrics are also directly available.

5. Empirical Evaluation and Observed Results

Experimental Configuration:

• Users: 10 avatars (2 principals, 8 groupies)
• Scene: Random ShapeNet objects ($N=50$–200), varying scene depths $(S, D)$
• Network: Cellular and wireless modeled delays; cloud RTTs
• Cache Sizes: 5–50 object slots

Key Quantitative Findings:

Scenario	Cache Policy	Hit Rate	Avg. Latency Reduction	Rebuffering Reduction	$Q_{\rm sync}$
Standard FoV (110°, $S=10$), cache=5	LRU, no prefetch	40%	–	–	–
Standard FoV, cache=5	Prefetch (pred. FoV)	60%	–	80%	↑ from 0.75 → 0.93
Increased Depth ($S=20$, $D=50$), no prefetch	LRU	~25%	–	–	–
IRM Poisson baseline, cache=10	IRM	~55%	–	–	–
XRFlux correlations, cache=10	Prefetch	10–20% absolute ↑ vs IRM	>70% (edge: 25ms, cloud-only: 120ms)	80% fewer	↑ 0.18

Prefetching into predicted FoVs consistently outperforms standard approaches, elevating hit rates by 10–20% above IRM and reducing average fetch time from 120ms (cloud-only) to 25ms (edge hit), resulting in over 70% faster user-perceived latency and a marked drop in rebuffering and synchronization errors (Alfares et al., 25 Dec 2024).

6. Comparison to Legacy and Contemporary Benchmarks

Prior systems, including VBench (360° video) and IRM-driven data cache simulations, are limited in modeling only 3-DoF head rotation, ignoring translational motion, multiuser synchronization, and edge-compute factors. They assume independent request arrivals and lack support for VR-specific object-level prefetching or Level of Detail adaptation. XRFlux advances the state of the art through:

• True 6-DoF avatar motion
• Dual FoV (actual and predicted) tracking
• Multiuser entourage and principal/groupie dynamics
• Modular edge-cloud replay with flexible plug-in cache models
• LoD-aware caching with dynamic resolution selection
• Support for predicted-FoV prefetch policies

7. Adoption, Extensibility, and Future Research Directions

Deployment Steps:

1. Clone repository: https://github.com/PSU-Cloud/XRFlux
2. Configure Unity scene, adjusting assets and density.
3. Customize mobility models as needed (e.g., for structured environments, WFC-based pathing).
4. Execute simulation to produce demand log (JSON/CSV).
5. Replay through edge-cache engine with selected policies and sizes.
6. Aggregate QoE metrics for comparative analysis.

Extensibility:

• Integration of new cache algorithms (LFU, segmented, ML-based predictors)
• Replacement of FoV predictors with ML or attention models
• Network emulation plug-ins (e.g., QUIC protocols)
• Additional metrics: motion-to-photon latency, per-frame PSNR
• Replay of human-subject FoV traces for realism

Future Work:

• Dynamic cityscape navigation via wave function collapse (WFC)
• LoD-adaptive and neural decimation rendering strategies
• Device-level (on-HMD) caching for AR constraints
• End-to-end transport protocol emulation and global latency tracking
• Hybrid workloads combining synthetic and human-derived traces (Alfares et al., 25 Dec 2024)