Profiling and debugging your Unity mobile games

Transcription

1 Profiling and debugging your Unity mobile games Stephen Barton Technical Specialist Google Campus London 20/10/2016 ARM 2016

2 Agenda 1. Introduction to ARM tools for developers 2. DS-5 Streamline Performance Analyser 3. Mali Graphics Debugger 4. Mali Graphics Debugger in Unity 5. Analyse the performance of Ice Cave 6. Q & A 2 ARM 2016

3 Importance of Analysis & Debug Mobile Platforms Expectation of amazing console-like graphics and playing experience Screen resolution beyond HD Limited power budget Solution ARM Cortex CPUs and Mali GPUs are designed for low power whilst providing innovative features to keep up performance Software developers can be smart when developing apps Good tools can do the heavy lifting 3 Confidential ARM 2016

4 Mali Tools Suite 4 Confidential ARM 2016

5 Mali Offline Compiler Analyze shader performance Command line tool Number of cycles Registers utilization Mali Graphics Debugger API Trace & Debug OpenGL ES, OpenCL Debug and improve performance at frame level Mali GPU Tools Performance Analysis, Debug, and Software Development ARM DS-5 Streamline Profile CPUs and Mali GPUs Timeline HW Counters OpenCL visualizer OpenGL ES Emulator Emulate OpenGL ES 2.0, 3.1 Supports Android Extension Pack Windows and Linux Benchmarked against Khronos Texture Compression Tool Command line and GUI ETC, ETC2, ASTC, 3D textures ASTC encoder Available on GitHub 5 Conformance Suite Confidential ARM 2016

6 Development with tools from ARM Move to Target Develop Chosen IDE or engine Mali Offline Compiler Checks shader correctness Run Mali Emulator Mobile graphics on your desktop OpenGL ES Allows faster development iterations 6 Confidential ARM 2016

7 Performance Analysis and Debug with tools from ARM Analyze DS-5 Streamline Profile CPUs and Mali GPUs Timeline HW Counters OpenCL visualizer Optimize Mali Offline Compiler Analyze shader performance Command line tool Number of cycles Registers utilization Debug Mali Graphics Debugger API Trace & Debug OpenGL ES, OpenCL Debug and improve performance at frame level 7 Confidential ARM 2016

8 Speed Up Your Code Find out where the CPU is spending the most time Tune code for optimal cache usage Drill down to the Source Code Break performance down by function View it alongside the disassembly ARM DS-5 Streamline Performance Analyzer OpenCL Visualizer Visualization of OpenCL dependencies, helping you to balance resources between GPU and CPU better than ever Mali GPU Support Analyze and optimize Mali GPU utilization Monitor CPU and GPU cache usage Optimize energy efficiency Monitor actual power consumption with the ARM Energy Probe Correlate software execution to actual power consumption Customize it for Your System Flexible architecture permits easy addition of new counters Open source driver and daemon gives developers ultimate flexibility 8 Confidential ARM 2016

9 Process to Success Timeline Call Paths Functions Code Log Visualization of system performance metrics, software profile and system events over time Hierarchical profile table, aggregating samples per process, thread, and function call chain Flat software profile table, listing shared libraries and function hotspots Source and instruction level profile. Color coded source code lines for easy identification Chronologic list of text and graphic user annotations sent to Streamline, offering flexible filtering 9 Confidential ARM 2016

10 Timeline: Mali GPU Graphics Performance Analysis CPU and GPU fragment and vertex processing activity Mali GPU hardware and OpenGL driver counters, including samples screenshots Process heatmap focused on GPU Fragment activity 10

11 Advanced Drawing Modes Native mode Overdraw mode Advanced API Debugger Graphics debugging for content developers OpenGL ES 1.1, 2.0, 3.1, EGL, OpenCL Shader map mode Fragment count mode Mali Graphics Debugger Trace graphics and compute applications to debug issues and analyze the performance Frame Analyzer Understand issues and causes at frame level Complimentary to ARM DS-5 Streamline Android Application Start/stop daemon List all the debuggable processes Launch application to debug Graphics State Visibility Shows the current state of the API at any point of the trace Discover when and how a certain state was changed Analyse shaders and kernels All the shaders being used by the application are reported Shader statistics Each shader is compiled with the Mali Flexible and cross platform Runs on Windows, Linux and Mac Traces from Android and Linux targets 11 Confidential ARM 2016 Offline Compiler and is statically analyzed

