Summary
This article analyzes a memory spike issue observed in GOT Online using GameOptim reports. Investigation shows that unusually high PSS and Remapper memory is not caused by overly fragmented AssetBundles, but by overly broad bundles containing multiple scenes and excessive dependencies. We explain how Unity’s internal object mapping contributes to Remapper overhead and why oversized bundles increase PSS, followed by optimization strategies such as maintaining one-scene-per-bundle packaging.
Unity AssetBundle Memory Spikes: PSS vs Remapper Analysis and Optimization
Problem Overview
In a GOT Online performance report, significant PSS memory spikes were observed in specific scenes. Memory profiling further revealed unusually high Remapper memory usage, indicating potential issues in resource mapping and loading behavior.
A key question emerged:
Is this caused by AssetBundles being split too finely?
The analysis shows the opposite is true.
Root Cause: Overly Broad AssetBundle Packaging
The issue is not excessive fragmentation, but overly broad bundling.
A critical AssetBundle was identified:
defaultpackage_share_assets_art_prefab_scenes.bundle
Key characteristics:
- Size: ~232 MB
- No significant concentration of high-volume assets (e.g., textures or meshes)
- Resource mode shows ~22 MB attributed directly to AssetBundle overhead
This combination strongly suggests inefficient resource grouping rather than asset-heavy content.
Why This Triggers Memory Spikes
1. Mixed Scene Packaging Increases Load Scope
When multiple scenes are included in a single AssetBundle:
- Loading one scene may indirectly load unrelated scene assets
- Dependency chains expand unintentionally
- Memory footprint grows beyond expected runtime scope
2. Remapper Memory Growth (Internal Mapping Overhead)
Unity must maintain internal structures to:
- Map object references
- Track dependencies
- Manage asset-to-object relationships
As bundle complexity increases:
- Object count increases
- Dependency graph becomes denser
- Remapper memory grows significantly
3. PSS Memory Increase (Physical Memory Impact)
Once assets and dependencies are actually loaded:
- They contribute directly to physical memory usage
- PSS increases alongside runtime asset residency
Key Insight: Remapper ≠ PSS
Although they often rise together, they represent different layers:
- Remapper: Internal Unity memory used for object mapping and reference tracking
- PSS (Proportional Set Size): Actual physical memory consumed by the process
They are correlated symptoms of the same structural issue, not identical metrics.
Optimization Recommendations
1. Enforce One-Scene-Per-Bundle Strategy
Where possible:
- Package a single scene per AssetBundle
- Avoid cross-scene dependency aggregation
This reduces:
- Unnecessary asset loading
- Dependency chain expansion
- Remapper overhead
2. Audit Bundle Composition
For each large bundle, verify:
- Are multiple scenes included?
- Are unused assets bundled unintentionally?
- Are shared resources incorrectly centralized?
3. Validate Against Memory Trends
Use profiling data to correlate:
- PSS spikes
- Remapper growth
- AssetBundle load events
This helps isolate structural packaging issues early.
Conclusion
Memory spikes involving both PSS and Remapper are often not caused by asset quantity alone, but by how assets are grouped and loaded.
In this case, the core issue was an oversized, multi-scene AssetBundle that amplified dependency complexity and internal mapping overhead.
A more granular bundling strategy—especially one-scene-per-bundle—can significantly reduce both runtime memory pressure and internal engine overhead.
Top comments (0)