advertisement
Mali Graphics Debugger 3.0.0
User Guide
©
ARM Limited 2015
| Introduction | 2
Chapter
1
Introduction
Topics:
•
•
•
•
| Introduction | 4
Overview
The Mali Graphics Debugger is a tool to help OpenGL
®
ES and OpenCL
™
developers get the best out of their applications through analysis at the API level. The tool allows the user to observe OpenGL ES and OpenCL API call arguments and return values, and to interact with a running target application so as to investigate the effect of individual calls on the target. Attempted misuse of the API is highlighted, as are recommendations for improvement on a Mali-based system. Trace information may also be captured to a file on one system and be analyzed later. The state of the underlying GPU subsystem is observable at any point.
This document describes how to install and use the Mali Graphics Debugger on Windows, Linux and
Mac OS X
®
. It describes how to examine an OpenGL ES 2.0, 3.0 or 3.1 application running on a Linux or Android
™
target.
Installation Package
The installation package for the Mali Graphics Debugger contains everything you need to start investigating OpenGL ES 2.0, 3.0 or 3.1 applications on a desktop computer. Limited support for
OpenCL 1.1 is also provided.
You should have downloaded the installation package appropriate to your platform. The Mali Graphics
Debugger is available for Windows, Linux and Mac OS X, and comes in both 32-bit and 64-bit variants.
Typically, you should download the package that most closely resembles your host environment.
Components
The installation package contains three main components: the GUI application, the target intercept components and Mali Graphics Debugger sample traces.
This release
This is a major release following the 2.1.0 release of the tool, it adds the features and fixes the issues listed below:
• We've changed our underlying GUI framework and added a few new UI features to most views. The change will allow us to provide an even better UI in the future. Some highlights include:
• A new Timeline view which allows you to get an at-a-glance overview of the rendering model for an application.
• The return of the Framebuffer view!
• A new breadcrumb bar to help users navigate around the trace.
• Vastly improved UI responsiveness:
• The new UI is compartmentalised such that large data sets in one view will not adversely affect performance of other views.
• The underlying GUI framework now allows us to load far larger data sets dynamically resulting in better UI responsiveness while live tracing.
• Improved support for multiple processes and multiple contexts in traces.
•
capture depth, stencil and all colour (MRT) attachments
when using Frame Capture.
• A compressed trace format which improves performance of tracing and capturing. It also allows for smaller saved trace files.
• Support for Linux targets running on 64-bit ARM platforms.
• Support for x86 and x86-64 Android targets.
Chapter
2
Minimum Requirements
Topics:
•
•
•
•
| Minimum Requirements | 6
Host System Requirements
The host should be able to connect to the target via TCP/IP (for online analysis) and should have port
5002 open.
The installation requires around 350MB of disk space.
Up to 2GB of RAM will be claimed by the installed application as it runs. If available, more memory may be allocated to the application, which will allow larger traces to be accommodated.
Up-to-date operating system components and graphics drivers are recommended.
Increasing Available Memory
Increasing the amount of memory made available to the application will increase the maximum trace size that may be accommodated. To do this, locate the mgd.ini file within the application installation and open it with a text editor. Find the Java Virtual Machine (JVM) argument starting with ‘-Xmx…’.
The number that follows the argument defines the maximum amount of memory that the application will claim when running, with a trailing ‘m’ for megabytes. This number can be increased to match the capabilities of your system. Please note the format for the argument and ensure that your modifications follow the same format exactly (i.e. no spaces, trailing lower-case ‘m’). The number you enter must be a multiple of 4.
Temporary Storage
Depending on the complexity of the application being traced, the Mali Graphics Debugger can require a large amount of temporary disk storage. By default, the system temporary storage directory is used. If the free space available in this directory is too little, MGD will display a warning and stop caching data to the directory, increasing memory usage.
The temporary storage directory can be changed by clicking on Edit # Preferences and selecting an existing directory to be used in the Custom temporary storage directory field.
Target System Requirements
In general, the Mali Graphics Debugger should work on any Linux system that supports OpenGL ES
2.0, 3.0 or 3.1. Limited support is provided in this release for OpenCL 1.1. The system should be able to substitute the existing OpenGL ES or OpenCL system libraries with the supplied intercept libraries.
The specific method for doing this is platform-specific.
In addition, the application supports Android
™
4.2, 4.3, 4.4, 5.0, and 5.1 on the Google Nexus 10 platform. Other platforms should also work correctly although these have not been tested.
MGD is supported only on target systems using an ARM Mali GPU.
Chapter
3
Host Installation
Topics:
•
•
•
•
| Host Installation | 8
Linux
On Linux, the Mali Graphics Debugger is provided as a gzipped tar archive that can be extracted to any location on disk. This package can be extracted using any modern version (i.e. > 1.13) of GNU tar: tar xvzf Mali_Graphics_Debugger_v<version>.<build>_Linux_<arch>.tgz
The GUI executable is ‘mgd’ within the gui directory
Windows
On Windows, the Mali Graphics Debugger is provided as an executable installer package. To install the software, run the installer and follow the instructions on screen. A link to the installed GUI will be added to the Start menu.
Mac OS X
On Mac OS X, the Mali Graphics Debugger is provided as a dmg package. It can be mounted by double-clicking on it. The GUI executable is ‘mgd’ within the gui directory and can be launched either from the dmg package or from the local filesystem after copying the mounted folder to the local disk.
On Mac OS X version 10.9 (Mavericks) and later, the system will prevent you from running MGD as the package is not signed. The workaround is to hold the CTRL key down when opening the app.
Target Deliverables
The extracted directory hierarchy on the host will contain a ‘target’ directory containing the following additional directories:
• linux/soft_float
Containing daemon and libraries for Linux-based ARM target devices.
• linux/hard_float
Containing daemon and libraries for Linux-based ARM Hard Float target devices.
• linux/arm64
Containing daemon and libraries for Linux-based ARMv8 (64-bit) target devices.
• android/arm
Containing daemon and libraries for Android-based ARMv8 (64-bit) and ARMv7 (32-bit) target devices.
• android/intel
Containing daemon and libraries for Android-based x86-64 (64-bit) and x86 (32-bit) target devices.
• android-non-root
Containing Android daemon application, makefile and libraries for unrooted Android-based ARMv8
(64-bit) and ARMv7 (32-bit) target devices.
Note: You will be required to manually add the libraries to your execution environment, see
on page 10 for details.
Chapter
4
Target Installation
Topics:
•
•
•
•
•
| Target Installation | 10
Target Installation Overview
The Mali Graphics Debugger has two target components that interact to collect and transmit trace information from your application to the GUI on the host. These two target components are:
Intercept Library: The intercept library intercepts calls made by your application to one of the supported libraries and collects information about each call as it is made on the underlying system. The intercept library needs to be loaded before your application starts.
Daemon: The daemon application collects trace data from all running, intercepted applications and passes this data to the host. All data is transferred using TCP/IP using port 5002.
The method for using these components varies by target platform.
Linux
Prerequisites
• A running OpenGL ES or OpenCL application.
• A network connection to a host running the MGD GUI.
• The target device should permit TCP/IP communication on port 5002.
Installation
Navigate to the target directory and enter either the linux/soft_float folder (soft float implementation),
linux/hard_float (hard float implementation) or linux/arm64 (ARMv8 implementation) according to the configuration of your system. Inside this folder there should be the following:
• libinterceptor.so
• mgddaemon
These files need to be copied to the target device. The location of the files does not matter as they should be able to run anywhere as long as the user has sufficient privileges. The execute permission bit needs to be set on the mgddaemon application. This can be done using the following command from the directory on the target to which the files were copied.
chmod +x ./mgddaemon
Run Instructions
To capture traces into MGD the user needs to do the following:
1. Start the daemon running if not already started.
2. Start a capture from the MGD GUI.
3. Start your application with the intercept libraries enabled.
Start the Daemon
The daemon should be started before you run your first trace. In a terminal, run:
./mgddaemon & from the directory you which you copied the daemon. The daemon can remain running for the duration that MGD is being used, and will handle applications starting and stopping.
Start MGD GUI
Once the daemon has started connect the MGD GUI to the target by starting a capture.
| Target Installation | 11
Intercept the Application
To intercept the application correctly the system needs to preload the intercept library libinterceptor.so, in the MGD target distribution. To do you need to define the LD_PRELOAD environment variable to point at this library. For example:
LD_PRELOAD=/path/to/intercept/libinterceptor.so ./your_app
When the application starts, trace data should start to fill the trace window on the MGD GUI.
If you are unable to use LD_PRELOAD on your system there is an alternative; see
Intercepting without using LD_PRELOAD
on page 41 for more information.
Choosing the correct architecture
You must make sure you use the correct libraries for your target architecture. If you are running on
ARMv7 architecture you must use either the soft-float libraries found in linux/soft_float, or the hardfloat libraries found in linux/hard_float depending on the requirements of your system.
If you are running on ARMv8 (64-bit) and intend to trace a 64-bit application, you must use the files found in linux/arm64. This folder includes a 64-bit build of the daemon.
If you are running on ARMv8 but are intending to trace a 32-bit application you must use the appropriate ARMv7 library which will probably be the hard-float version found in linux/hard_float.
Uninstalling
To uninstall simply remove the files which were loaded onto the target.
Android
Prerequisites
• Android Software Development Kit (SDK) installed on a machine that connects to the Android device.
• PATH should include the path to the adb binary.
• The target device should be rooted and allow modification of the /system partition. If that is not possible, MGD provides an alternative, but it has certain limitations and application startup
performance will suffer. To install MGD on an unrooted device, see
.
• The target device should permit TCP/IP communication on port 5002.
• For Android targets you will need at least 4 Mb free on the
/system
partition, plus an additional 5
Mb if you are also installing the 64-bit interceptor. Certain devices, such as the Nexus 10, may ship with very little free space on the system partition, and it may not be possible to install MGD without manually freeing up space in the system partition.
To check free space in the system partition, run the following command from a host command line: adb shell df /system
Installation
On 32-bit Android targets you will need to install the interceptor library target/android/arm/ armeabi-v7a/libGLES_mgd.so
, and the mgddaemon executable target/android/arm/ mgddaemon
onto your target device by following these instructions.
Run the following commands from a host command line from the target/android/arm/
directory located in installation directory of the MGD tool.
1. Copy the interceptor and MGD daemon to the device: adb push armeabi-v7a/libGLES_mgd.so /sdcard/ adb push mgddaemon /sdcard/
| Target Installation | 12
2. All of the remaining commands in this section should be run on the Android device as a super user.
Access the device and enter super user mode by running: adb shell su
3. To make sure your system partition is writable, run: mount -o remount /system
4. Setup MGD on the device: cd /sdcard/ cp mgddaemon /system/bin/mgddaemon cp libGLES_mgd.so /system/lib/egl/libGLES_mgd.so
You may receive an error message such as: cp: /system/lib/egl/libGLES_mgd.so: No such file or directory
This means that there is not enough space in the
/system
for more information.
5. Tell Android to use the MGD interceptor by editing egl.cfg
(backing it up before you do). Run the following on device: cp /system/lib/egl/egl.cfg /system/lib/egl/egl.cfg.bak
echo "0 0 mgd" > /system/lib/egl/egl.cfg
6. If your system is Android 4.4 or above, to make Android load the MGD interceptor library before the system library, the interceptor library must be named
/system/lib/egl/libGLES.so
. Usually there will not be a library with that name on the system, so it is sufficient to run: ln -s /system/lib/egl/libGLES_mgd.so /system/lib/egl/libGLES.so
7. If your system uses a non-monolithic driver (i.e. there are files called libGLESv2_*.so
, libGLESv1_CM_*.so
, and libEGL_*.so
in
/system/lib/egl/
or
/vendor/lib/egl/
), you will need to replicate that driver structure with MGD. To do this, run: ln -s /system/lib/egl/libGLES_mgd.so /system/lib/egl/libEGL_mgd.so
ln -s /system/lib/egl/libGLES_mgd.so /system/lib/egl/ libGLESv1_CM_mgd.so
ln -s /system/lib/egl/libGLES_mgd.so /system/lib/egl/libGLESv2_mgd.so
8. Grant appropriate permissions to the MGD libraries and interceptor: chmod 777 /system/bin/mgddaemon chmod 777 /system/lib/egl/*
9. Reboot the device.
Once the steps above have been completed all subsequently opened applications will pass all OpenGL
ES/EGL calls through libGLES_mgd.so
.
Installation instructions for 64-bit devices
On 64-bit Android devices, you will need to install two copies of the interceptor library, one for 32-bit code and one for 64-bit code. To install the 32-bit interceptor follow the instructions specified in
the installation instructions for 32-bit Android
You will then need to repeat the process using the interceptor library target/android/arm/arm64v8a/libGLES_mgd.so
but copying it into
/system/lib64/egl/
instead of
/system/lib/egl/
.
adb shell su -c mount -o remount /system
adb push arm64-v8a/libGLES_mgd.so /sdcard/
adb shell
| Target Installation | 13
The following commands run on the target:
su cd /sdcard/ cp libGLES_mgd.so /system/lib64/egl/libGLES_mgd.so
chmod 777 /system/lib64/egl/libGLES_mgd.so
cp /system/lib64/egl/egl.cfg /system/lib64/egl/egl.cfg.bak
echo "0 0 mgd" > /system/lib64/egl/egl.cfg
ln -s /system/lib64/egl/libGLES_mgd.so /system/lib64/egl/libGLES.so
You should end up with two copies of the interceptor:
A 32bit version in
/system/lib/egl
A 64bit version in
/system/lib64/egl
Choosing which Applications/Processes to Trace
By default MGD will trace all running OpenGL ES applications. It can be preferable to limit MGD to only trace applications you're interested in.
To do this, the name of the application that should be traced should have its name written in
/system/ lib/egl/processlist.cfg
. The processlist.cfg file may contain more than one process name, separated by a newline character.
Note: The processlist.cfg should have appropriate permissions. You can achieve this by running: chmod 666 /system/lib/egl/processlist.cfg
on the target device.
For convenience, the interceptor will print the name of any processes which link against OpenGL ES to logcat, so the name of the process can be found in this way. For example the line in logcat will read:
I/mgd_interceptor(11844): (11844): Interceptor: Interceptor loaded for
11844: com.arm.mali.Timbuktu
In which case your processlist.cfg file should contain a single line: com.arm.mali.Timbuktu
Note: If
/system/lib/egl/processlist.cfg
exists but is empty then no applications will be traced.
Run Instructions
If you wish for MGD to connect to the daemon over USB, then you will need to run the following on the host: adb forward tcp:5002 tcp:5002
Next ensure you are running the daemon. In a terminal, run: adb shell su mgddaemon
Now in MGD you can connect to the IP of the target, or to 127.0.0.1:5002 if using USB, and start you application.
Note: If an application is started before the daemon is started, only the function calls made from the time when the daemon was started will be traced.
Uninstalling
To uninstall MGD we will reverse the installation process.
| Target Installation | 14
1. All of the commands in this section should be run on the Android device as a super user. You can access the device and enter super user mode by running: adb shell su
2. To make sure your system partition is writable, run: mount -o remount /system
3. Start by removing the interceptor libraries and the MGD daemon: rm /system/bin/mgddaemon rm /system/lib/egl/libGLES_mgd.so
4. If you modified system/lib/egl/egl.cfg
you should restore it now from the backup you made by running the following command: cp /system/lib/egl/egl.cfg.bak /system/lib/egl/egl.cfg
5. If you created the
/system/lib/egl/libGLES.so
symlink when installing you should remove it now by running the following command: rm /system/lib/egl/libGLES.so
6. If you created symlinks for a non-monolithic system, you should remove them now by running the following command: rm /system/lib/egl/libEGL_mgd.so
rm /system/lib/egl/libGLESv1_CM_mgd.so
rm /system/lib/egl/libGLESv2_mgd.so
7. Finally, the target device should be rebooted to allow the original libraries to be reloaded.
Unrooted Android
Prerequisites
• Android Software Development Kit (SDK) installed on a machine that connects to the Android device;
• PATH should include the path to the adb binary;
• The target device should permit TCP/IP communication on port 5002;
• The source code for the application to be traced should be accessible.
• The Android device must be running Android 4.2 or above.
Limitations
There are several drawbacks to installing MGD inside the target application rather than in the /system partition of the device. These are outlined below:
• The method requires source code access
• Tracing extensions may work but is unsupported
• Application start times may increase compared to the standard installation approach
Due to these limitations, ARM recommends that the intercept library is installed in the /system partition whenever possible.
Installation
Installation on a non-rooted device involves modifying the source code and build script of the application that needs to be traced, installing the MGD Daemon application on the target device, and running it prior to launching the application to be traced.
The steps to successfully tracing an application without rooting your device are listed below:
| Target Installation | 15
1. Copy the folder called android-non-root target redistributables to the root folder of the target application.
2. Add the following line to the target application's
Android.mk
, at the end of the file: include $(LOCAL_PATH)/../android-non-root/MGD.mk
Note: The line above assumes LOCAL_PATH points to the jni folder. Adjust as necessary.
3. Add the following code to your project's main Activity class: static {
try {
System.loadLibrary("MGD");
}
catch( UnsatisfiedLinkError e ){
// Feel free to remove this log message.
Log.i("[ MGD ]", "libMGD.so not loaded.");
}
}
4. Recompile the application and install it on your Android device.
5. Run the following commands from a host command line from the target/android-non-root directory located in installation directory of the MGD tool.
adb install -r MGDDaemon.apk
This will install the MGD Daemon as an Android app, so that it can be run on an unrooted device. It fulfils the same role as the console application mgddaemon.
Run Instructions
If you wish for MGD to connect to the daemon over USB, then you will need to run the following on the host: adb forward tcp:5002 tcp:5002
Next ensure you are running the daemon. Run the MGD Daemon application and switch it to the "ON" state.
Now in MGD you can connect to the IP of the target, or to 127.0.0.1:5002 if using USB, and start your application. The MGD Daemon application provides a list of all traceable applications for your convenience.
Uninstalling
Uninstallation of the MGD Daemon follows the same principle as any other Android application. Simply open the menu, press and hold on the application's icon, then drag it to the uninstall (trash bin) icon onscreen.
To exclude libMGD.so from the target application's build, simply comment out or delete the code you
added in the installation instructions (
on page 14).
Troubleshooting
Target devices with no cp support
On systems that do not have cp, you can instead use cat on the target, e.g: cat /sdcard/libGLES_mgd.so > /system/lib/egl/libGLES_mgd.so
| Target Installation | 16
No Trace Visible
The interceptor component on the target reports through logcat on Android. If no trace is found then it is advisable to review the logcat trace. Generally you should:
• [Linux] Ensure that the interceptor library is in your PRELOAD path.
• [Android] Ensure that your processlist.cfg is set correctly.
• [Android 4.3 and earlier] Ensure that the egl.cfg file has been correctly modified.
• [Android 4.4 and later] The system has to be fully restarted to load the intercept library.
• Ensure you force close and reopen your application after installing the interceptor, to ensure the interceptor is loaded.
• Ensure the daemon is started before the application.
• Ensure your application is making OpenGL ES or OpenCL calls.
Frame Capture doesn’t work on Android 4.4 and above
If you find that the frame capture feature of MGD is not working on an Android 4.4 (or above) device, it may be because the application is manually loading the graphics libraries based on the information in / system/lib/egl/egl.cfg. To check if this is the case and to resolve the problem, try to move /system/lib/ egl/egl.cfg by running the following commands: adb shell
# The following commands run on the target su mv /system/lib/egl/egl.cfg /system/lib/egl/egl.cfg.bak
Socket Permission Errors
The MGD interceptor uses a abstract namespace Unix domain socket (AF_UNIX) to connect to the
MGD daemon. This doesn't require any special permissions for your application. However, certain platforms with additional security measures may limit access to AF_UNIX sockets.
If you've followed the instructions in the installation guide but are getting no trace output, have a look at the log output on your device (e.g. using adb logcat
on Android). If you see something like:
06-26 20:57:18.430: I/mgd_interceptor(9622): Trying to connect to the
daemon...
06-26 20:57:18.430: E/mgd_interceptor(9622): error socket connect:
Permission denied
There is a permission issue on abstract namespace AF_UNIX sockets, which is stopping the interceptor talking to the daemon. In this case it's worth talking to your platform vendor to determine how to enable access to AF_UNIX sockets.
If your device uses SElinux then running "setenforce 0" on the device can enable access to AF_UNIX sockets.
Chapter
5
Getting Started with MGD
Topics:
•
•
| Getting Started with MGD | 18
Running the Host GUI
Run the application:
• On Windows by double-clicking the MGD icon.
• On Linux by running
/path/to/installation/gui/mgd &
• On Mac OS X by double-clicking the MGD icon inside the gui directory.
The main window should open.
Load one of the supplied sample traces from /path/to/installation/samples using File # Open, or using the toolbar button. The various application windows should fill with information from the loaded trace that you may examine at will.
Using the Mali Graphics Debugger on Your Application
Before running your application, ensure that the supplied daemon application is running and that the appropriate interception libraries are in place. See
information.
Note: It is not necessary to rebuild your application to enable tracing.
Tracing a Live Application
Select Debug # Set Target IP… and review the target connection details. Ensure that port 5002 is open to allow the daemon to transfer data to the host application.
With both target and host applications running as before, start a live trace by pressing the toolbar button. The GUI should show the trace dynamically streaming from the target.
When ready, stop the trace by pressing the toolbar button.
Pausing, stepping frames and resume
The currently selected process can be paused by pressing the button; the process will be halted at the next eglSwapBuffers() call to allow you to examine the result. Pressing this button again before the process has paused will force the application to pause on the next function call (regardless if it is eglSwapBuffers() or not).
All connected processes can be paused by pressing the button; the processes will be halted at the next eglSwapBuffers() call to allow you to examine the result.
Once paused, individual frames for the selected process can be rendered on target by stepping with the button.
The selected process may be resumed by pressing the button.
Note: Only the threads that are calling the graphics API functions will be paused.
Capturing Framebuffer Content
Whilst executing, it is possible to perform an in-depth capture of the output from the graphics system on a draw-by-draw basis. Press the button to take a snapshot of framebuffer content following
| Getting Started with MGD | 19 each draw call in the next full frame of the application. Note that this involves considerable work in composing and transferring data that will slow the application down considerably.
In order to capture subsequent frames you will need to pause the application with the button. Once paused, proceed by pressing the button for each frame that needs capturing.
In the Frame Outline view any regular frame will now have a icon to show that it is a captured frame.
Capturing All Framebuffer Attachments
It is possible to capture most framebuffer attachments including all colour attachments, and the depth and stencil attachments. Whilst capturing a live trace, press the button. When a frame is captured with this mode enabled, all the attachments it is possible to capture will be captured for each draw call.
This information is visible for each framebuffer in the Assets View.
Example
In this example 3 squares a drawn on screen with varying depths moving from -1.0 towards 0.0, with a coloured cube rendered behind them. All 4 draw calls (the 3 squares + 1 cube) have different values set for the stencil buffer write mask, with the stencil pass operation set to GL_REPLACE.
Colour Attachment
Depth Attachment
| Getting Started with MGD | 20
Values range from -1.0 ... 1.0, where -1.0 is full blue, 0.0 is black, and 1.0 is full red.
Output is enhanced on the host to increase contrast.
Stencil Attachment
Values are from 0 ... 255, where 0 is black, and 255 is red.
Capturing All Framebuffer Attachments Limitations
There are some limitations to which attachments can be captured by this mode:
• This mode is disabled in the interceptor for Mali-2/3/4xx devices
• It is not possible to capture the depth or stencil attachments for FBO 0 on a GLES 2.0 only configuration
| Getting Started with MGD | 21
• For any configuration where depth texture sampling is not supported, or where the device only has
GLES 2.0 available and the depth attachment is a renderbuffer, only a low resolution capture of the depth buffer is possible.
It is also worth bearing in mind that capturing all attachments increases the per-draw-call capture time and the amount of data transmitted by the device to the host.
Analyzing Overdraw
MGD has the ability to show overdraw in a given scene. Whilst capturing a live trace press the button. MGD will now replace the fragment shader in the target application with an almost transparent white colored fragment shader. Each time a pixel is rendered to the framebuffer the alpha value is increased via an additive blend, meaning the whiter the final image appears the more overdraw happens in that area.
Original Image Image with overdraw feature turned on
An application with low levels of overdraw should appear to be a uniform dull grey.
Any frame with overdraw mode turned on will have this icon in the Frame Outline view.
Analyzing the Shadermap
MGD has the ability to give each shader program in use in a given scene a different solid color. Whilst capturing a live trace, press the button. This allows the shader in use by each object in the scene to be identified, and allows detection of any bugs that may be caused by incorrect shader assignment.
An example of this feature is displayed below:
Original Image Image with shader map feature turned on
There are 100 unique colors that can be assigned to shader programs, at which point programs will have duplicate colors. The program that corresponds to a color can be identified by matching the color in the scene with the color shown in the shader views, as shown below. Alternatively you may position the cursor over a captured framebuffer image (captured in shadermap mode) and the active shader will be identified above the image.
| Getting Started with MGD | 22
Any frame with shadermap mode turned on will have this icon in the Frame Outline view.
Overdraw and Shadermap limitations
Applying any full screen post processing effects, for example rendering to a texture, will prevent the overdraw map or shadermap from displaying correctly on the device. However, the information can be seen by switching to the correct framebuffer in the UI after capturing a frame while either feature is active.
Analyzing the Fragment Count
MGD has the ability to count the number of fragments processed by a shader per draw call. If depth testing is enabled and a fragment would be excluded as a result, then that fragment will not be included in the count.
To toggle this feature, click the button. When enabled, each draw call will increment the Fragments field of the fragment shader used to draw it. The fragment count represents the number of fragments that have been rendered with the selected shader in the current frame up to, and including the currently selected draw call. An example of this feature is shown below.
| Getting Started with MGD | 23
The “Total cycles” field is calculated using the average number of cycles for a given shader multiplied by the number of fragments processed.
Note: The two columns Fragments and Total cycles will only be available for those frames where the fragment count analysis has been requested. These columns will indicate ‘N/A’ (not available) for other frames.
Any frame with fragment count mode turned on will have this icon in the Frame Outline view.
Fragment Count Limitations
To maintain compatibility with older OpenGL ES 2.0 hardware and software, this feature uses a software method to count the number of fragments. As a result, a single draw call can take several seconds to complete. In addition, the target device screen will show only the final draw call in a frame, and the frame capture feature will not show any usable information.
Replaying a Frame
MGD has the ability to replay certain frames on the target device, depending on what calls were in that frame. To see if a frame can be replayed you must pause your application in MGD. Once paused, if a frame can be replayed, the (frame replay) and (frame replay with capture) buttons will be enabled.
Clicking will cause MGD to reset the OpenGL ES state of your application back to how it was before the previous frame had been drawn. It will then play back all the function calls in that frame on the target device. The button operates in the same way except it will also enable
at the same time.
This feature can be combined with the
,
, and
features. You can, for example, pause you application in an interesting position, activate the
Overdraw mode and then replay the frame. The previous frame will be replayed exactly as before but with the overdraw mode enabled. You can repeat this process with the other modes enabled to get a complete picture for a single frame.
Frame Replay Limitations
Frame replay will be disabled if the frame you want to replay:
• creates or deletes any OpenGL ES/EGL objects,
• changes state that had not previously been changed,
• is not complete (i.e. no eglSwapBuffers call),
• has calls from multiple threads/contexts,
• calls various unsupported functions.
| Getting Started with MGD | 24
More information about exactly why frame replay is disabled for a particular frame can be found in the
Console View in MGD.
Frame Overrides
MGD has the ability to change a Frame before replaying it again on a target device. These modifications are made on the Frame Overrides View, which is shown in the image above. At present it is possible to apply the following overrides:
•
Replace a selected texture with a 256 x 256 pixel texture of different colors in a grid like pattern.
•
Replace the shaders of a program with a version that forces a specific precision for all types.
•
Replace both the fragment and vertex shaders of a program with custom versions.
Replace Texture
| Getting Started with MGD | 25
This texture can be used to ensure that the user has generated the texture coordinates of their object correctly. Only the textures that are listed on the Frame Overrides menu will be replaced. These overrides will be in use for every frame replay until they are removed from the Frame Overrides list.
Force Precision
For a given program, the fragment and vertex shader are modified so that any precision specifiers
( highp
, mediump
and lowp
) are replaced with the precision specified by the user, and default precision modifiers are applied to the source for the following types:
ESSL Version
#version 300 es
#version 310 es
Everything else
Types
float
, int
, sampler2D
, samplerCube
, sampler3D
, samplerCubeShadow
, sampler2DShadow
, sampler2DArray
, sampler2DArrayShadow
, isampler2D
, isampler3D
, isamplerCube
, isampler2DArray
, usampler2D
, usampler3D
, usamplerCube
, usampler2DArray float
, int
, atomic_uint
, sampler2D
, samplerCube
, sampler3D
, sampler2DArray
, samplerCubeShadow
, sampler2DShadow
, sampler2DArrayShadow
, sampler2DMS
, isampler2D
, isampler3D
, isamplerCube
, isampler2DArray
, isampler2DMS
, usampler2D
, usampler3D
, usamplerCube
, usampler2DArray
, usampler2DMS
, image2D
, image3D
, imageCube
, image2DArray
, iimage2D
, iimage3D
, iimageCube
, iimage2DArray
, uimage2D
, uimage3D
, uimageCube
, uimage2DArray float
, int
, sampler2D
, samplerCube
When the frame is replayed the modified shaders are used in place of the original shaders allowing the user to observe the effect of changing the precision mode.
Modify Shaders
This override allows you to change both the fragment shader and vertex shader of a particular program. When you select a program and select finish on the wizard, two text editors will be displayed.
One of the editors corresponds to the vertex shader of the program and the other corresponds to the fragment shader of the program.
| Getting Started with MGD | 26
Each editor will allow you to edit that particular shader's source. Once you save your changes these new source files will be stored and be used in the next replay frame of your application. This will happen until the override itself is deleted.
Note: If you do not save your modifications then they won't be used when replaying the frame.
| Getting Started with MGD | 27
There is also an option to compile the source to see if there are any errors that exist in your modifications.
Note: The results of the compilation can be found in the Console view.
If the changes that are made to the shader are invalid. Then the frame override will not be used and the original program will be used instead. Invalid shaders are shaders that either don't compile, or the inputs and outputs don't match the original shader.
Using GPUVerify to Validate OpenCL Kernels
GPUVerify is a tool that has been developed by Imperial College London. It can be used to test whether an OpenCL kernel is free from various issues including: Intra-group data races, inter-group data races and barrier divergence.
GPUVerify is a stand alone application and is not provided by MGD. It needs to be downloaded separately from the Imperial College's
website
. Before using this tool with MGD it is recommended that the user spends time getting GPUVerify working in a stand alone context following its own documentation.
To use this tool with MGD you first need to point MGD to the binary in your GPUVerify directory. To do this click on Edit # Preferences and fill in the Path to GPUVerify field.
| Getting Started with MGD | 28
It is worth noting that the Apply and OK fields will be greyed out if you enter an invalid path in this location.
When tracing a OpenCL application MGD will capture calls to clCreateProgramWithSource, clCreateKernel, clCreateKernelsInProgram and clEnqueueNDRangeKernel. It will then use the data from these functions to get the names for all the OpenCL kernels and the source code associated with them, as well as any runtime parameters that are known at this point such as: the local and global workgroup sizes.
If you want to run any of the kernels found in a trace you just need to click on Debug # Launch
GPUVerify. You should now be presented with a dialogue that looks like the one below.
| Getting Started with MGD | 29
The Combo box beside Kernel Name will list all of the kernels that MGD is aware of from analysing the trace. If the kernel you expect to see isn't there then check that you are not using a binary CLProgram or that MGD started tracing at the beginning of your application. Once you have selected a kernel from the drop down list, MGD will fill in all of the parameters that it knows about.
Feel free to change the values in the dialog box to any valid values that you see fit. They don't have to be the same values that you originally ran the kernel with. There are no restrictions to the Kernel
Build Options. However, the Global Workgroup Size and Local Work Group Size should be in the form
number, number, number. If you enter invalid options an error box will be displayed giving you more information.
The output for GPUVerify will be shown on the MGD Console view.
Comparing State between function calls
During the course of investigation of an application trace, the user may wish to compare the API state between two function calls to examine what has changed. Users may do this using the Generate Diff command.
To compare changes in state between two functions in the trace either select two function calls from the trace using control+click on Windows / Linux hosts, or command+click on OS X hosts, or select two draw calls from the frame outline view, then select Generate Diff from the popup menu.
Difference Report View
| Getting Started with MGD | 30
The difference between state for the two function calls is shown in a new view which is created as a result of running the Generate Diff command. This view shows a table of the items that are different, or have changed at some point between the two functions. Values that have changed, but have since reverted to the original value are highlighted in light blue, where as values that are different between the two functions are highlighted in red. Where state values are made up of multiple components (for example GL_VIEWPORT), the subcomponents are highlighted individually. In this case, subcomponents that have not changed are shown with grey text.
The final column in the output table is labelled Related functions. This lists the numerical id of function calls in the trace which modified the particular state item. By menu-clicking on one of the rows, the user is able to navigate to one of the related functions using the menu that appears.
The results of the state comparison are persistent until the window closes, so it is possible to open multiple differences at a time allowing the user to manually compare sets of changes.
Send Output Buffers
Clicking (Toggle Send Output Buffers Mode) will toggle Send Output Buffers Mode on or off. With
Send Output Buffers Mode enabled, all buffers that have changed as a result of an API call, that have not been uploaded by the user, will be sent from the target device to the host. Certain applications, such as those with heavy use of compute shaders, will require massive amounts of data to be sent to the host, resulting in an extremely slow trace. Disabling Send Output Buffers Mode can temporarily prevent this data from being sent, allowing the interesting parts of the application to be reached much faster.
Send Output Buffers mode can be toggled on or off at any time during a trace. By default, Send Output
Buffers Mode is disabled at the start of each trace.
Chapter
6
Exploring Your Application
Topics:
•
•
•
•
•
•
•
•
•
•
•
•
| Exploring Your Application | 32
API Function Calls
The main editor window shows a table of function calls made by your application as it is running. Use this to examine exactly what your application was requesting of the graphics system and what that system returned.
Each call has:
• the time at which it was made
• the list of arguments sent to the call
• the value (if any) returned by the underlying system when the function was called
• the error code returned by the underlying system when the function was called
• the process ID (PID) of the process the function call was made from
• the thread ID (TID) of the thread the function call was made from
•
any notes the user has added to the function call (see
Note that some columns in this table may be initially hidden – click the button to enable or disable columns.
The Trace Outline shows a frame-oriented view of the trace. Each frame is delimited by a call to eglSwapBuffers(). Draw calls in a frame are grouped by the framebuffer bound at the time they were called. Selecting an item in the overview will highlight the corresponding item in the main trace.
You can open documentation for an API call (if available) in a browser by Menu-clicking on the call and selection Open Documentation.
It is possible to select two function calls from the trace using control+click on Windows / Linux hosts, or command+click on OS X hosts. Menu-clicking on one of the two selected functions will bring up
a popup menu showing various options including the ability to
generate a state difference report
.
Alternatively the user may select two draw calls from the outline view and use the popup menu to compare the two draw calls instead.
Timeline View
The Timeline View shows a graphical representation of the function calls in your application. There are three types of timeline view:
• When you first open a trace, the Process Timeline View is shown. This shows you a high level view of API Function Call activity for each process that was traced.
• Single clicking a process will select that process.
• Double clicking a process will select the very first frame in that process.
• When a frame or render pass has been selected, the Render Pass Timeline View is shown. This shows you each context in the selected process and each render pass in each context.
• Single clicking a render pass will select that render pass.
• Double clicking a render pass will select the very first draw call in that render pass.
• When a draw call has been selected, the Draw Call Timeline View is shown. This view is identical to the render pass view, except now individual draw calls are visible.
• Single clicking a render pass will select the very first draw call in that render pass.
• Single clicking a draw call will select that draw call.
All three types of timeline view can be navigated in the same way:
• The X-Axis can be scrolled by holding down the left mouse button and dragging left or right.
• The X-Axis can be zoomed in or out by scrolling up or down using the scroll wheel, or by holding down the right mouse button and dragging up or down.
• Hovering over any element in the chart, including the axes, will display a tooltip showing context sensitive information about that element.
| Exploring Your Application | 33
Statistics View
This window shows a selected summary of the trace as a whole. Use this to gain an overview of the state of your application as it ran.
Draw Call Information View
This view shows additional information about the currently selection 'draw' call. Therefore, this view is only active when a ‘draw’ call such as glDrawArrays or glDrawElements is selected in the trace.
Depending on the type of 'draw' call selected, different information may be shown. This view is particularly useful when using indirect 'draw' calls such as glDrawElementsIndirect. Since those calls use a command struct as a parameter it is impossible to see what parameters were passed to the call in the normal trace view (it will simply show the value of the struct pointer). However, the struct will be parsed and display in this view.
Trace Analysis View
This view shows problems or interesting information related to API calls as they were made. These problems can include improper use of the API (passing illegal arguments, for example) or issues known to adversely impact performance. Use this view to improve the quality and performance of your application.
Selecting an entry in this view will highlight the offending issue(s) within the trace view. Hover your cursor over the problem report to gain a more detailed view of the problem (if available).
Target State View
This view shows the state of the underlying system at a time following the function selected in the trace view, and is updated as the trace selection changes. Use this to explore how the system state changes over time and the causes of that change.
The initial state is shown as an entry in normal type. If the relevant API standard defines an initial state then this will be shown, otherwise <unknown> will appear instead.
If a state item has changed then its value will be shown in highlighted in green. The function call that made the change can be located by selecting Select Previous Change Location from the right click menu on the state item. The function call that next changes a given state item can be located in a similar way.
To filter the view to show only states that have been changed by the currently selected function call, enable the Show only states that changes this function call option in the view.
You can use the Filter box to filter the states and values in the view. For example, type texture into the box and the view will only show you states which have 'texture' in the name and/or those which have
'texture' in the value. Filtering is case insensitive.
Trace Notes
In the trace editor window there is a column in the table labelled notes. This is intentionally left blank and is for the user to write notes on a particular function call. This will then be saved and loaded with the trace. A good use case for this is if there is a function call that looks like it could be a future candidate for optimization. The user can write a note to remind them in the future.
Every marked function will then appear green in the trace and a new marker will be placed on the ruler on the right hand side of the trace. This allows quick navigation to areas with notes.
| Exploring Your Application | 34
This highlighting option can be disabled by right clicking anywhere in the trace editor window and unchecking the option that says "Highlight Notes".
Framebuffers View
Frame buffers can be captured using
on page 18. Once you have a frame with a successful frame capture, the results can be found in the Framebuffers view. In the view, frame buffers in use at the currently selected point in the trace. Use this to gain an insight into what the graphics system has produced as a result of your application calls.
Selecting a frame buffer in the left-hand list will bring up a list of the attachments used in that attachment in the lower list. Selecting an attachment will bring up a larger view of that attachment. You can then mouse over the attachment for additional information. Double clicking the main image will open up the attachment in an external editor.
In certain situations you might want to view the framebuffer with alpha blending disabled. The Ignore
Alpha checkbox allows you to do this.
For a captured frame it is possible to step through the sequence of draw calls for that frame one at a time and observe how the final scene is constructed.
| Exploring Your Application | 35
Assets View
This view shows those items currently reserved or allocated by calls to the graphics system, and includes textures, shaders, framebuffers and EGL context values. Use this to explore what your application has loaded and what is currently active.
The Assets tab shows a tree of asset items (if any) as loaded by API calls up to and including the currently selected function. Selecting any item within the tree will show a preview of the item if available.
General Operations on Assets
The following operations are available on an asset item wherever it appears in the GUI:
• Asset items shown in normal type are known to the system, but are not currently bound. Assets shown in bold type are those currently bound and in use.
• Double clicking an asset item will show a larger view of the item.
• The right click menu on an asset item allows you to locate where the asset was either created or modified.
• Asset items shown with a blue highlight have been modified by the currently selected function call.
Asset Exporting
Assets can be exported from your application trace to disk.
Framebuffers can be exported by:
• Selecting File # Export All Captured Framebuffers.
• Selecting the frames, render targets, or draw calls containing the captured framebuffers you want export from the Trace Outline View, right clicking, and selecting Export Selected Captured
Framebuffers. This option will be greyed out if your selection does not contain any captured framebuffers.
Textures can be exported by:
• Right clicking on a single function call and selecting Export Textures. This will export all textures that existed at the time of that function call.
• Selecting the textures you want to export from the texture view, right clicking, and selecting Export
Textures.
Shaders can be exported by:
• Right clicking on a single function call and selecting Export Shaders. This will export all shaders that existed at the time of that function call.
• Selecting the shaders you want to export from the shader view, right clicking, and selecting Export
Shaders.
Vertex/Fragment/Compute Shader Views
These are an alternative tabular view of all currently loaded shaders. For each shader various cycle counts are shown allowing you to identify which shaders are most costly.
For fragment shaders, the Fragments column (and other dependent columns) will be empty unless the
feature was active for the selected frame.
Active shaders are shown in bold type.
Textures View
This shows an alternative tabular view of all currently loaded textures and includes information on their size and format. Use this to visualize the images that you have loaded into the system.
| Exploring Your Application | 36
Loading textures is done using an external program: note that for larger traces the application can take a short time to convert and display all textures. The following texture formats are currently supported:
• GL_COMPRESSED_RGBA8_ETC2_EAC
• GL_COMPRESSED_RGB8_ETC2
• GL_ETC1_RGB8_OES
• GL_LUMINANCE
• GL_ALPHA
• GL_RGBA4
• GL_RGBA with type GL_UNSIGNED_BYTE or GL_UNSIGNED_SHORT_4_4_4_4
• GL_RGB with type GL_UNSIGNED_BYTE
• GL_COMPRESSED_RGBA_ASTC_*_KHR
• GL_COMPRESSED_SRGB8_ALPHA_ASTC_*_KHR
Vertex Attributes View
This view shows the values of the vertex attributes that are passed to the vertex shader when a ‘draw’ call happens. Therefore, vertex attributes are visible only when a ‘draw’ call such as glDrawArrays or glDrawElements is selected in the trace. If GL_ELEMENT_ARRAY_BUFFER_BINDING or
GL_ARRAY_BUFFER_BINDING is set, the corresponding buffer object will be used to provide the values.
Chapter
7
About the Implementation
Topics:
•
The Mali Graphics Debugger works by intercepting each OpenGL
ES or OpenCL call made by the application under test. Once intercepted, call arguments are logged before they are passed transparently to the existing EGL, OpenGL ES, or OpenCL library.
The logged data is collected and passed to the host via a daemon running on the system.
| About the Implementation | 38
OpenGL ES Conformance
This product is based on a published Khronos Specification. Under normal trace conditions no changes are made to the stream of calls made by the application on the existing OpenGL ES implementation and therefore should not affect the conformance status of that implementation.
Chapter
8
Known Issues
Topics:
•
•
•
•
•
•
•
•
•
•
•
Issues with texture and image output on 64-bit Linux host
•
Issues viewing Khronos man pages
•
| Known Issues | 40
OpenGL ES Extensions
Generally, known OpenGL ES extensions will appear in the trace, but will not have an effect on the trace or asset state.
Shading Language Version
The host application supports syntax-highlighting of shaders from OpenGL ES 3.1 and before. There is support for Open CL kernel source but this is currently limited to a plain text view.
Shader Compiler
The system uses a built-in version of the Mali Offline Shader Compiler to determine vertex, fragment, and compute shader cycle counts. These cycle counts will only be correct for Mali-T760 devices running r5p0 drivers, however, other Mali-T600 based devices are likely to offer similar counts.
Performance
The Mali Graphics Debugger aims to be as unobtrusive as possible. However, there is a performance impact imposed by the gathering and sending of trace data to the host. This is particularly pronounced when you request a snapshot of a frame as this causes pixel read-back calls to be inserted by the interceptor after each draw call.
The interceptor library has negligible impact on application performance when not tracing.
API Asset Coverage
• There is currently limited support for most API extension enumerations
• Not all asset types are covered at present
• Not all texture types/formats are currently supported
Tracing Multiple Processes
If multiple applications are traced simultaneously then the trace shown in the GUI will contain function calls from all applications together. The trace state will then be a combination of the state from all applications that is likely to be misleading.
To avoid this, on Linux targets, simply only start a single application at a time with the interceptor enabled. On Android, there are instructions in
Choosing which Applications/Processes to Trace
page 13 on how to trace a single application.
Memory
Capturing for long periods of time or attempting to capture many framebuffer and/or other images is very expensive on memory. If a memory shortage is detected an active trace may be terminated to
Partial Support for Earlier Trace Versions
As new features are being added to the Mali Graphics Debugger, the data format of the saved traces is updated. We aim to support opening and visualizing traces captured with an earlier version of the tool but we cannot guarantee full functionality with older traces. The best solution is to update the Mali
Graphics Debugger software on both target and host and re-trace the application.
| Known Issues | 41
Maximum Number of Displayed Vertex Attributes
The Vertex Attributes view is able to display up to 32 different vertex attributes. If an application is using more than 32 vertex attributes the remaining ones are captured and stored in the trace file but not displayed.
GTK Warnings when closing MGD (Ubuntu only)
Occasionally on closing the application the system will show errors from the GIMP Toolkit (GTK) similar to the following:
LIBDBUSMENU-GTK-CRITICAL **: watch_submenu: assertion
`GTK_IS_MENU_SHELL(menu)' failed
(Mali Graphics Debugger:3989): LIBDBUSMENU-GLIB-WARNING **: Trying to
remove a child that
doesn't believe we're it's parent.
These are believed to relate to issues within GTK itself: they are widely reported and are believed to be harmless.
Issues with texture and image output on 64-bit Linux host
Mali Graphics Debugger requires that the 32-bit version of libjpeg62 be available on your system. On certain distributions, this is not there by default. On Ubuntu, this can be installed using the following command: sudo apt-get install libjpeg62:i386
Issues viewing Khronos man pages
Depending on your particular platform, you may or may not be able to correctly view the Khronos man pages when double clicking functions. This is particularly an issue for Windows which uses Internet
Explorer. This unfortunately is outside of our control, as it is an incompatibility between the Khronos man page format, and the platform default browser.
Intercepting without using LD_PRELOAD
In some cases it may not be possible to use LD_PRELOAD (for example, LD_PRELOAD is already being used for another purpose). In this case you need to define both LD_LIBRARY_PATH and
MGD_LIBRARY_PATH, as follows:
LD_LIBRARY_PATH=/path/to/intercept/dir/:$LD_LIBRARY_PATH
MGD_LIBRARY_PATH=/path/to/original/drivers/dir/
In this case, the
/path/to/intercept/dir/
should be the directory on the target where the installation files were copied. This must contain libinterceptor.so, and should include symlinks to libinterceptor.so named libEGL.so
, libGLESv2.so
and libGLESv1_CM.so
It is possible to setup the required symlinks for libinterceptor.so as follows: ln -s /path/to/intercept/libinterceptor.so /path/to/intercept/libEGL.so
ln -s /path/to/intercept/libinterceptor.so /path/to/intercept/ libGLESv1_CM.so
ln -s /path/to/intercept/libinterceptor.so /path/to/intercept/libGLESv2.so
ln -s /path/to/intercept/libinterceptor.so /path/to/intercept/libOpenCL.so
| Known Issues | 42
The
/path/to/original/drivers/dir/
should contain the pre-existing libGLESv2.so, libEGL.so
files from the graphics driver installation.
LD_PRELOAD need not be defined when using this method.
When a graphics application runs, the MGD intercept libraries are loaded from the
LD_LIBRARY_PATH first. These intercept libraries dynamically load the original graphics libraries from the MGD_LIBRARY_PATH location as required.
Chapter
9
Changes from Previous Versions
Topics:
•
•
•
•
•
•
•
•
•
•
•
•
•
•
| Changes from Previous Versions | 44
Changes between version 2.1.0 and 3.0.0
The following summarizes the changes made in this issue.
Issue
[MGD-714]
[MGD-1225]/[MGD-1788]
[MGD-1697]
[MGD-1699]
[MGD-1729]
[MGD-1798]
[MGD-181]
[MGD-150]
[MGD-1657]
[MGD-1847]
[MGD-167]
[MGD-1074]
[MGD-1156]
[MGD-1268]
[MGD-1562]
[MGD-1571]
[MGD-1572]
[MGD-1582]
[MGD-1655]
[MGD-1656]
[MGD-1666]
[MGD-1677]
[MGD-1680]
[MGD-1682]
[MGD-1687]
Summary
Show API calls for a single process from a system running multiple graphics processes
Improved tracking of Shader assets when they are attached and linked to multiple programs
Processes started after the pause command is sent should start in a paused state
Replay commands should only be sent to the process from which they originated
GUI now has the concept of multiple processes
Fragment Count doesn't work on anything other than FrameBuffer 0
User would like to see uniform data for GLES3 entrypoints and types
Support multiple color attachments in the framebuffer view (MRT)
Improve handling of low disk/memory
X86 Android support in Interceptor
Display a context-aware trace
Add ability in Assets view to see what is bound to each framebuffer
Windows installer could offer an option to launch
MGD after successful installation
MGD assets view needs an export option
Release User Guide as PDF
Support Uniform Storage Blocks
Support Vertex Array Objects
Frame Capture doesn't work on frame buffers that are not RGBA
MGD reports ASTC as unrecognized texture format
MGD reports KHR_DEBUG as an unrecognized state
MGD interceptor prints too many message if unsupported extensions are used
Bring back the framebuffer view glFramebufferRenderbuffer doesn't understand attachment code 0x821a
Give user the option to not send buffers during glDispatchCompute
MGD assets view should provide an export shaders option
| Changes from Previous Versions | 45
[MGD-1714]
[MGD-1725]
[MGD-1733]
[MGD-1734]
[MGD-1741]
[MGD-1742]
[MGD-1749]
[MGD-1804]
[MGD-1805]
[MGD-1356]
[MGD-1362]
[MGD-1712]
[MGD-1786]
Problem with texture files when using custom temporary storage directory
Wrong kernel given to GPUVerify
Create breadcrumb bar
Separate pids into different models
GPUVerify - String index out of range: -1
PATH corrupted during installation
Create process timeline view
Create render pass timeline view
Create draw call timeline view
ESC key could close Find API search
No tooltip for Binary Format in shader views
MGD should check if it can write to the temporary directory
Add tooltip to explain deleted shaders
Changes between version 2.0.2 and 2.1.0
The following summarizes the changes made in this issue.
Issue
[MGD-1436]
[MGD-1448]
[MGD-1546]
[MGD-1559]
[MGD-1558]
[MGD-1561]
[MGD-1554]
[MGD-1553]
[MGD-1551]
[MGD-1419]
[MGD-1155]
[MGD-1518]
[MGD-1629]
[MGD-1570]
Summary
Added state comparison support
Upgraded base Eclipse version to Eclipse 4.4
Remove fabricated shaders and textures from selection in Frame overrides view
Double clicking on item in Frame overrides view should take you to that item
User should be able to delete a Frame override from the Frame overrides view by pressing the delete key
"Dirty" shader files are marked with a '*' in the frame overrides view
Remove the compile button in Shader Override
Editor (shaders are now compiled on save)
You can now create frame overrides by right clicking on the relevant asset
Convert interceptor to C++
EGL parameters are now shown in the assets view
Support for 64-bit Android
Fix a crash on Ubuntu when the user tries to open the Help
Fix an issue where MGD could not uncompress
ATSC images
| Changes from Previous Versions | 46
[MGD-1451] Add support for glBlitFramebuffer
Changes between version 2.0.1 and 2.0.2
The following summarizes the changes made in this issue.
Issue
[MGD-1580]
[MGD-1581]
Summary
MGD works correctly when it's not called libGLES_mgd.so
MGD only looks for libEGL.so in /vendor/lib/egl/
Changes between version 2.0.0 and 2.0.1
The following summarizes the changes made in this issue.
Issue
[MGD-1565]
[MGD-1539]
Summary
MGD works correctly on Windows systems with non-English languages.
Minor issues with images in the documentation.
Changes between version 1.3.2 and 2.0.0
The following summarizes the changes made in this issue.
Issue
[MGD-1146]
[MGD-1053]
[MGD-1284]
[MGD-1210]
[MGD-1299]
[MGD-1222]
[MGD-1131]
[MGD-1137]
[MGD-71]
[MGD-240]
[MGD-1011]
[MGD-835]
[MGD-1352]
Summary
Filmstrip feature has been re-enabled
Help is now provided as an Eclipse plugin
Added "Framebuffer" as a mid-level hierarchy in the outline view
Mgddaemon now provided as an Android application for rooted devices
Hard float version of interceptor is now built without neon for greater compatibility
Search highlighting improved
Context menus in MGD now contain default actions
Show and hide menus added for column context menus
Improved error message regarding the libjpeg62 dependency
Added more default items to the context menus
Added alpha channel support when opening images opened from the Framebuffersview
User can now copy function calls from the trace view to the clipboard
Made improvements to previous/next change location in Target State view
[MGD-245]
[MGD-290]
[MGD-1460]
[MGD-1466]
[MGD-1433]
[MGD-974]
[MGD-1297]
[MGD-1457]
[MGD-1088]
[MGD-1142]
[MGD-879]
[MGD-1234]
[MGD-1341]
[MGD-1246]
[MGD-1432]
[MGD-1086]
[MGD-1322]
[MGD-1333]
[MGD-1429]
[MGD-1296]
[MGD-1317]
[MGD-219]
[MGD-1319]
[MGD-1253]
| Changes from Previous Versions | 47
New samples have been added to show features such as overdraw map, fragment count statistics, shader map and frame capture
Debug menu now contains all of options from the toolbar and in the same order
Columns in the Statistic View are now resizeable
User can now filter frames by MGD features such as overdraw
MGD updated to use Java 7 and JRE is bundled with package
Improved handling of large trace files
Framebuffer view now correctly reports pixel coordinates no matter what the view size
Progress bar now shown when doing a capture from paused
MGD no longer hangs when replaying a frame that had previously been captured
OpenGL ES 3.1 basic support has been added.
All calls are now intercepted and displayed in the
Trace View
Failed calls to glTexImage* no longer update texture assets
Vertex attribute support added for OpenGL ES
3.0 entrypoints
Increased the number of texture formats that
MGD supports
Attachment data is now captured for glDiscardFramebufferEXT and glInvalidateFramebuffer
Added the ability to create notes in the TraceView to highlight specific lines in a trace
Filmstrip feature can be toggled on or off during tracing
User can now override a texture with a predefined checker board texture whilst replaying a frame
User can now override the precision mode for all types in a shader whilst replaying a frame
Added documentation for using the interceptor inside a apk
Icons added to help distinguish between regular frames, replayed frames and frames with different features
Added new Compute Shaders view
Added app selection screen to the new MGD daemon app
Improved speed whilst calculating unique indices
Ability to copy text strings in MGD added
| Changes from Previous Versions | 48
[MGD-1338]
[MGD-1170]
[MGD-1339]
[MGD-1230]
[MGD-1202]
[MGD-1287]
[MGD-260]
[MGD-1395]
[MGD-1282]
[MGD-1458]
[MGD-1505]
[MGD-1383]
[MGD-1470]
[MGD-1179]
[MGD-1134]
[MGD-1445]
Total cycles number is now uses decimal notation instead of E notation
Fixed tooltip for the index number of an API call
Vertex and Fragment shaders view counters are now aligned to the right
Preferences menu has been re-enabled for all platforms
Inconsistent use of N/A in the UI has been resolved
Trace search now updates as the application is running
Context menu items are greyed out if unavailable
Can now do a frame capture on a replayed frame
Framebuffers now open in an image editor the same orientation as MGD displays
MGD daemon application can now detect whether it is on a rooted device or not
Version 4.5.0 of the Mali offline compiler integrated. This allows the compilation of compute shaders
Items in the GUI are now correctly sorted
User can now edit shaders in an application and then replay a frame using their edited shaders instead of the original ones
EGL attribute names are now shown rather than numerical values
Improved OpenGL ES 1.1 support
Compiler manager no longer causes MGD to crash when opening certain traces
Changes between version 1.3.0 and 1.3.2
The following summarizes the changes made in this issue.
Issue
[MGD-1475]
Summary
Support for Android 5.0
Changes between version 1.2.2 and 1.3.0
The following summarizes the changes made in this issue.
Issue
[MGD-504]
[MGD-246]
[MGD-896]
Summary
The results of glGetError are now show for every call
Added “Step” feature to allow stepping through frames on the target
Traces are now in a binary format to increase performance
[MGD-282]
[MGD-1138]
[MGD-1155]
[MGD-146]
[MGD-1104]
[MGD-1096]
[MGD-1094]
[MGD-65]
[MGD-1066]
[MGD-831]
[MGD-1091]
[MGD-1079]
[MGD-1065]
[MGD-1015]
[MGD-997]
[MGD-1071]
[MGD-1068]
[MGD-1024]
[MGD-297]
[MGD-263]
[MGD-900]
[MGD-1000]
[MGD-1001]
[MGD-1092]
[MGD-241]
[MGD-1121]
| Changes from Previous Versions | 49
Added a feature in the Vertex Attribute View to visualise sparse vertex indices. Also added a warning if the vertex indices are too sparse.
Added support for replaying frames which don’t create or destroy state
Shader cycles statistics are now calculated for
‘Midgard’ based devices
Double-clicking an MGD trace file now opens
MGD (Windows only)
Search function is faster
MGD is more responsive when selecting the last frame in a big trace
MGD no longer runs out of memory after opening and closing several trace files
Fixed Shader View sorting when using “Show create location”
String arguments are now shown instead of the pointer value in the Trace View
The Vertex Attribute View is now correct when the minimum vertex index is >0
Fixed Shaders View so it shows shaders correctly before they’ve been linked
Added EGL parameters are in the Assets View
Stopped context being lost in the Outline View when selecting a call other than glDrawElements
Fixed shadermaps so they use the same shader number as API calls
In a multi-context trace, the trace problems are now correct
Constants are now correctly displayed for glClear
Texture formats for T-Rex HD are now correct
Stopped UI locking up while saving traces
Attaching a texture to a channel of an FBO now detaches whatever is currently bound
Added support for BGRA textures
Framebuffer view is now cleared when trace file gets closed
Stopped UI locking up when connecting to a nonexisting IP address
“Show create location” / Show last modification now works for Shader Views
It is no longer possible to close main application window when Open File dialog is open
Asset view selection is no longer cleared when stepping backwards through the trace
Stepping through draw calls no longer resets the asset table
| Changes from Previous Versions | 50
[MGD-1036]
[MGD-903]
[MGD-2]
[MGD-888]
[MGD-210]
[MGD-947]
[MGD-935]
Fixed a NullPointerException which was thrown after reopening the Assets View
Stopped the framebuffer view of other open traces being cleared when you close a trace
Cancelling file read no longer results in Stream
Closed error
Traces can be exported to a text file
Trace file highlights can now be removed once set
Function arguments now display correct enumeration values
Fixed java.util.ConcurrentModificationException
thrown while tracing GFXBench
Changes between version 1.2.1 and 1.2.2
The following summarizes the changes made in this issue.
Issue
[MGD-1012]
[MGD-231]
Summary
Fixed unique indices count.
Support for Android KitKat 4.4.
Changes between version 1.2.0 and 1.2.1
The following summarizes the changes made in this issue.
Issue
[MGD-935]
[MGD-197]
[MGD-922]
[MGD-921]
[MGD-907]
Summary
Fixed java.util.ConcurrentModificationException.
Show framebuffer pixel information.
Eliminate memory-free error on interceptor closedown.
Fix for interceptor segfault on GFXBench3 (PBO).
Handle Unicode characters in shader sources.
Changes between version 1.1.0 and 1.2.0
The following summarizes the changes made in this issue.
Issue
[D905]
[D852]
[D837]
[D887]
Summary
Allow binary shaders to be debugged. All apps will fall back to compiled shaders.
Added end to end tests for fragment count
Handle click on empty framebuffer image.
Previously the app would throw a generic warning if an empty framebuffer was double-clicked.
Suppress multiple error dialogs. These were produced when trying to read a texture without
[D854]
[D160]
[D836]
[D838]
[A753]
[D335]
[D844]
[D852]
[D859]
[D463]
[A860]
[A876]
[A873]
[D3]
| Changes from Previous Versions | 51 the appropriate decoder. Only one report is now produced for each failing decoder.
Shaders view shows a fragment count for each shader
All frames now start with eglSwapBuffers.
Previously this call was included at the end of a frame. This change improves application consistency.
Add an 'empty message' to the framebuffers view.
Fixed exception thrown when calculating shader statistics.
Add armhf_fbdev in the installer
Fix workbench save/restore with new versions.
Fixed vertex and fragment views being empty after shader deletion Shaders are shown next to their bound program in the shader views There may be duplicate shaders, as a shader can be bound to multiple programs After a shader is deleted, the shader is shown greyed out if still attached Vertex shaders in the vertex shader view also now have a colour
Add framebuffer size in the tooltip
README_linux and README_android merged into user guide Added target installation content to the userguide Deleted README_android and
README_linux
Daemon now reports version during start up
Updated user documentation. Also improved the messages that a daemon produces when it starts up. Includes updates to user guide and code to better document the use of port 5002.
Adding Android ASTC support
All mga references become mgd
Changed test trace file extension to mgd.
Fix frame and draw call index numbers in stats view. These were one-out.
Adding ASTC decoding to GUI.
Changed Linux installer extension to tgz. This simplifies publishing.
Renaming State view 'State' column to 'State
Item'
Renaming samples to have a .mgd extension
Show colors in the shaders view.
Close process streams after use. These were no being closed, and so were accumulating until the system ran out of descriptors.
Rename Trace Problems view
Clear frame image when model unloads.
[D12]
[D34]
[D63]
[A595]
[A801]
[A788]
[A793]
[A722]
[A815]
[A760]
[A794]
[A834]
[A779]
[A834]
[A284]
| Changes from Previous Versions | 52
Show multiple texture formats/types only if they are different.
Overdraw map now supports GLES3 shaders
(Timbuktu works)
Add status line with progress report for background jobs.
Fix 'task already scheduled or canceled' when closing and re-opening stats view.
Fix exception when cancelling a file open action.
Inform the user when the connection to the target is broken change extension to .mgd
Better message for broken URLs in help lookup.
Fix opening a file shows up as dirty.
Add title to vertex attribute index column.
Hide the filmstrip panel if no screenshots are available.
Display screenshots in the left pane in the GUI.
Saving now updates tab. And you can differentiate between save and save as.
Adding single-step function.
Fixing interaction between pause and framebuffer requests.
Improve image drawing, remove unnecessary images.
Add support for RGB and RGB565 formats for framebuffers.
Enable O3 optimization in the Android build.
Message when texture cannot be displayed externally.
Implemented overdraw map
Fix bug calculating shader cycle average.
Vertices per draw call and frame now show
Unique vertices as well
Add vertices count to shader stats.
Selecting frame selects last call in frame.
Previously the first call would be selected.
Will allow us to more easily present per-frame information.
Enable all the basic texture formats.
Add GL_ALPHA texture format as grayscale image.
Revised error handling. All LOGE or LOGI statements now terminate with \n (previously there was a mix). All exit() calls are now made with a non-zero value if indicating failure.
[A762]
[A758]
[A724]
[A720]
[A717]
[A691]
[A727]
| Changes from Previous Versions | 53
Implemented core GLES3 vertex attrib types
Updated User Guide. Updated known-issues section to contain information on the Khronos manual page issues.
Added mgd.ini option to substitute vendor
Renaming start/stop to connect/disconnect. This better reflects what these commands actually do, and helps towards separating the start/stop controls.
Added LD_LIBRARY_PATH/
MGD_LIBRARY_PATH interception method By naming/symlinking MGD appropriately, MGD can be placed in the LD_LIBRARY_PATH variable, and the library path to forward calls to can then be specified by passing the environment variable
MGD_LIBRARY_PATH. This method is safer than LD_PRELOAD, and can be used with other tracers.
Improved interceptor to support more drivers
Included updated GLES/glext.h
Updated size of bitfields in CL definition.
Add to the trace a timestamp showing the time before/after each function call.
Stop up-scaling the FB images if they are already smaller than the canvas.
Fixed find on a live trace
Added armhf build to bundle
Updated emulator to load libGLES from same dir Now loads libGLES* from same directory as libEGL, rather than using LD_LIBRARY_PATH, which was causing some trouble previously.
Fix null pointer exception when saving. This occurs when a constant value is unrecognised.
These are now replaced with 'unrecognised' but this can only be temporary until unknown constants are properly supported.
Add User Guide note on GTK warnings.
Improving the progress bar on multiple file load.
The previous bar was not correctly showing the total progress when opening multiple files, this has been fixed. There remains an issue with the blocking of the UI thread by the openEditor call, but this is unavoidable at the moment.
Only permit existing file to be opened. Previously the File # Open dialog would allow the user to type a filename that didn't exist, causing problems later in the flow.
Search substrings (they don't need to fully match).
Fix Y coordinate of CUBEMAP.
| Changes from Previous Versions | 54
[A684]
[D686]
[A697]
[D698]
Fix bug. MGD did not show up on Mac with Java
1.6
Fixing standard Mac menu items. The 'About
MGD' and 'Preferences' options were missing from the Mac implementation.
Revising socket close mechanism to eliminate errors. The socket closedown code reported lots of warnings even in the correct case. Code has now been refactored to improve the messaging and to try and eliminate spurious warnings.
Added EGL plugin to send context on eglMakeCurrent
GLES3 working on Android, and Nexus10 4.3
booting. Only needed chmodding to work on
Android 4.3, so have changed the README to reflect this requirement. Have also removed the
GLES2 version of the android interceptor, and will now ship GLES3 as it is public.
Fix sequencing on save. Save operation no longer closes an active trace if the user cancels the file selection dialog.
Changes between version 1.0.2 and 1.1.0
The following summarizes the changes made in this issue.
Issue
[353]
[353]
[653]
[349]
[591]
[620]
Summary
Added Vertex Attributes view, which shows all the vertices used in a ‘draw’ call
Indices buffers are captured in the trace
Added warning for swapping between buffer targets
Adding statistic for vertices per frame and show vertices count in the Outline View
Shader statistics are now updated individually
Added ability to find function calls with text pattern search (CTRL-F)
Shaders are now sorted numerically
Improved the vertical bar with markers to point to the correct items when it is clicked
“Save” now asks before overwriting
Add reference to the buffers table in
GL_ELEMENT_ARRAY_BUFFER_BINDING
Numbers start from 1 in views.
Changes between version 1.0.1 and 1.0.2
The following summarizes the changes made in this issue.
Issue Summary
[550]
[543]
[539]
[353]
[353]
[514]
[485]
[518]
[517]
[515]
[489]
[483]
[508]
[498]
[482]
| Changes from Previous Versions | 55
Add uniforms support.
Fix concurrent modification exception.
Fix bug in Windows installer.
Moving views; adding right click menu.
Dimension sorts by width following area.
Adding shader attributes to program view.
Update EULA with Apache Commons library.
Fixing trace load progress counter.
Texture names now sort on ID
Added glVertexAttrib*fv family of entry points
Added glVertexAttrib*f commands to
AssetProcessor
Upgrade everything to Java 1.7
Small improvements to the UI of the Outline view
Fix for interceptor vertex array buffer sending
Adding index to draw call in frame.
Fix warning 'timer already canceled'.
Add detection of eglGetError errors.
Display frames with alternate colors in the trace view.
Adding table header tool tips.
Added index column to trace view.
Attachment temporary files now deleted on exit.
Small UI improvements
Fix NullPointerException with buffers.
Fix trace editor switching.
Add statistics entry to show the number of API calls per frame.
Make open file trace faster.
Improved performance when highlighting the locations of a problem in the trace.
Fix double-click global action issue.
Add buffers view.
Changed Asset view to sort GLES objects alphabetically
Added preview text and icons for Buffer assets.
Add a simple binary viewer for buffers.
Fix precision errors in the progress bar.
Show MB read in the progress bar to show activity for enormous files.
Set the size of a texture even if no data is available.
| Changes from Previous Versions | 56
[341]
[341]
[498]
[498]
[498]
[498]
Display information for textures bound to framebuffers.
Show number of vertices and draw calls in the
Outline view.
Add per frame and per draw call statistics in the view.
Added AssetProcessor support for all GLES3 target buffers.
Updated AssetProcessor to handle glBufferSubData
Added tracking of buffer creation/deletion/ modification to model.
Added glBufferData test app
Improve file moving to work cross device
Changes between version 1.0.0 and 1.0.1
The following table details the changes made in this issue.
Issue
[429]
[473]
[427]
[472]
[453]
[451]
[474]
Summary
Removed multi-selection on trace problems view.
Fixed issue when textures with type 565 were sent.
Personalised icons on shader editor.
Added eglGetProcAddress path for function pointer lookup in interceptor functions.
Notes
Since only the first selection is used. Also selection now done on a single-click rather than a double-click.
Caused traces with RGB565 images to fail to load.
Shader editor pane now shows the icon appropriate to the content.
Previously, the only path available used dlsym, which will not work with extension functions which must look up the function in the underlying driver with eglGetProcAddress. The interceptor originally returned addresses to core API functions, which is counter to the wording of the EGL spec.
Fixing trace load cancel button.
MGD now stops cleanly when the cancel button is pressed on a large trace load.
Reducing argument memory usage.
Provide support for saving attachments and framebuffers to disk when the system is short of memory.
Fix Save dialog (before it was actually a open dialog).
Add type to the image buffers and textures, and display it.
Also add a filter for txt extension on trace files.
| Changes from Previous Versions | 57
[418]
[447]
[469]
[398]
[435]
[436]
[448]
[431]
Added documentation for all special case functions.
Modified Trace Editor code to handle bitfields.
All trace functions can be double-clicked to reveal help page.
Functions such as glClear which take a bit mask now show the bit mask value expanded into each of the mask values if possible.
Fix exception thrown when no markers are selected.
Added process filter to Android target.
Now requires a /system/lib/egl/ processList.cfg to exist, and have the running process name equal one of the lines of that file, in order for a single process trace to occur. The interceptor will trace all processes by default if processList.cfg is not present.
Removed shader editor right click menu
Retain connection IP address and port information
The menu items had no effect, and so have been removed.
Save and restore window layout The application will now remember where windows were placed in the workbench, and will restore these at the start of the next session.
If the user enters information in the connection dialog then this is now saved across sessions.
Removing unused popup menu on stats view.
Removed unnecessary popup menu.
Changes in version 1.0.0
This version is the first release of the Mali Graphics Debugger.
| Changes from Previous Versions | 58
Chapter
10
Support
For further support on this product, please visit the
Mali Developer
Center
.
It should be noted that continuing support of the product is at ARM’s discretion unless explicitly included in a current contract between
ARM and you.
| Support | 60
Chapter
11
Legal
Topics:
•
•
Proprietary Notice
Words and logos marked with
®
or TM are registered trademarks or trademarks of ARM Limited in the
EU and other countries, except as otherwise stated below in this proprietary notice. Other brands and names mentioned herein may be the trademarks of their respective owners.
OpenCL and the OpenCL logo are trademarks of Apple Inc. used by permission by Khronos.
OpenGL is a registered trademark and the OpenGL ES logo is a trademark of Silicon Graphics Inc.
used by permission by Khronos.
Oracle and Java are registered trademarks of Oracle and/or its affiliates. Other names may be trademarks of their respective owners.
Windows is a registered trademark of Microsoft Corporation in the United States and other countries.
Android is a trademark of Google Inc.
Mac and OS X are trademarks of Apple Inc., registered in the U.S. and other countries.
Neither the whole nor any part of the information contained in, or the product described in, this document may be adapted or reproduced in any material form except with the prior written permission of the copyright holder.
The product described in this document is subject to continuous developments and improvements. All particulars of the product and its use contained in this document are given by ARM Limited in good faith. However, all warranties implied or expressed, including but not limited to implied warranties of merchantability, or fitness for purpose, are excluded.
This document is intended only to assist the reader in the use of the product. ARM Limited shall not be liable for any loss for damage arising from the use of any information in this document, or any error or omission in such information, or any incorrect use of the product.
Analytics Information We Track
The following summarizes the analytics information we track.
When Tracked
Per product version
Per product version
Per session
Per session
Per session
Per session
Per session
Per session
Per session
Name
product/build product/version product/user_preference system_property/os_arch system_property/ os_distribution_description system_property/ os_distribution_name system_property/ os_distribution_version system_property/os_name system_property/os_version
Summary
Tracks the current product build
ID
Tracks the current product version
Tracks which MGD user preferences are enabled and disabled
Tracks the operating system bitness
(Linux only) Tracks the Linux distribution version descriptive name
(Linux only) Tracks the Linux distribution name
(Linux only) Tracks the Linux distribution version number
Tracks the operating system name
Tracks the operating system version
| Legal | 62
Per session
Per session
Per session
Per session
Per session
Per session
Per session
Per session
Per trace
Per trace
Per trace
Per trace
Per trace
Per trace
Per trace
Per trace
Per trace
Per trace
Per trace
Per trace
Per trace system_property/user_country Tracks the users locale country system_property/user_language Tracks the users locale language action/set_target_ip Tracks the number of times set target IP feature is used memory/amount_available memory/critical_event
Tracks the amount of memory available to Java when the program is first run
Tracks the number of times a critical memory level is detected memory/warning_event product/user_preference view/tab_activated action/add_override_count
Tracks the number of times a warning memory level is detected
Tracks which MGD user preferences are enabled and disabled
Tracks the number of times an individual view is used
Tracks the number of times each kind of frame override is used action/ disable_send_output_buffers action/
Tracks the number of times output buffers sending was disabled
Tracks the number of times action/enable_filmstrip_count action/enable_fragment_count Tracks the number of times the fragment count feature was used action/enable_frame_capture Tracks the number of times the frame capture feature was used action/enable_overdraw attachment capturing was enabled
Tracks the number of times the filmstrip mode feature was used action/enable_shadermap
Tracks the number of times the overdraw feature was used
Tracks the number of times the shadermap feature was used action/open_documentation action/replay_frame
Tracks number of times user uses 'Open Documentation' feature
Tracks the number of times the frame replay feature was used action/ replay_frame_with_capture action/use_gpu_verify action/use_state_diff_feature
Tracks the number of times the frame replay with capture feature was used
Tracks when GPUVerify feature is used
Tracks the number of times the state diff is used
| Legal | 63
Per trace
Per trace
Per trace
Per trace
Per trace
Per trace
Per trace
Per trace
Per trace
Per trace
Per trace
Per trace
Per trace
Per trace
Per trace
Per trace
Per trace
Per trace
Per trace trace/gles_api_version trace/ gles_buffer_target_use_count trace/
Tracks the numbers of each
EGL context created, grouped by GLES version
Tracks the numbers of uses of each GLES buffer target
(GL_ARRAY_BUFFER, etc.)
Tracks the numbers
FBO attachment point
(GL_COLOR_ATTACHMENT0, etc.)
Tracks the numbers of uses of trace/ target (GL_RENDERBUFFER,
GL_TEXTURE2D, etc.) trace/ Tracks the largest overall area of gles_fbo_dimensions_largest_area an FBO encountered trace/ Tracks the largest height of an trace/ Tracks the largest width of an trace/ gles_texture_dimension_largest trace/ gles_texture_format_use_count trace/ gles_texture_target_use_count trace/largest_call_count trace/ largest_drawcallperframe_count trace/largest_frame_count trace/
Tracks the largest overall area of any texture encountered
Tracks the numbers of uses of each GLES texture format used
(GL_RGBA8, etc.)
Tracks the numbers of uses of each GLES texture target used
(GL_TEXTURE2D, etc.)
Tracks the total number of all function calls
Tracks the largest number of draw function calls in a single frame
Tracks the total number of frames
Tracks the largest number of trace/largest_shader_cycles trace/ largest_verticesperframe_count trace/live_target_type trace/live_version trace/number_of_generated
Tracks the largest total shader cycles for any shader
Tracks the largest number of vertices per frame
Tracks the type of live target connected to (Android, Linux)
Tracks the version number of a trace
Tracks the numbers of each type of GLES resource created
(Textures, Shaders, Sync
Objects, etc.)
| Legal | 64
Per trace
Per trace trace/opencl_context_counter trace/read_version
Tracks the number of OpenCL contexts created
Tracks the version of the trace file loaded from a saved trace
| Legal | 65
| Legal | 66
advertisement
* Your assessment is very important for improving the workof artificial intelligence, which forms the content of this project
Related manuals
advertisement