12 Investigation with the ARM Mali Graphics Debugger Assets View Frame Statistics Frame Outline API Trace Dynamic Help Frame Capture: Framebuffers States Uniforms Vertex Attributes Buffers Textures Shaders 12

13 Mali Graphics Debugger Outline view Quick access to key graphics events Frames Render targets Draw calls Investigate at frame level Find what draw calls have higher geometry impact Jump between the outline view and the trace view seamlessly 13

14 Mali Graphics Debugger Target state Shows the current state of the API at any point of the trace Every time a new API call is selected in the trace the state is updated Useful to debug problems and understand causes for performance issues Discover when and how a certain state was changed 14

15 Mali Graphics Debugger All the heavy assets are available for debugging, including data buffers and textures. Buffers Client and server side buffers are captured every time they change See how each API call affects them Textures All the textures being uploaded are captured at native resolution Check their size, format and type 15

16 Mali Graphics Debugger Shaders reports and statistics All the shaders being used by the application are reported Shader statistics Each shader is compiled with the Mali Offline Compiler and is statically analyzed to display: number of instructions for each GPU pipeline number of work registers and uniform registers Additionally, for each draw call MGD knows how many times that shader has been executed (i.e. the number of vertices) and overall statistics are calculated 16

17 Mali Graphics Debugger Alternative drawing modes Different drawing modes can be forced and used both for live rendering and frame captures Native mode Frames are rendered with the original shaders Overdraw mode Highlights where overdraw happens (ie. objects are drawn on top of each other) Shader map mode Native shaders are replaced with different solid colors Fragment count mode All the fragments that are processed by each frame are counted 17

18 Mali Graphics Debugger with Unity 18 Confidential ARM 2016

19 Setup MGD for Unity 1 Step 1: Placing library in application Create the folder Assets\Plugins\Android folder in your project. Find the libmgd.so library in your MGD installation directory. It will be located in android-nonroot\arm\[armeabi-v7a/arm64-v8a] Copy this to your Assets\Plugins\Android directory. Step 2: Creating a new Android Activity 19

20 Setup MGD for Unity 2 Step 3: Compiling the activity into a class file Activity extends from the Unity activity so you need to add the classes.jar. As we are using Android we need to include the android.jar from the relevant SDK as well Android.jar needed from Android Classes.jar needed from Unity Step 4: Packaging activity up in a jar For Unity to use it we also need to pack up the files into a jar 20

21 Setup MGD for Unity 3 Step 5: Overloading default AndroidManifest.xml By default your new activity won t be loaded. To do this we need to create a new Android Manifest to load it. Place this file also in your Assets\Plugins\Android folder Step 6: Deploy & Trace Build your application like usual and generate your apk. Place the apk on device. Open the MGD application and select your application and you should be able to trace your application. Help can be found at community.arm.com and in the user documentation provided with MGD. 21

22 Mali Graphics Debugger New Features 22 ARM 2016

23 Mali Graphics Debugger Vulkan Support Trace Assets View Function Parameters Buffers Allows full API trace of Vulkan applications. Shows you easily all of the function parameters available. Implemented as a Vulkan layer which shows easy loading. Also shows Asset data and buffer information. Implemented perspectives to hide information that isn t related to a particular API 23 ARM 2016

24 Mali Graphics Debugger VR Support VR is becoming more and more popular. Games companies are generating more content. GDC this year had a dedicated day just for VR content. MGD supports VR by a series of heuristics to understand whether to treat glflush as the end of Frame or not. Works with Unity and internal demos. Ice Cave VR 24 Confidential ARM 2016

