How Can Developers Balance Broad and Deep Performance Analysis in Unity?
Performance profiling often involves a trade-off between data coverage and analysis depth. GOT Online now supports custom data collection in Overview mode, allowing Resource and Lua data to be collected alongside other performance data. The update also adds deeper Mono, memory, stutter, resource management, and GPU analysis capabilities.
About GameOptim GameOptim helps Unity developers identify memory issues, rendering bottlenecks, and performance regressions through automated profiling and cloud based performance analysis. Explore more: 🌐 Website: www.gameoptim.com https://www.gameoptim.com/?fopt=blog 📘 Blog: www.gameoptim.com/blog/ https://www.gameoptim.com/blog/ 💼 LinkedIn: www.linkedin.com/company/gameoptim/ https://www.linkedin.com/company/gameoptim/ 🎥 YouTube: GO.PerformanceLab https://www.youtube.com/@GO.PerformanceLab 💬 Discord: GameOptim https://discord.gg/4Jh6hj9gRw ⭐ GitHub: GameOptim https://github.com/GameOptim/unity mobile performance guide 💻 Dev: GameOptim https://dev.to/gameoptim Summary GOT Online now supports configurable Resource and Lua data collection in Overview mode, allowing related performance data to be captured in a single report. IL2CPP packages can now support deep Mono data analysis with SDK 2.4.5 and Script Debugging enabled during the build. The new memory analysis module provides deeper analysis of Resource, Lua, and Mono memory. Updated stutter analysis helps developers investigate key functions and individual stutter points. Resource Management helps identify loading and unloading bottlenecks, while the updated GPU timing collection provides more stable GPU timing data across a wider range of devices. How Can Developers Collect More Performance Data Without Losing Analysis Depth? Performance optimization often involves a large number of performance parameters. However, collecting more data does not necessarily mean obtaining better analysis results. Data collection itself introduces instrumentation overhead. If all available data is collected simultaneously, the additional instrumentation can affect performance and potentially make the collected data less representative of the original runtime behavior. For this reason, GOT Online previously separated performance data collection into four analysis modes. Each mode could collect specific data independently to reduce interference between different types of data. However, running separate tests for different analysis modes also increases the workload for QA and testing teams. To balance data coverage and analysis depth, GameOptim has adjusted the GOT Online data collection model. Overview mode now supports configurable Resource and Lua data collection. This allows performance data with logical relationships to be captured in the same report, reducing redundant testing while supporting the required analysis. Because enabling different data collection modes can have different effects on performance, developers should review the relevant documentation and its notes when configuring a test according to their analysis requirements. Can IL2CPP Packages Support Deep Mono Data Analysis? Mono heap allocation is an important part of performance optimization. Continuous Mono heap allocation not only increases memory usage but can also trigger GC and cause stuttering. In projects with more serious Mono memory leaks, excessive memory consumption can also lead to crashes. GOT Online now supports deep Mono data analysis for IL2CPP packages. With SDK 2.4.5 integrated and the Script Debugging option enabled when building the package, developers can collect and analyze Mono data directly from an IL2CPP package without having to build a separate Mono package. Using the GOT Online Mono mode, developers can collect and analyze heap memory allocation and leakage data to help identify performance issues related to the project's Mono module and proceed with optimization. How Can Developers Analyze Resource, Lua, and Mono Memory in More Detail? GOT Online adds a dedicated memory analysis module covering three areas: Resource memory Lua memory Mono memory These modules provide different levels of detail depending on the data collection configuration. What Resource Memory Data Can Developers Analyze? When the Resource mode is not enabled during testing, the resource statistics module records the quantity and size of commonly used resources at important points in the test, including the starting frame, every 1,000 frames, scene switch frames, and the ending frame. The tracked resources include: Textures Meshes Shaders Fonts RenderTextures Particle systems When Resource mode is enabled, GOT Online collects more detailed information about the usage of these resources. For example, texture analysis can include: Memory usage Peak quantity Width Height Lifetime Whether Read/Write is enabled This allows developers to investigate texture usage in greater detail. What Lua Memory Data Can Developers Analyze? When Lua mode is enabled during testing, the Lua memory section provides data covering: Overall heap memory Detailed heap allocations Mono object references This helps developers analyze Lua memory allocation and usage within the project. Lua references to Mono objects can also prevent Mono heap memory from being released and contribute to memory leaks. Therefore, analyzing Mono object references can provide additional information when investigating Mono memory leakage related to Lua. How Can Developers Monitor Mono Heap Usage? Mono memory analysis includes two metrics: Mono Reserved Mono Used These metrics allow development teams to monitor both the amount of memory reserved for the Mono heap and the amount actually being used. When Mono heap memory is high, GameOptim recommends keeping it within 80 MB . In this situation, developers are advised to use GOT Online Mono mode for further testing and optimization of Mono heap memory allocation. How Can Developers Identify the Functions Behind Stutters? The latest version refines the stutter analysis interface into two pages: 1. Key Function Analysis 2. Stutter Point Analysis This separation provides different views for investigating common sources of stuttering. What Can Key Function Analysis Reveal? Key Function Analysis covers three common types of stutter: Loading GameOptim consolidates relevant functions observed during the test within the Key Function Analysis page. For example, the loading stutter page provides information about functions such as: Developers can inspect their execution time, stutter locations, and call frequency to help identify the causes of loading related stutters. How Does Stutter Point Analysis Help Identify the Cause? The Stutter Point Analysis page retains several existing analysis views, including: Per frame time curves Function call stacks for specified frames Function call timing sequences It also adds dedicated stutter point analysis. The pie chart on the left shows the causes associated with stutter frames. Developers can click into the chart to further investigate the functions contributing to the stutter. When a project is known to have high Lua pressure, developers can also enable the Lua option before testing. In this case, Lua related functions are included in the function call stack and function timing sequence data, providing more detailed information for optimizing the Lua module. How Can Resource Management Help Locate Loading Bottlenecks? As projects become more complex and the number of resources increases, loading and unloading resources can produce more noticeable stuttering. GOT Online's Resource Management module in Resource mode helps developers identify which resources contribute to loading bottlenecks. It also provides detailed timing information for resource loading and unloading, as well as GameObject instantiation and activation. After enabling Resource mode and selecting the Resource Management module, developers can analyze four major areas: AssetBundle loading and unloading Resource loading and unloading Resource instantiation Resource activation How Can Developers Prioritize Resource Loading Problems? The Resource Management overview directly lists the top 10 problematic resources based on loading time and frequency. This allows developers to focus on the resources that require attention and prioritize further optimization. The module also provides information about how different loading interfaces are used. For example, in the Resource Loading & Unloading section, developers can see: Which AssetBundle the resource belongs to Which interface was used Loading time Loading count This provides more detailed information for investigating resource loading behavior. How Has GPU Timing Collection Changed? GameOptim has updated the way GPU timing is collected in this release. After updating the SDK, GPU timing data collection is more stable and supports a wider range of compatible devices. The recommended GPU timing targets are similar to CPU timing targets. For a project targeting 30 FPS , GPU time should remain below 33 ms , with GameOptim recommending 28 ms as a better target. For a project targeting 60 FPS , GPU time should remain below 16 ms . Otherwise, frame drops can become more likely. When GPU pressure is high, developers can combine GPU timing with parameters from the GPU Counter module, including: GPU Load GPU Shading GPU Bandwidth GPU Primitives GPU Shader Cycles These metrics can be used to further investigate and optimize GPU pressure. What Does This GOT Online Update Mean for Performance Testing? The latest GOT Online update focuses on making performance data collection and analysis more efficient without treating data coverage and analysis depth as mutually exclusive goals. Overview mode now supports Resource and Lua data collection, allowing logically related performance data to be captured in a single report. The update also extends deep Mono analysis to IL2CPP packages, adds more detailed memory and stutter analysis, improves Resource Management, and updates GPU timing collection. GameOptim continues to focus on helping developers locate performance issues more efficiently and reduce the time required for performance investigation and optimization. FAQ Why doesn't GOT Online collect all performance data at the same time by default? Collecting different types of performance data introduces different levels of instrumentation overhead. Collecting all available data simultaneously can therefore affect performance and potentially interfere with the collected results. GOT Online previously separated data collection into different modes for this reason. Can Resource and Lua data now be collected in the same GOT Online report? Yes. Overview mode now supports configurable Resource and Lua data collection, allowing related performance data to be captured together in a single report. Can Mono data be analyzed in an IL2CPP package? Yes. With SDK 2.4.5 integrated and Script Debugging enabled during the build, developers can collect and analyze Mono data from an IL2CPP package without building a separate Mono package. What memory areas does the new memory analysis module cover? The memory analysis module covers Resource memory, Lua memory, and Mono memory. The available data depends on the corresponding collection mode and configuration. What does GOT Online Resource Management analyze? Resource Management analyzes four major areas: AssetBundle loading and unloading, resource loading and unloading, resource instantiation, and resource activation. It also provides information such as loading time, loading frequency, AssetBundle association, and the interface used. New users can get 2 hours of free GOT Online testing time after completing registration. https://www.gameoptim.com/?fopt=blog About GameOptim GOT Online GOT Online is a cloud based performance analysis platform with online performance reports for deeper analysis and collaboration. Based on visualized data display, providing targeted analysis suggestions and performance parameter trends, facilitating efficient quality control execution. To meet a wide range of optimization needs, GOT Online provides four major analysis modes: • Overall Performance Analysis • Mono Heap Memory Analysis • Lua Performance Analysis • GPU Performance Analysis