Mali Graphics Debugger
OpenGL ES 1.x, 2.x, 3.x and OpenCL 1.1 API Trace and Debug Tool
The Mali Graphics Debugger allows developers to trace OpenGL ES and OpenCL API calls in their application and understand frame-by-frame the effect on the application to help identify possible issues.
Android and Linux ARM based target platforms are currently supported and everything to get up and running within a matter of moments is provided in the installer package.
Features and Benefits
- Draw-call by Draw-call stepping
To identify draw call related issues, redundant draw calls and other opportunities to optimize
- Texture View
Visualize an application’s texture usage, to identify opportunities to compress textures or change formats.
- Shader Statistics
Understand which vertex and fragment shaders are the most expensive with cycle count reporting
- Vertex Attribute / Uniform View
See vertex data and index buffers
- State View
Full visibility of graphics state and tracking of state changes
- Dynamic Optimization Advice
Highlighting of common API misusage and dynamic performance improvement advice
Histograms for Overdraw MapAnalyze the impact of overdrawing pixels on each framebuffer by looking at the overdraw captures or the new histograms.
The automated trace view allows you to run a range of standard MGD commands automatically when a certain frame is encountered.
For help and support from ARM and fellow developers, please visit the ARM Mali Graphics Community.
Trace API calls
Trace OpenGL ES, EGL, OpenCL API calls with arguments, time, process ID, thread ID.
- Full trace from the start
- Automatic check for GL errors
- Search capabilities
- Multi-process support
Quick access to key graphics events.
- 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.
Target State Debug
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.
Trace Statistics and Analysis
High level statistics about the trace.
- Per frame
- Per draw call
Analyze the trace to find common issues.
- Performance warnings
- API misusage
- Highlight API calls causing a problem in the trace view.
Uniforms and Vertex Attributes for each draw call
When a draw call is selected, all the associated data is available:
- Show uniform values, including samplers, matrices and arrays
- Show all the vertex attributes, their name and their position
All the heavy assets are available for debugging, including data buffers and textures
- Client and server side buffers are captured every time they change
- See how each API call affects them
- All the textures being uploaded are captured at native resolution
- Check their size, format and type
Shaders reports and statistics
All the shaders being used by the application are reported.
Each shader is compiled with the Mali Offline Compiler and is statically analyzed to display:
- number of instruction 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.
Frame capture and analysis
Frames can be fully captured to analyze the effect of each draw call.
- A native resolution snapshot of each framebuffer is captured after every draw call
- The capture happens on target, so target dependent bugs or precision issues can be investigated
All the images can be exported and analyzed separately.
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 the 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.