25 New Features in the Mali Graphics Debugger Geometry Viewer Visualize all of your geometry per draw call. Zero overhead to the application so you get this feature for free. Open all your old traces and they will now have this support. Render pass Dependencies MGD can now show you the dependencies on your scene. Can do this for textures, render buffers and blits of the Framebuffer Texture 1 Draws to Texture 1 Reads from Texture 1 Render pass 0 Render pass 1 25 Confidential ARM 2016 Render pass 1 has a dependency on render pass 0 due to texture 1

26 Case Study: Ice Cave 26 ARM 2016

27 Ice Cave 27

28 Main Bottlenecks CPU Too many draw calls Complex physics Vertex processing Too many vertices Too much computation per vertex CPU Memory Vertices Textures Uniforms Fragment processing Too many fragments, overdraw Too much computation per fragment Vertices Uniforms Triangles Varyings Textures Uniforms Varyings Pixels Bandwidth Big and uncompressed textures High resolution framebuffer Vertex Shader Fragment Shader 28

29 CPU Activity User 25% GPU Fragment Activity 99% GPU Vertex Activity 7% 29

30 CPU Bound Synchronous Rendering Mali GPU is a deferred architecture Do not force a pipeline flush by reading back data (glreadpixels, glfinish, etc.) Reduce the amount of draw calls Try to combine your draw calls together Offload some of the work to the GPU Move physics from CPU to GPU Deferred Rendering Avoid unnecessary OpenGL ES calls (glgeterror, redundant stage changes, etc.) 30

31 Vertex Bound Get your artist to remove unnecessary vertices LOD switching Only objects near the camera need to be in high detail Use culling Too many cycles in the vertex shader 31

32 Vertex Count and Shader Optimizations Identify the top heavyweight vertex shaders Vertex Cycles Per Program 10% 23% 12% 18% 37% Shader 164 Shader 158 Shader 173 Shader 176 Others 32

33 Fragment Bound - Inspect the Tripipe Counters Reduce the load on the Arithmetic pipeline GPU Cycles 593m Tripipe Cycles 576m Arithmetic 361m Texture 228m Load & Store 214m 33

34 Tripipe Counters Cycles per instruction metrics It s easy to calculate a couple of CPI (cycles per instruction) metrics: For the load/store pipeline we have: 228m (Mali Load/Store Pipe LS instruction issues) / 190m (Mali Load/Store Pipe LS instructions) = 1.2 cycles/instruction 100% 95% 90% 85% Stalls For the texture pipeline we have: 215m (Mali Texture Pipe T instruction issues) / 187m (Mali Texture Pipe T instructions) = 1.15 cycles/instruction 80% 75% Load & Store Pipeline Texture Pipeline Instructions 34

35 Fragment Bound Render to a smaller framebuffer Move computation from the fragment to the vertex shader (use HW interpolation) Drawing your objects front to back instead of back to front reduces overdraw Reduce the amount of transparency in the scene 35

36 Frame Analysis Check the overdraw factor 5x 3-5x 5x 8x 3x 36

37 Shader Map and Fragment Count Identify the top heavyweight fragment shaders Fragment Count Per Program ~10m instances / ( ) pixel = % 4% 7% 75% Program 175 Program 280 Program 181 Others 37

38 Bandwidth When creating embedded graphics applications, bandwidth is a scarce resource A typical embedded device can handle 5.0 Gigabytes a second of bandwidth A typical desktop GPU can do in excess of 100 Gigabytes a second The application is not bandwidth bound as it performs, over a period of one second: (96m (Mali L2 Cache External read beats) m (Mali L2 Cache External write beats)) x 16 ~= 2.9 GB/s Since bandwidth usage is related to energy consumption it s always worth optimizing it 38

39 Bandwidth Bound Vertices Reduce the number of vertices and varyings Interleave vertices, normals, texture coordinates Use Vertex Buffer Objects Fragments Use texture compression Enable texture mipmapping This will also cause a better cache utilization. 39

40 Resources Enhancing Your Mobile Games ARM Guide to Unity Connected Community Tools op-for-mali/tools/ 40