User Guide - Mali Developer Center

User Guide - Mali Developer Center
Mali Graphics Debugger v3.4.0
User Guide
© ARM Limited 2016
| Introduction | 2
Chapter
1
Introduction
Topics:
•
•
•
•
Overview
Installation Package
Components
This release
| Introduction | 4
Overview
The Mali Graphics Debugger is a tool to help OpenGL® ES, EGL™, OpenCL™, and Vulkan™
developers get the best out of their applications through analysis at the API level. The tool allows the
user to observe OpenGL ES, EGL, OpenCL, and Vulkan 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 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 GPU applications on a desktop computer. Full support is available for:
•
•
OpenGL ES 2.0, 3.0, 3.1, and 3.2
EGL 1.4
Limited support is available for:
•
•
OpenCL 1.0, 1.1, and 1.2
Vulkan 1.0 (Android only)
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 minor release following the 3.3.0 release of the tool, it adds the features and fixes the issues
listed below:
•
•
Support for tracing Vulkan (the new Khronos graphics and compute API). See the Vulkan Overview
on page 18 for more information.
Support for tracing and capturing VR applications:
•
•
•
MGD now correctly detects the end of a frame in VR applications when they don't use
eglSwapBuffers.
• Frame capture (with all the supported modes), works correctly for VR applications. Capturing will
now continue until all render passes started during a frame have completed.
• VR applications typically use more than one thread and EGL context to do their rendering.
Different EGL contexts are now color coded in the Trace, Trace Outline, and Timeline views to
make it more obvious when this is happening.
The Render Pass Dependencies View on page 46 could previously only show dependencies
between render passes which used the same textures as read and write as draw call targets. It can
now do the same for renderbuffer targets as well as supporting glBlitFramebuffer, glClear
(to break dependencies), multiple render targets, and depth/stencil targets.
The filtering of states in the Target State View on page 39 has been improved to allow you to
show only:
•
States that have been changed at any point in the trace
| Introduction | 5
•
•
•
•
States that have not been changed at all in the trace
States which are not currently their default value
States that have been changed by the current function
States which are read-only (e.g. GL_MAX_TEXTURES)
The full change log for this release is here.
| Introduction | 6
Chapter
2
Minimum Requirements
Topics:
•
•
•
•
Host System Requirements
Increasing Available Memory
Temporary Storage
Target System Requirements
| Minimum Requirements | 8
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 one or more of
the following:
•
•
OpenGL ES 2.0, 3.0, 3.1, or 3.2 and EGL 1.4
OpenCL 1.0, 1.1, and 1.2
The system should be able to substitute the existing OpenGL ES, EGL, and OpenCL system libraries
with the supplied intercept libraries. The specific method for doing this is platform-specific.
In addition, this version of MGD has been tested with:
•
•
Android™ 4.4, 5.0, and 5.1 on the Google Nexus 10 platform
Android 6.0 on an internal development board
Previous versions of MGD have been tested with:
•
Android 4.2 and 4.3 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:
•
•
•
•
Linux
Windows
Mac OS X
Target Deliverables
| Host Installation | 10
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 file system 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
Target Installation Overview on page 12 for details.
Chapter
4
Target Installation
Topics:
•
•
•
•
•
•
Target Installation Overview
Linux
Android
Unrooted Android
Vulkan
Troubleshooting
| Target Installation | 12
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, EGL, 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 | 13
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 57 for more information.
If you have more than one version of your graphics driver on your system and are having issues; see
Multiple drivers installed on the system on page 58 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 the host machine.
PATH should include the path to the adb binary.
A valid ADB connection to the target device (i.e. adb devices returns the ID of you device
with no permission errors and you can run adb shell without issues). See the Android device
documentation for more help and information.
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 Unrooted Android.
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.
Important: Users of x86 based Mali Android devices should use the interceptor library
target/android/intel/x86/libGLES_mgd.so, and the mgddaemon executable
target/android/intel/mgddaemon instead.
| Target Installation | 14
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/
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 partition. See the Prerequisites section
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.
| Target Installation | 15
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
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
Important: Users of 64-bit x86 based Mali Android devices should use the interceptor library
target/android/intel/x86-64/libGLES_mgd.so instead.
Choosing which Applications/Processes to Trace
By default MGD will trace all running OpenGL ES, EGL, OpenCL, and Vulkan 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,
EGL, OpenCL or Vulkan 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
| Target Installation | 16
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.
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 the host machine.
PATH should include the path to the adb binary.
A valid ADB connection to the target device (i.e. adb devices returns the ID of you device
with no permission errors and you can run adb shell without issues). See the Android device
documentation for more help and information.
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.
| Target Installation | 17
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:
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.
Important:
Please note that the non-root interceptor is only available for the armeabi-v7a and arm64v8a ABIs.
To ensure your build works as expected you must make sure you specify a appropriate value
for APP_ABI in your Application.mk.
To target both ARMv7 and ARMv8 targets your Application.mk should contain:
APP_ABI := armeabi-v7a arm64-v8a
See https://developer.android.com/ndk/guides/abis.html for more information about Android
ABIs
| Target Installation | 18
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
Uninstalling 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 (Installation on page 17).
Vulkan
Vulkan Overview
If you have access to a Mali device with Vulkan and would like to use MGD, please contact us using
the ARM Mali Graphics Community.
The MGD interceptor for Vulkan is implemented using the Vulkan layers system. Different layers can
be present on your target system or within you application itself. Layers must be enabled as part of the
system or as part of your application at runtime. To choose which layers are enabled you must specify
the layer names, for MGD the layer name is "VK_LAYER_ARM_MGD". The MGD daemon application
must be started on your target platform before the application you want to trace.
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
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, EGL, OpenCL, or Vulkan calls.
| Target Installation | 19
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.
| Target Installation | 20
Chapter
5
Getting Started with MGD
Topics:
•
•
Running the Host GUI
Using the Mali Graphics
Debugger on Your Application
| Getting Started with MGD | 22
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 Target Installation Overview on page 12 for more
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.
Dealing With Multiple Processes
It is possible to trace multiple processes concurrently with MGD. Any intercepted application launched
after the host has connected to the daemon will be received into the trace file on the host. Individual
processes will be displayed in the Trace Outline View.
Note: Most commands that are available for interacting with a live target will affect
the currently selected process only. This includes all capture commands, the resume and
step commands, all replay commands including the frame overrides, and all automated trace
commands (except the command to disconnect).
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.
| Getting Started with MGD | 23
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
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
paused, proceed by pressing the
button. Once
button for each frame that needs capturing.
In the Trace Outline View any regular frame will now have a
frame.
icon to show that it is a captured
Capturing All Framebuffer Attachments
It is possible to capture most framebuffer attachments including all color 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 available attachments 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
colored 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.
Color Attachment
Depth Attachment
| Getting Started with MGD | 24
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 OpenGL ES 2.0 only
configuration
| Getting Started with MGD | 25
•
For any configuration where depth texture sampling is not supported, or where the device only has
OpenGL ES 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 gray.
Any frame with overdraw mode turned on will have this
icon in the Trace 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 Shaders View, 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 | 26
Any frame with shadermap mode turned on will have this
icon in the Trace 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 | 27
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 Trace 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
enabled.
(frame replay) and
(frame replay with capture) buttons will be
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
the same time.
button operates in the same way except it will also enable frame capture at
This feature can be combined with the Capture All Attachments, Overdraw, Shadermap, and Fragment
Count 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 | 28
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 Texture
•
Replace a selected texture with a 256 x 256 pixel texture of different colors in a grid like pattern.
Force Precision
•
Replace the shaders of a program with a version that forces a specific precision for all types.
Modify Shaders
Replace both the fragment and vertex shaders of a program with custom versions.
Replace Texture
| Getting Started with MGD | 29
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
Types
#version 300 es
float, int, sampler2D, samplerCube,
sampler3D, samplerCubeShadow,
sampler2DShadow, sampler2DArray,
sampler2DArrayShadow, isampler2D,
isampler3D, isamplerCube,
isampler2DArray, usampler2D,
usampler3D, usamplerCube,
usampler2DArray
#version 310 es
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
Everything else
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 | 30
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 | 31
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 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 | 32
The Apply and OK fields will be grayed out if you enter an invalid path in this location.
When tracing a OpenCL application, MGD will capture calls to all OpenCL 1.2 functions,
including 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 through GPUVerify you need to select a function
call in the trace with live kernel objects, then click on Debug # Launch GPUVerify. You will be
presented with a dialog that looks like the one below.
| Getting Started with MGD | 33
The Kernel drop-down list shows all the kernel objects that are live and have available source code
at the currently selected function call. Source code is only available to MGD for kernels that have
been created from a program that was created using clCreateProgramWithSource followed by
clBuildProgram. If the kernel you expect to see isn't in the list, ensure that you have selected a function
call where that kernel object is live and that the kernel was created using the described method.
Once you have selected a kernel from the drop-down list, the Local Work Size, Global Work Size,
and Kernel Build Options fields will be populated with all the information MGD has available. The
local and global work sizes can be either be picked from the drop-down lists, which have been
populated with the local and global sizes from the kernel's enqueue history, or the sizes can be
manually entered with a comma separated list of numbers. The number of dimensions of the local and
global sizes must match. If invalid options are entered, an error box will be displayed giving you more
information. There are no restrictions to the Kernel Build Options field, though GPUVerify may output
an error if the options are unsupported.
The output for GPUVerify is shown in 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 Trace Outline View, then select Generate Diff from the popup menu.
Difference Report View
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
| Getting Started with MGD | 34
components (for example GL_VIEWPORT), the subcomponents are highlighted individually. In this
case, subcomponents that have not changed are shown with gray text.
The final column in the output table is labeled 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.
Bookmarks
MGD contains a Bookmarks feature to allow the user to bookmark particular function calls and
optionally add notes to the bookmark. These bookmarks can be saved and loaded with the trace. This
can be used, for example, to make notes on a function call that looks like it could be a candidate for
optimization. The user can add a bookmark with a note to remind them in the future.
Bookmarks can be viewed and manipulated in the Bookmarks View and the Trace View.
Dealing With VR Applications
Virtual Reality (VR) applications have a peculiar pattern in term of OpenGL ES calls. They usually have
multiple threads and/or contexts to handle different steps: scene rendering, barrel distortion, chromatic
aberration, etc. MGD shows every context using a different color to make it clear what is part of which
context. This applies to the Trace View, the Trace Outline View and the Timeline View.
When you pause a VR application or a generic multi-threaded application, pausing will be delayed over
the frame end until all render passes (including those from other threads) have finished. The function
calls and render passes traced after the frame end will be shown as part of the next frame in the Trace
Outline View. That frame is considered incomplete and is marked with the
is resumed and the end of the frame is reached.
icon until the application
Chapter
6
Exploring Your Application
Topics:
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
Trace View
Trace Outline View
Timeline View
Statistics View
Function Call Information View
Trace Analysis View
Target State View
Buffers View
Bookmarks in the Trace View
Framebuffers View
Assets View
Shaders View
Textures View
Vertices View
Uniforms View
Automated Trace View
Render Pass Dependencies
View
Bookmarks View
Console View
| Exploring Your Application | 36
Trace View
The main window in MGD 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 bookmark notes the user has added to the function call (see Bookmarks in the Trace View on
page 40).
Note that some columns in this table may be initially hidden – click the
columns.
button to enable or disable
Each call executed in a different EGL context is highlighted using a different color.
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.
Searching
To find a particular function call (or set of calls), MGD includes a search feature. You can open the
search dialog by pressing Ctrl + F with the Trace View selected, or by selecting Edit # Find API call...
from the main menu. Simply type your search string in the search box, press Return and MGD will
highlight matching calls in the trace. You can use the
results.
Pressing the
and
buttons to jump between the search
button or pressing the Esc key will close the search and hide the results.
By default the search only looks at the function call name. If you want to search the function call
parameters as well you can select the Include parameters option. With this selected, MGD will search
the functions exactly as they appear in the Function Call column of this view.
The search field supports the following advanced search operators: * (wildcard), | (or), and & (and).
Trace Outline View
The Trace Outline View shows a summary tree view of the function calls made by your application as it
is running. Use this to easily navigate through the trace.
The top level items in the tree are processes. If you've traced more than one process on the target
system you can switch between them by selecting them in the this view. This will cause the Trace View
to display only calls for that process.
| Exploring Your Application | 37
Function calls are further grouped depending on the API in use For example, OpenGL ES calls are
grouped into frames and render passes. For each item (including the groupings) in the tree we shown
the name, index, and additional interesting information for that item. For certain items, even more
information can be found in the item's tooltip.
Selecting an item in the tree will cause other views to be updated to provide information about that
item. Selections made in other navigation views (the Trace View, Breadcrumb Bar, or the Statistics
View Charts Tab) will cause the selection in the Trace Outline View to update. If the item selected in
another view is not an item in the Trace Outline view, a selection line will be shown to indicate where
the item would be in relation to other items.
When you have a trace with many frames, you can use the Show Only Frames With Features
Enabled option to quickly find interesting frames. With this mode turned on, only frames that meet one
of the following criteria will be shown:
•
•
•
•
•
Frame Capture
Frame Replay
Fragment Count
Overdraw Mode
Shader Map Mode
The
(Collapse All) button can be used to collapse all of the items in the tree.
Right clicking on items in the tree allows you to generate a diff report between two items and export
framebuffers. See Comparing State between function calls on page 33 and Asset Exporting on page
42 for more information.
Each call executed in a different EGL context is highlighted using a different color.
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.
Statistics View
Three tabs are available in this window; General, Charts and Memory.
| Exploring Your Application | 38
General
This tab gives statistics and averages for the currently selected process. Use this to gain an overview
of the state of your application as it ran.
Charts
This tab shows charts for various statistics for the currently selected item type. For example, selecting
a process will show you statistics about all the processes in the current trace. The currently selected
item will be highlighted in the chart and the item's parent is shown as the chart's title. The following
actions are available for the charts:
•
•
•
Hovering over a slice of the pie chart allows you to see more information about the slice (including
its value).
Clicking on a slice will select that item in the trace.
Double-clicking on a slice will select that item's first child in the trace.
Note: Some items do not support all the available statistics. For example, Render Passes do
not support the Number of render passes statistic.
Memory
This tab shows information on memory usage for each frame. This data can be produced on Mali T600
or later based devices, but the vendor may choose not to enable this feature. To check if this feature
is supported, please check if your device contains one of the following files: /sys/kernel/debug/
mali0/ctx/*/mem_profile or /sys/kernel/debug/mali/mem/*. If the files are present and
non-empty then your device is supported.
Attention: To allow this data to be processed by MGD, please turn off the SELinux
permissions by running 'setenforce 0' on your device.
Attention: You may need to mount the Linux "debugfs" mount point for this feature to work:
mount -t debugfs /sys/kernel/debug /sys/kernel/debug
When selecting a frame a pie chart showing the memory allocated by each channel is shown, each
channel is a driver defined heap for a different type of object.
•
•
•
Hovering over a slice of the pie chart shows you the memory contained in that channel.
Clicking on a slice will display information on the memory contained in that trace and the
percentage of total memory used in that frame.
Double-clicking on a slice will display a histogram showing more details of the memory allocations.
The histogram shows the number of memory allocations made for each range of memory. Hovering
over each bar shows the total amount of memory this range contains.
Function Call Information View
This view shows any additional information that is available about the currently selected function call.
Only functions that are shown in the outline view will have additional information.
Depending on the type of function 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 displayed in this view.
| Exploring Your Application | 39
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 been changed anywhere in the trace then it will be highlighted in light-green. A state
item that is not currently it's default value is highlighted in dark-green. Any read-only constant states
such as GL_MAX_DRAW_BUFFERS are highlighted in yellow. States that are never been changed in
the trace are shown in white.
If a state has been changed, you can find the function call that changed it 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.
Filtering
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.
In addition to the Filter box, there are six filtering modes available:
•
•
•
•
•
•
All states - No additional filtering is applied.
States that have been modified - Only show the states that have been changed in this trace.
States that have not been modified - Only states that never change value in the trace will be
shown.
States that are not currently their defaults - Only states which, at the currently selected function
call, are not at their default values will be shown.
States changed by this function - Only states changed by the currently selected function call will
be shown.
Read-only states - Only read-only constant states such as GL_MAX_DRAW_BUFFERS will be
shown.
Regular Expression Filtering
The Filter box also supports regular expressions. For example, type gl_program|gl_texture into the
box to see all those states (or state values) that contain the 'gl_texture' or 'gl_program'. Filtering using
regular expressions is still case insensitive.
By default the matches are preformed on substrings, e.g. program will match GL_PROGRAM. If you
wish to anchor your expressions you can use the standard regular expression boundary matchers
such and ^ (the beginning of a line) and $ (the end of a line). For example, typing program$ matches
GL_CURRENT_PROGRAM but not GL_PROGRAM_PIPELINE_BINDING.
If the filter you type is not a valid regular expression, the Filter box will go red and the specific error will
be shown as a tooltip. MGD uses Java regular expressions, for more information see:
| Exploring Your Application | 40
•
•
The documentation for the Pattern class
The Oracle® regular expression tutorial
Buffers View
The view shows information about the currently allocated buffer objects. The list of buffer objects can
be filtered by usage. The bottom part of the view shows the size of the currently selected buffer objects.
If no buffer object is selected, the size of all the displayed buffers objects is shown.
Filtering
To filter the view to show only the buffer objects with a given usage, use the Filter box. For example,
type transform into the box and the view will only show you the buffer objects which have 'transform' in
the usage field. Filtering is case insensitive.
Regular Expression Filtering
The Filter box also supports regular expressions. For example, type gl_transform|gl_array into the
box to see all those buffer objects with usage that contains 'gl_transform' or 'gl_array'. Filtering using
regular expressions is still case insensitive.
By default the matches are preformed on substrings, e.g. transform will match GL_TRANSFORM.
If you wish to anchor your expressions you can use the standard regular expression boundary
matchers such and ^ (the beginning of a line) and $ (the end of a line). For example,
typing FEEDBACK_BUFFER$ matches GL_TRANSFORM_FEEDBACK_BUFFER but not
GL_ARRAY_BUFFER.
If the filter you type is not a valid regular expression, the Filter box will go red and the specific error will
be shown as a tooltip. MGD uses Java regular expressions, for more information see:
•
•
The documentation for the Pattern class
The Oracle® regular expression tutorial
Bookmarks in the Trace View
This topic describes how to view and manipulate Bookmarks in the Trace View, for more general
information on bookmarks please see Bookmarks.
In the Trace View window there is a column labeled Bookmark Notes which lets you view and edit
Bookmarks for each function call.
To add a bookmark with a note Double Click on the notes area for that function call and enter you
note. To add an empty bookmark Right Click on the function call and select Add Bookmark. To add
remove a bookmark Right Click on the function call and select Remove Bookmark.
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.
This highlighting option can be disabled by right clicking anywhere in the Trace View window and
unchecking the option that says Toggle Bookmark Highlighting.
| Exploring Your Application | 41
Bookmarks can also be viewed and manipulated in the Bookmarks View
Framebuffers View
Frame buffers can be captured using Capturing Framebuffer Content on page 23. 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 as well as histograms displaying the overdraw or shader map data, if
relevant. 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.
| Exploring Your Application | 42
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.
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 grayed 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 Textures 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 Shaders View, right clicking, and selecting
Export Shaders.
Shaders View
This view is 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. These cycle counts are
calculated using the Mali Offline Shader Compiler for the Mali T760 GPU.
The "Cycles” field in the table shows the estimate of the number of cycles each shader will take for a
single invocation. This estimate may be inaccurate for any shaders that have any kind of non-linear
control flow, such as a loop where the number of iterations cannot be statically determined, or if the
shader contains any "if" statements.
| Exploring Your Application | 43
For fragment shaders, the Fragments column (and other dependent columns) will be empty unless the
Fragment Count 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.
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
Vertices View
The view has three sub tabs: Attributes, Indices, and Geometry. All the tabs show data for the
selected ‘draw’ call. Therefore, the data is visible only when a ‘draw’ call such as glDrawArrays or
glDrawElements is selected in the trace.
Attributes
This tab shows the values of the vertex attributes that are passed to the vertex shader. If
GL_ELEMENT_ARRAY_BUFFER_BINDING or GL_ARRAY_BUFFER_BINDING is set, the
corresponding buffer object will be used to provide the values. The vertex indices used in this view
have been sorted and duplicates removed.
Indices
This view shows the original list of vertex indices that were passed to the draw call.
Geometry
This view shows, as a wireframe, the geometry drawn by the draw call. This allows you to get a quick
idea of what the draw call was drawing and also to inspect the geometry for defects. You can see if the
geometry is incorrect (missing or additional unexpected vertices), or if the geometry is too dense which
may lead to performance problems.
| Exploring Your Application | 44
If you use the geometry view in combination with the Framebuffers View, you can see where in the
scene the geometry was drawn. This allows you to detect if the geometry is appropriate for it's position
in the scene. For example, if the geometry is always far away from the camera, the geometry detail can
probably be lower. Or, if the complex internal geometry of an object always occluded, it's probably not
worth drawing.
In order to render the correct geometry, MGD must know which one of the shader attributes
corresponds to the geometry position data. You can select this from the Position Attribute choice
box. MGD will use the names of the attributes and their types to initially auto-select it's best guess at a
matching attribute.
The axes in the corner of the view show the orientation of the geometry relative to the three axes, X
(red), Y (green), and Z (blue).
You can rotate the camera around the center of the geometry by clicking and dragging the primary
mouse button in the view. For more precise rotation, the numeric keypad direction buttons (2, 4, 6,
and 8) can also be used to rotate the camera. To zoom the camera in and out, you can use the mouse
scroll wheel or the the W and S keys. To reset the position and orientation of the camera at any point,
press the Reset Camera button.
To do more in depth analysis of the geometry, you can export it to a Wavefront .obj file. These files can
be loaded by most 3D model editors and viewers. To export the geometry, right click on the geometry
viewer and select Export to .obj.
Note: Currently the Geometry viewer (and export function) only works with the
GL_TRIANGLES and GL_TRIANGLE_STRIP draw modes. Primitive restart is also not
supported, if you are using this feature then you may see unexpected results.
Note: Wavefront .obj files do not support triangle strips so MGD will convert any triangle strip
data to a series of individual triangles when exporting.
Uniforms View
This view shows uniform data for the active OpenGL ES shader program at the time of the selected
function call.
For each active uniform, we shown its index, location, type, and value. If the uniform is a block, the
block name and the block buffer binding will be shown.
Automated Trace View
The Automated Trace View allows you to run a range of standard MGD commands automatically when
a certain frame is encountered. For example, you could run your application and automatically take a
frame capture on frame 10, do a frame capture with overdraw mode switched on at frame 20 and do a
frame capture with fragment count mode enabled at frame 30.
Note: Currently you can only add automated trace commands after an application has started.
To add an automated trace command, first select and pause the process you want to add commands
to and then open up the Automated Trace View.
| Exploring Your Application | 45
Select Add Command and the Add Automated Trace Command dialog will be opened.
Here you can select the type of command you want and which frames it should apply to. You must
specify at least one frame number to add a command. For a frame number to be considered valid, it
must:
•
•
be greater than the current frame plus one
not already have an automated command associated with it
If the list of frames is invalid the Frame number(s) text box will be highlighted in red. A tooltip on text
box will give you the reason why.
Note: 'Empty' frame numbers (a series of commas with no number between them) and
duplicate frame numbers are ignored.
When you have a valid list of frames, select the Ok button.
| Exploring Your Application | 46
You can then add more commands (and remove existing ones).
When you are happy with the list, press the
button. When the trace reaches frames which you
have added commands to, those commands will be executed.
Note: Automated trace commands for a frame will be ignored if:
•
•
you send a play, step, or capture command in that frame
you send a play, step, or capture command in the frame before that frame
Render Pass Dependencies View
MGD can work out what dependencies there are between different render passes in a selected frame.
The different types of dependencies it can detect are as follows:
1. If a render pass reads from a texture that is wrote to in a different render pass without being
cleared. E.g. render pass 0 draws to texture 1 and render pass 1 then reads from texture 1.
| Exploring Your Application | 47
2. If a render pass has the same depth or stencil buffer bound as another render pass without being
cleared. Assuming that depth or stencil testing is enabled. E.g. render pass 0 has render buffer 1
attached to its depth target and render pass 1 also has render buffer 1 attached to its depth target.
3. If a render pass does a glBlitFramebuffer call on a different framebuffer. E.g. render pass 0 draws to
framebuffer 1 and render pass 1 blits framebuffer 1 into framebuffer 2.
The Render Pass Dependencies View shows render pass dependencies for the selected frame. To
generate a list of dependencies, select a frame in the Trace Outline View and press the Generate
button in the Render Pass Dependencies View. Any any render pass in the selected frame that is
dependent on another render pass will be shown in the tree. Expanding the render pass will tell you:
•
•
Which render pass it's dependent on
Which frame that render pass is in
| Exploring Your Application | 48
•
Why MGD considers it a dependency
The dependency analysis stops at the first dependency for each render pass, to find out the next
dependency in the chain (if there is one), select the frame with the earlier render pass in it and run the
analysis again.
As a example, in the following screen shot, we can see that two of the render passes in Frame 1,
Render Pass 1 and Render Pass 4, have dependencies on previous render passes. Render Pass 1
is dependent on Render Pass 26 in the previous frame (Frame 0). Render Pass 4 is dependent on
Render Pass 3 in the current frame (Frame 1). In both cases there are dependencies because Texture
18 is attached to the active frame buffer for the render passes.
Bookmarks View
This topic describes how to view and manipulate Bookmarks in the Bookmarks View, for more general
information on bookmarks please see Bookmarks.
This view shows any bookmarks that have been added to the trace and allows you to add, remove, and
edit bookmarks.
You can jump to the function call associated with a specific function call by clicking the Go to Function
button next to the bookmark.
Bookmarks are links to specific function calls in the trace and can contain notes for you to add
interesting information. Pressing the
Add Bookmark button will add an empty bookmark to the
currently selected function call in the Trace View. Pressing the
Remove Bookmark button will
remove the selected bookmark in the Bookmarks View. You can edit a bookmark by Double Clicking
on the notes area next to the bookmark.
Bookmarks can also be viewed and manipulated in the Trace View
Console View
This view contains a read-only console that MGD uses to present its internal log. You can attach the
output of this view to bug reports and it might be helpful when making a support request.
Chapter
7
Integration with DS-5 Streamline
Topics:
•
•
•
Introduction
Installation
Using Streamline Annotations
| Integration with DS-5 Streamline | 50
Introduction
The Mali Graphics Debugger interceptor library generates ARM® DS-5 Development Studio Streamline
version 5.22 or later annotations and chart information.
When profiling an application with Streamline and provided the interceptor is installed and being used
the following additional information is now available:
•
•
•
Active EGL context for each intercepted processes' thread is shown in the Heat Map and Core Map
views.
Per process activity view is now available which shows active contexts, frames within each context,
render passes within each frame and important calls per render pass including draw calls, frame
end calls and flushing calls.
Charts showing:
•
•
•
•
Frames per second
Direct and indirect draw calls per frame
Vertices and instanced vertices passed to a draw call
Vertices per frame
Installation
The user should install and have working DS-5 Streamline version 5.22 or later. Instructions for how to
do this are included with DS-5 Streamline.
Mali Graphics Debugger integration only requires the interceptor library from Mali Graphics Debugger
to be installed on the target. Neither the host application nor mgddaemon are required if the user is only
interested in DS-5 Streamline annotations.
The user should follow the instructions laid out in Target Installation Overview to install the interceptor
on their target device.
Once all the various setup instructions have been followed you should end up with:
•
•
•
•
•
A working installation of DS-5 Streamline.
gatord installed and working on the target device.
The MGD interceptor installed and working on the target device.
Mali Graphics Debugger installed on host. (Optional if only interested in Streamline annotations)
mgddaemon installed and working on the target device. (Optional if only interested in Streamline
annotations)
Using Streamline Annotations
The user should launch the DS-5 Streamline application and launch gatord on the target device, then
should start a new profiling capture within DS-5 Streamline as per the Streamline documentation.
Once the trace has started to be received, the user should start the OpenGL ES application they are
interested in profiling. The MGD interceptor must be loaded by the application.
Important:
For Android targets it should be sufficient to just to launch the appropriate application from the
launcher.
For Linux targets, the user may need to use the LD_PRELOAD or LD_LIBRARY_PATH methods.
Warning:
The mgddaemon daemon application should not be running when using the Streamline tracing
functionality.
Once the user has finished tracing the application they are interested in, they should terminate the
application and then disconnect the trace in DS-5 Streamline.
| Integration with DS-5 Streamline | 51
Heat Map / Core Map Annotations
The Heat Map and Core Map views now show active EGL contexts for each rendering thread. The
length of each bar indicates the duration that that context was active (between eglMakeCurrent
calls)
Mali Graphics Debugger Activity View
A new view is available from the same menu as the Heat Map / Core Map / Processes menu for each
process that was traced using the MGD interceptor. This view shows the active contexts on each
thread, each frame within a context, each render pass within a frame, and interesting API calls within a
render pass.
It is possible to select a frame, render pass or call item and see its relationship with other items.
Selecting a frame will highlight all render passes within that frame and all calls associated with each
render pass. Selecting a render pass will highlight the chain of render passes and calls for a given
frame so far. Selecting a call will highlight all previous calls within a render pass.
Information such as the time spent in the driver for an item is available by hovering over the
item. Additionally render passes will give an indication of the reason for the render pass, such as
eglSwapBuffers for the end of frame, or glBindFramebuffer(fboID) indicating that the user
changed the bound draw FBO.
For more detailed information the user may zoom in to a level where it is possible to see individual API
calls. Calls are color coded to indicate the type of call they are.
API Call Marker Colors
Red
Flushing calls such as glFlush
Green
End of frame calls such as eglSwapBuffers
Blue
Direct draw commands such as glDrawArrays
Yellow
Indirect draw commands such as glDrawArraysIndirect
Charts
Five chart are provided by the interceptor tracking draw calls, frame rate and vertices.
| Integration with DS-5 Streamline | 52
Draw Calls / Frame
This chart shows, for each EGL context, the number of draw calls per frame. Selecting a range with the
caliper tool will give you the average for that period. This chart is stacked so the total height indicates
the total number of draw calls at any given time.
Frame Rate
This chart shows, for each EGL context, the average frame in frames-per-second. The frame rate, r,
is calculated as shown below using a simple rolling average over the last 6 frames. Selecting a range
using the caliper tool will show an average value for that period.
Calculation of frame rate r measured in frames per second. d is the average duration between
frames (in seconds), ti is the time of the i'th last frame end (in seconds), and n is the size of the rolling
average; which is 6.
Indirect Draw Calls
This chart shows, for each EGL context, the number of indirect draw calls. This information is provided
as an indication of how much additional work may be being done by the GPU as it is not possible to
determine the number of vertices or instanced vertices for these draw calls. Selecting a range using the
caliper tool will show the total value for that period. This chart is stacked so the total height indicates
the total number of indirect draw calls at any given time.
Vertices
This chart shows, as a global total for the application, the number of vertices and instanced vertices
sent with all direct draw calls. The two series are overlaid such that the height of the instanced vertices
series shows the total number of vertices processed by the vertex shader. It is possible to select a
range using the caliper tool and see the total number of vertices and instanced vertices for that period.
For programs not using instanced rendering, the two series will be the same.
Vertices / Frame
This chart shows, for each EGL context, the number of vertices per frame. Selecting a range using the
caliper tool will show an average value for that period. This chart is stacked so the total height indicates
the total number of vertices at any given time.
Chapter
8
About the Implementation
Topics:
•
Khronos Conformance
The Mali Graphics Debugger works by intercepting each OpenGL
ES, EGL, OpenCL, and Vulkan calls made by the application under
test. Once intercepted, call arguments are logged before they are
passed transparently to the existing OpenGL ES, EGL, OpenCL, or
Vulkan library. The logged data is collected and passed to the host
via a daemon running on the system.
| About the Implementation | 54
Khronos 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 to the existing OpenGL ES, OpenCL, EGL, or
Vulkan implementation and therefore should not affect the conformance status of that implementation.
Chapter
9
Known Issues
Topics:
•
•
•
•
•
•
•
•
•
•
•
•
OpenGL ES Extensions
Shading Language Version
Shader Compiler
Performance
API Asset Coverage
Memory
Partial Support for Earlier
Trace Versions
GTK Warnings when closing
MGD (Ubuntu only)
Issues with texture and image
output on 64-bit Linux host
Issues viewing Khronos man
pages
Intercepting without using
LD_PRELOAD
Multiple drivers installed on the
system
| Known Issues | 56
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 OpenGL ES
shader cycle counts. These cycle counts will only be correct for Mali-T760 devices running r7p0
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
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
protect the system. See Increasing Available Memory on page 8 for advice.
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.
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
| Known Issues | 57
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
ln -s /path/to/intercept/libinterceptor.so
libGLESv1_CM.so
ln -s /path/to/intercept/libinterceptor.so
ln -s /path/to/intercept/libinterceptor.so
/path/to/intercept/libEGL.so
/path/to/intercept/
/path/to/intercept/libGLESv2.so
/path/to/intercept/libOpenCL.so
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.
Note: Sometimes you will find that the original Mali drivers pointed to by
MGD_LIBRARY_PATH are tiny shim libraries that do not export any entry points, but instead
depend on libmali.so; in this situation the interceptor will fail to correctly load the driver libraries
unless MGD_LIBRARY_PATH also contains libmali.so. When this is not the case you may
either point MGD_LIBRARY_PATH to the location of libmali.so, regardless of whether that
location also contains libEGL/libGLES libraries, or you may point MGD_LIBRARY_PATH to a
location that contains symlinks to libmali.so instead.
| Known Issues | 58
Multiple drivers installed on the system
In some cases you may have more than one version of Mali driver installed on your device. An
example would be if you aim to use both X11 and FBDEV on the same Linux platform. In these
circumstances it may not be possible to use the standard LD_PRELOAD approach on its own.
You must instead use that approach as normal whilst defining the MGD_LIBRARY_PATH environment
variable as follows:
MGD_LIBRARY_PATH=/path/to/original/drivers/dir/
The /path/to/original/drivers/dir/ should contain the pre-existing libGLESv2.so, libEGL.so
files from the graphics driver installation.
When a graphics application runs, the MGD intercept libraries are preloaded as normal. The intercept
libraries then dynamically load the original graphics libraries from the MGD_LIBRARY_PATH location
as required.
See Intercepting without using LD_PRELOAD for more information.
Chapter
10
Changes from Previous Versions
Topics:
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
Changes between version
3.3.0 and 3.4.0
Changes between version
3.2.0 and 3.3.0
Changes between version
3.1.0 and 3.2.0
Changes between version
3.0.0 and 3.1.0
Changes between version
2.1.0 and 3.0.0
Changes between version
2.0.2 and 2.1.0
Changes between version
2.0.1 and 2.0.2
Changes between version
2.0.0 and 2.0.1
Changes between version
1.3.2 and 2.0.0
Changes between version
1.3.0 and 1.3.2
Changes between version
1.2.2 and 1.3.0
Changes between version
1.2.1 and 1.2.2
Changes between version
1.2.0 and 1.2.1
Changes between version
1.1.0 and 1.2.0
Changes between version
1.0.2 and 1.1.0
Changes between version
1.0.1 and 1.0.2
Changes between version
1.0.0 and 1.0.1
Changes in version 1.0.0
| Changes from Previous Versions | 60
Changes between version 3.3.0 and 3.4.0
The following summarizes the changes made in this issue.
Issue
Summary
[MGD-2075]
Multisampled framebuffer attachments can now
be captured
[MGD-1937]
The "Add Command" dialog in Automated Trace
Control can no longer be hidden behind the main
MGD window
[MGD-2070]
The Trace View and Trace Outline View
selections are no longer reset when switching
between traces
[MGD-1932]
The Render Pass Dependency View can now
track renderbuffer dependencies
[MGD-2062]
MGD now color codes EGL contexts in GUI
where appropriate.
[MGD-1007]
MGD now has more state filtering modes,
see Target State View on page 39 for more
information.
[MGD-1923]
MGD can now trace Vulkan api calls
[MGD-2051]
For VR applications, MGD now shows proper
frame delimitation in the Trace Outline View
[MGD-2133]
Fixed MGD_LIBRARY_PATH sometimes not
working correctly on a Firefly board with fbdev
[MGD-2117]
Fixed filmstrip images being 2-3 frames behind
the actual frame
[MGD-1809]
The Console View has been simplified
Changes between version 3.2.0 and 3.3.0
The following summarizes the changes made in this issue.
Issue
Summary
[MGD-2084]
Add full cl_kernel and cl_program support
[MGD-2072]
Add support for OpenCL errors
[MGD-2025]
Add support for tracing OpenCL 1.2 functions
[MGD-1859]
Detect blocking calls in OpenCL
[MGD-480]
Add wireframe view on host to assess the
complexity of a draw call
[MGD-729]
Add exporting geometry from draw calls into
external graphics applications
[MGD-1926]
Show render pass dependencies (for textures
only)
[MGD-1877]
Clicking on a framebuffer in framebuffers view
should show color attachment 0
[MGD-2067]
Fix missing Streamline integration documentation
| Changes from Previous Versions | 61
Changes between version 3.1.0 and 3.2.0
The following summarizes the changes made in this issue.
Issue
Summary
[MGD-1862]
An internal error occurred during: "Closing 1>
Capturing Target@/127.0.0.1:5002"
[MGD-1885]
Send streamline annotations from MGD
interceptor
[MGD-1801]
Convert shaders view into one view
[MGD-1867]
Frame replayed with capture enabled is marked
with an incorrect icon
[MGD-1906]
MGD overdraw map layer count tooltip is wrong
[MGD-2002]
Fragment count is incorrect
[MGD-1757]
Improved performance of Textures View
[MGD-1917]
Current note could be saved when user changes
focus to a different API call
[MGD-1483]
User would like to end the search by pressing
Escape
[MGD-1452]
MGD API trace search could allow an option to do
a full text search
[MGD-2007]
Cannot use MGD 3.0 interceptor on arm-linux-sf
target
[MGD-226]
Display indices for a selected glDrawElements
call
[MGD-1945]
Add support for driver supplied memory reports
[MGD-1726]
Improve installation instructions for MGD Android
App
[MGD-1959]
Can't trace app on unrooted Android device
[MGD-2018]
Overdraw histogram doesn't show 0x overdraw
[MGD-1759]
Improved performance of Vertex Attributes View
[MGD-1758]
Improved performance of Buffers View
[MGD-1949]
Track current binding for each buffer to allow to
group buffers by binding type
[MGD-1951]
Allow user to select items in the Buffers View;
show total memory consumption for selected
items
[MGD-1960]
Update MGD.mk file to reflect current directory
structure
[MGD-2031]
Histogram in Framebuffers View should refresh
when switching between the trace files
[MGD-2001]
10x overdraw is reported for two different shades
of gray
[MGD-1950]
Allow user to filter / sort Buffers View by binding
type
| Changes from Previous Versions | 62
[MGD-2034]
Using the "Ignore Alpha" option in the
Framebuffers View sometimes sets the color data
to black
Changes between version 3.0.0 and 3.1.0
The following summarizes the changes made in this issue.
Issue
Summary
[MGD-1901]
Added Automated trace control
[MGD-1742]
Target state filtering now accepts regular
expressions
[MGD-1889]
An update popup has been added
[MGD-1887]
There are now graphs of existing statistics
[MGD-1871]
Support for Android 6.0 (Marshmallow)
[MGD-1770]
Histograms for overdraw and shader map
[MGD-1231]
Currently bound EGL objects in Assets View are
now shown in bold.
[MGD-1800]
Support for Tessellation and Geometry shaders
[MGD-1900]
Splash screen now shown on Windows
Changes between version 2.1.0 and 3.0.0
The following summarizes the changes made in this issue.
Issue
Summary
[MGD-714]
Show API calls for a single process from a system
running multiple graphics processes
[MGD-1225]/[MGD-1788]
Improved tracking of Shader assets when they
are attached and linked to multiple programs
[MGD-1697]
Processes started after the pause command is
sent should start in a paused state
[MGD-1699]
Replay commands should only be sent to the
process from which they originated
[MGD-1729]
GUI now has the concept of multiple processes
[MGD-1798]
Fragment Count doesn't work on anything other
than Framebuffer 0
[MGD-181]
User would like to see uniform data for OpenGL
ES 3.0 entry points and types
[MGD-150]
Support multiple color attachments in the
Framebuffers View (MRT)
[MGD-1657]
Improve handling of low disk/memory
[MGD-1847]
X86 Android support in Interceptor
[MGD-167]
Display a context-aware trace
[MGD-1074]
Add ability in Assets View to see what is bound to
each framebuffer
| Changes from Previous Versions | 63
[MGD-1156]
Windows installer could offer an option to launch
MGD after successful installation
[MGD-1268]
MGD Assets View needs an export option
[MGD-1562]
Release User Guide as PDF
[MGD-1571]
Support Uniform Storage Blocks
[MGD-1572]
Support Vertex Array Objects
[MGD-1582]
Frame Capture doesn't work on frame buffers that
are not RGBA
[MGD-1655]
MGD reports ASTC as unrecognized texture
format
[MGD-1656]
MGD reports KHR_DEBUG as an unrecognized
state
[MGD-1666]
MGD interceptor prints too many message if
unsupported extensions are used
[MGD-1677]
Bring back the Framebuffers View
[MGD-1680]
glFramebufferRenderbuffer doesn't understand
attachment code 0x821a
[MGD-1682]
Give user the option to not send buffers during
glDispatchCompute
[MGD-1687]
MGD Assets View should provide an export
shaders option
[MGD-1714]
Problem with texture files when using custom
temporary storage directory
[MGD-1725]
Wrong kernel given to GPUVerify
[MGD-1733]
Create breadcrumb bar
[MGD-1734]
Separate different target processes into different
models
[MGD-1741]
GPUVerify - String index out of range: -1
[MGD-1742]
PATH corrupted during installation
[MGD-1749]/[MGD-1804]/[MGD-1805]
Create a Timeline View
[MGD-1356]
Esc key could close Find API search
[MGD-1362]
No tooltip for Binary Format in shader views
[MGD-1712]
MGD should check if it can write to the temporary
directory
[MGD-1786]
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
Summary
[MGD-1436]
Added state comparison support
[MGD-1448]
Added GPUVerify support
[MGD-1546]
Upgraded base Eclipse version to Eclipse 4.4
| Changes from Previous Versions | 64
[MGD-1559]
Remove fabricated shaders and textures from
selection in Frame Overrides View
[MGD-1558]
Double clicking on item in Frame Overrides View
should take you to that item
[MGD-1561]
User should be able to delete a frame override
from the Frame Overrides View by pressing the
delete key
[MGD-1554]
"Dirty" shader files are marked with a '*' in the
Frame Overrides View
[MGD-1553]
Remove the compile button in Shader Override
Editor (shaders are now compiled on save)
[MGD-1551]
You can now create frame overrides by right
clicking on the relevant asset
[MGD-1419]
Convert interceptor to C++
[MGD-1155]
EGL parameters are now shown in the Assets
View
[MGD-1518]
Support for 64-bit Android
[MGD-1629]
Fix a crash on Ubuntu when the user tries to open
the Help
[MGD-1570]
Fix an issue where MGD could not uncompress
ASTC images
[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
Summary
[MGD-1580]
MGD works correctly when it's not called
libGLES_mgd.so
[MGD-1581]
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
Summary
[MGD-1565]
MGD works correctly on Windows systems with
non-English languages.
[MGD-1539]
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
Summary
[MGD-1146]
Filmstrip feature has been re-enabled
[MGD-1053]
Help is now provided as an Eclipse plugin
| Changes from Previous Versions | 65
[MGD-1284]
Added "Framebuffer" as a mid-level hierarchy in
the Outline View
[MGD-1210]
Mgddaemon now provided as an Android
application for rooted devices
[MGD-1299]
Hard float version of interceptor is now built
without neon for greater compatibility
[MGD-1222]
Search highlighting improved
[MGD-1131]
Context menus in MGD now contain default
actions
[MGD-1137]
Show and hide menus added for column context
menus
[MGD-71]
Improved error message regarding the libjpeg62
dependency
[MGD-240]
Added more default items to the context menus
[MGD-1011]
Added alpha channel support when opening
images opened from the Framebuffers View
[MGD-835]
User can now copy function calls from the Trace
View to the clipboard
[MGD-1352]
Made improvements to previous/next change
location in Target State View
[MGD-879]
New samples have been added to show features
such as overdraw map, fragment count statistics,
shader map and frame capture
[MGD-1234]
Debug menu now contains all of options from the
toolbar and in the same order
[MGD-1341]
Columns in the Statistic View are now resizable
[MGD-1246]
User can now filter frames by MGD features such
as overdraw
[MGD-1432]
MGD updated to use Java 7 and JRE is bundled
with package
[MGD-1086]
Improved handling of large trace files
[MGD-1322]
Framebuffers View now correctly reports pixel
coordinates no matter what the view size
[MGD-1333]
Progress bar now shown when doing a capture
from paused
[MGD-1429]
MGD no longer hangs when replaying a frame
that had previously been captured
[MGD-1296]
OpenGL ES 3.1 basic support has been added.
All calls are now intercepted and displayed in the
Trace View
[MGD-1317]
Failed calls to glTexImage* no longer update
texture assets
[MGD-219]
Vertex attribute support added for OpenGL ES
3.0 entry points
[MGD-1319]
Increased the number of texture formats that
MGD supports
| Changes from Previous Versions | 66
[MGD-1253]
Attachment data is now captured
for glDiscardFramebufferEXT and
glInvalidateFramebuffer
[MGD-245]
Added the ability to create notes in the Trace
View to highlight specific lines in a trace
[MGD-290]
Filmstrip feature can be toggled on or off during
tracing
[MGD-1460]
User can now override a texture with a predefined
checker board texture whilst replaying a frame
[MGD-1466]
User can now override the precision mode for all
types in a shader whilst replaying a frame
[MGD-1433]
Added documentation for using the interceptor
inside an APK
[MGD-974]
Icons added to help distinguish between regular
frames, replayed frames and frames with different
features
[MGD-1297]
Added new Compute Shaders View
[MGD-1457]
Added app selection screen to the new MGD
daemon app
[MGD-1088]
Improved speed whilst calculating unique indices
[MGD-1142]
Ability to copy text strings in MGD added
[MGD-1338]
Total cycles number is now uses decimal notation
instead of E notation
[MGD-1170]
Fixed tooltip for the index number of an API call
[MGD-1339]
Vertex and Fragment Shaders View counters are
now aligned to the right
[MGD-1230]
Preferences menu has been re-enabled for all
platforms
[MGD-1202]
Inconsistent use of N/A in the UI has been
resolved
[MGD-1287]
Trace search now updates as the application is
running
[MGD-260]
Context menu items are grayed out if unavailable
[MGD-1395]
Can now do a frame capture on a replayed frame
[MGD-1282]
Framebuffers now open in an image editor the
same orientation as MGD displays
[MGD-1458]
MGD daemon application can now detect whether
it is on a rooted device or not
[MGD-1505]
Version 4.5.0 of the Mali offline compiler
integrated. This allows the compilation of compute
shaders
[MGD-1383]
Items in the GUI are now correctly sorted
[MGD-1470]
User can now edit shaders in an application and
then replay a frame using their edited shaders
instead of the original ones
[MGD-1179]
EGL attribute names are now shown rather than
numerical values
| Changes from Previous Versions | 67
[MGD-1134]
Improved OpenGL ES 1.1 support
[MGD-1445]
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
Summary
[MGD-1475]
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
Summary
[MGD-504]
The results of glGetError are now show for every
call
[MGD-246]
Added “Step” feature to allow stepping through
frames on the target
[MGD-896]
Traces are now in a binary format to increase
performance
[MGD-282]
Added a feature in the Vertex Attribute View to
visualize sparse vertex indices. Also added a
warning if the vertex indices are too sparse.
[MGD-1024]
Added support for replaying frames which don’t
create or destroy state
[MGD-297]
Shader cycles statistics are now calculated for
‘Midgard’ based devices
[MGD-263]
Double-clicking an MGD trace file now opens
MGD (Windows only)
[MGD-900]
Search function is faster
[MGD-1000]
MGD is more responsive when selecting the last
frame in a big trace
[MGD-1001]
MGD no longer runs out of memory after opening
and closing several trace files
[MGD-1092]
Fixed shader views sorting when using “Show
create location”
[MGD-241]
String arguments are now shown instead of the
pointer value in the Trace View
[MGD-1121]
The Vertex Attribute View is now correct when the
minimum vertex index is >0
[MGD-1138]
Fixed Shaders View so it shows shaders correctly
before they’ve been linked
[MGD-1155]
Added EGL parameters are in the Assets View
[MGD-146]
Stopped context being lost in the Outline View
when selecting a call other than glDrawElements
| Changes from Previous Versions | 68
[MGD-1104]
Fixed shadermaps so they use the same shader
number as API calls
[MGD-1096]
In a multi-context trace, the trace problems are
now correct
[MGD-1094]
Constants are now correctly displayed for glClear
[MGD-65]
Texture formats for T-Rex HD are now correct
[MGD-1066]
Stopped UI locking up while saving traces
[MGD-831]
Attaching a texture to a channel of an FBO now
detaches whatever is currently bound
[MGD-1091]
Added support for BGRA textures
[MGD-1079]
Framebuffers View is now cleared when trace file
gets closed
[MGD-1065]
Stopped UI locking up when connecting to a nonexisting IP address
[MGD-1015]
“Show create location” / Show last modification
now works for the shader views
[MGD-997]
It is no longer possible to close main application
window when Open File dialog is open
[MGD-1071]
Assets View selection is no longer cleared when
stepping backwards through the trace
[MGD-1068]
Stepping through draw calls no longer resets the
asset table
[MGD-1036]
Fixed a NullPointerException which was thrown
after reopening the Assets View
[MGD-903]
Stopped the Framebuffers View of other open
traces being cleared when you close a trace
[MGD-2]
Canceling file read no longer results in Stream
Closed error
[MGD-888]
Traces can be exported to a text file
[MGD-210]
Trace file highlights can now be removed once
set
[MGD-947]
Function arguments now display correct
enumeration values
[MGD-935]
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
Summary
[MGD-1012]
Fixed unique indices count.
[MGD-231]
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.
| Changes from Previous Versions | 69
Issue
Summary
[MGD-935]
Fixed java.util.ConcurrentModificationException.
[MGD-197]
Show framebuffer pixel information.
[MGD-922]
Eliminate memory-free error on interceptor
shutdown.
[MGD-921]
Fix for interceptor segfault on GFXBench3 (PBO).
[MGD-907]
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
Summary
[D905]
Allow binary shaders to be debugged. All apps
will fall back to compiled shaders.
[D852]
Added end to end tests for fragment count
[D837]
Handle click on empty framebuffer image.
Previously the app would throw a generic warning
if an empty framebuffer was double-clicked.
[D887]
Suppress multiple error dialogs. These were
produced when trying to read a texture without
the appropriate decoder. Only one report is now
produced for each failing decoder.
[D463]
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.
[A860]
Fixed exception thrown when calculating shader
statistics.
[A876]
Add armhf_fbdev in the installer
[A873]
Fix workbench save/restore with new versions.
[D3]
Fixed Vertex Shaders View and Fragment
Shaders View 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 grayed out if still attached Vertex shaders
in the Vertex Shaders View also now have a
color.
Add framebuffer size in the tooltip
[D335]
README_linux and README_android merged
into user guide Added target installation content
to the user guide. Deleted README_android and
README_linux
| Changes from Previous Versions | 70
[D844]
Daemon now reports version during start up
[D852]
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.
[D859]
Adding Android ASTC support
All mga references become mgd
Changed test trace file extension to mgd.
Fix frame and draw call index numbers in
Statistics View. These were one-out.
Adding ASTC decoding to GUI.
[D854]
Changed Linux installer extension to tgz. This
simplifies publishing.
[D160]
Renaming State View 'State' column to 'State
Item'
[D836]
Renaming samples to have a .mgd extension
Show colors in the Fragment Shaders View.
[D838]
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
[A753]
Clear frame image when model unloads.
[D12]
Show multiple texture formats/types only if they
are different.
[D34]
Overdraw map now supports OpenGL ES 3.0
shaders (Timbuktu works)
[D63]
Add status line with progress report for
background jobs.
[A595]
Fix 'task already scheduled or canceled' when
closing and re-opening the Statistics View.
[A801]
Fix exception when canceling a file open action.
[A788]
Inform the user when the connection to the target
is broken
[A793]
change extension to .mgd
[A722]
Better message for broken URLs in help lookup.
Fix opening a file shows up as dirty.
[A815]
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.
[A760]
Saving now updates tab. And you can
differentiate between save and save as.
Adding single-step function.
Fixing interaction between pause and framebuffer
requests.
| Changes from Previous Versions | 71
Improve image drawing, remove unnecessary
images.
Add support for RGB and RGB565 formats for
framebuffers.
Enable O3 optimization in the Android build.
[A794]
Message when texture cannot be displayed
externally.
Implemented overdraw map
[A834]
Fix bug calculating shader cycle average.
[A779]
Vertices per draw call and frame now show
Unique vertices as well
[A834]
Add vertices count to shader stats.
[A284]
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.
Implemented core OpenGL ES 3.0 vertex
attribute types
[A727]
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 bit fields 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.
| Changes from Previous Versions | 72
[A762]
Fixed find on a live trace
Added armhf build to bundle
Updated emulator to load libGLES from
same directory. Now loads libGLES* from
same directory as libEGL, rather than using
LD_LIBRARY_PATH, which was causing some
trouble previously.
[A758]
Fix null pointer exception when saving. This
occurs when a constant value is unrecognized.
These are now replaced with 'unrecognized'
but this can only be temporary until unknown
constants are properly supported.
[A724]
Add User Guide note on GTK warnings.
[A720]
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 open editor call,
but this is unavoidable at the moment.
[A717]
Only permit existing file to be opened. Previously
the File # Open dialog would allow the user
to type a file name that didn't exist, causing
problems later in the flow.
[A691]
Search substrings (they don't need to fully
match).
Fix Y coordinate of cube maps.
[A684]
Fix bug. MGD did not show up on Mac with Java
1.6
[D686]
Fixing standard Mac menu items. The 'About
MGD' and 'Preferences' options were missing
from the Mac implementation.
[A697]
Revising socket close mechanism to eliminate
errors. The socket shutdown 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
OpenGL ES 3.0 working on Android, and
Nexus10 4.3 booting. Only needed to chmod
to work on Android 4.3, so have changed the
README to reflect this requirement. Have also
removed the OpenGL ES 2.0 version of the
android interceptor, and will now ship OpenGL ES
3.0
[D698]
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.
| Changes from Previous Versions | 73
Issue
Summary
[353]
Added Vertex Attributes View, which shows all the
vertices used in a ‘draw’ call
[353]
Indices buffers are captured in the trace
Added warning for swapping between buffer
targets
[653]
Adding statistic for vertices per frame and show
vertices count in the Outline View
Shader statistics are now updated individually
[349]
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
[591]
“Save” now asks before overwriting
Add reference to the buffers table in
GL_ELEMENT_ARRAY_BUFFER_BINDING
[620]
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
Add uniforms support.
Fix concurrent modification exception.
[550]
Fix bug in Windows installer.
Moving views; adding right click menu.
Dimension sorts by width following area.
Adding shader attributes to the Programs View.
Update EULA with Apache Commons library.
[543]
Fixing trace load progress counter.
[539]
Texture names now sort on ID
[353]
Added glVertexAttrib*fv family of entry points
[353]
Added glVertexAttrib*f commands to the Asset
Processor
Upgrade everything to Java 1.7
Small improvements to the UI of the Outline View
Fix for interceptor vertex array buffer sending
[514]
Adding index to draw call in frame.
[485]
Fix warning 'timer already canceled'.
Add detection of eglGetError errors.
Display frames with alternate colors in the Trace
View.
| Changes from Previous Versions | 74
[518]
Adding table header tool tips.
[517]
Added index column to Trace View.
[515]
Attachment temporary files now deleted on exit.
Small UI improvements
Fix NullPointerException with buffers.
[489]
Fix Trace View switching.
Add statistics entry to show the number of API
calls per frame.
Make open file trace faster.
[483]
Improved performance when highlighting the
locations of a problem in the trace.
[508]
Fix double-click global action issue.
Add Buffers View.
Changed Assets View to sort OpenGL ES objects
alphabetically
[498]
Added preview text and icons for Buffer assets.
Add a simple binary viewer for buffers.
Fix precision errors in the progress bar.
[482]
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.
Display information for textures bound to
framebuffers.
[341]
Show number of vertices and draw calls in the
Outline View.
[341]
Add per frame and per draw call statistics in the
view.
[498]
Added Asset Processor support for all OpenGL
ES 3.0 target buffers.
[498]
Updated Asset Processor to handle
glBufferSubData
[498]
Added tracking of buffer creation/deletion/
modification to model.
[498]
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
Summary
Notes
[429]
Removed multi-selection on
Trace Problems View.
Since only the first selection is
used. Also selection now done
on a single-click rather than a
double-click.
| Changes from Previous Versions | 75
[473]
Fixed issue when textures with
type 565 were sent.
Caused traces with RGB565
images to fail to load.
[427]
Personalized icons on shader
editor.
Shader editor pane now shows
the icon appropriate to the
content.
[472]
Added eglGetProcAddress path
for function pointer lookup in
interceptor functions.
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.
[453]
Fixing trace load cancel button.
MGD now stops cleanly when
the cancel button is pressed on
a large trace load.
[451]
Reducing argument memory
usage.
Provide support for saving
attachments and framebuffers to
disk when the system is short of
memory.
[474]
Fix Save dialog (before it was
actually a open dialog).
Also add a filter for txt extension
on trace files.
Add type to the image buffers
and textures, and display it.
[418]
Added documentation for all
special case functions.
All trace functions can be
double-clicked to reveal help
page.
[447]
Modified Trace View code to
handle bit fields.
Functions such as glClear which
take a bit mask now show the bit
mask value expanded into each
of the mask values if possible.
[469]
Fix exception thrown when no
markers are selected.
[398]
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.
[435]
Removed shader editor right
click menu
The menu items had no effect,
and so have been removed.
[436]
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.
[448]
Retain connection IP address
and port information
If the user enters information in
the connection dialog then this is
now saved across sessions.
| Changes from Previous Versions | 76
[431]
Removing unused popup menu
on Statistics View.
Changes in version 1.0.0
This version is the first release of the Mali Graphics Debugger.
Removed unnecessary popup
menu.
Chapter
11
Support
For help and support from ARM and fellow developers, please visit
the ARM Mali Graphics Community.
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 | 78
Chapter
12
Legal
Topics:
•
•
Proprietary Notice
Analytics Information We
Track
| Legal | 80
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.
EGL and the EGL logo are trademarks of the Khronos Group Inc.
Vulkan and the Vulkan logo are trademarks of the Khronos Group Inc.
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
Name
Summary
Per product version
product/build
Tracks the current product build
ID
Per product version
product/version
Tracks the current product
version
Per session
product/user_preference
Tracks which MGD user
preferences are enabled and
disabled
Per session
system_property/os_arch
Tracks the operating system
bitness
Per session
system_property/
os_distribution_description
(Linux only) Tracks the Linux
distribution version descriptive
name
Per session
system_property/
os_distribution_name
(Linux only) Tracks the Linux
distribution name
Per session
system_property/
os_distribution_version
(Linux only) Tracks the Linux
distribution version number
Per session
system_property/os_name
Tracks the operating system
name
| Legal | 81
Per session
system_property/os_version
Tracks the operating system
version
Per session
system_property/user_country
Tracks the users locale country
Per session
system_property/user_language Tracks the users locale
language
Per session
action/set_target_ip
Per session
action/
Tracks if the user clicked the
user_clicked_updated_version_block_link
block link in the update available
popup
Per session
action/
Tracks if the user clicked the
user_clicked_updated_version_download_link
download link in the update
available popup
Per session
memory/amount_available
Tracks the amount of memory
available to Java when the
program is first run
Per session
memory/critical_event
Tracks the number of times a
critical memory level is detected
Per session
memory/warning_event
Tracks the number of times
a warning memory level is
detected
Per session
product/user_preference
Tracks which MGD user
preferences are enabled and
disabled
Per session
view/tab_activated
Tracks the number of times an
individual view is used
Per trace
action/add_override_count
Tracks the number of times each
kind of frame override is used
Per trace
action/
disable_send_output_buffers
Tracks the number of times
output buffers sending was
disabled
Per trace
action/
Tracks the number of times
enable_capture_all_framebuffer_attachments
additional framebuffer
attachment capturing was
enabled
Per trace
action/enable_filmstrip_count
Tracks the number of times the
filmstrip mode feature was used
Per trace
action/enable_fragment_count
Tracks the number of times the
fragment count feature was used
Per trace
action/enable_frame_capture
Tracks the number of times the
frame capture feature was used
Per trace
action/enable_overdraw
Tracks the number of times the
overdraw feature was used
Per trace
action/enable_shadermap
Tracks the number of times the
shadermap feature was used
Per trace
action/open_documentation
Tracks number of times user
uses 'Open Documentation'
feature
Per trace
action/replay_frame
Tracks the number of times the
frame replay feature was used
Tracks the number of times set
target IP feature is used
| Legal | 82
Per trace
action/
replay_frame_with_capture
Tracks the number of times
the frame replay with capture
feature was used
Per trace
action/use_gpu_verify
Tracks when GPUVerify feature
is used
Per trace
action/use_state_diff_feature
Tracks the number of times the
state diff is used
Per trace
trace/gles_api_version
Tracks the numbers of each
EGL context created, grouped
by OpenGL ES version
Per trace
trace/
gles_buffer_target_use_count
Tracks the numbers of uses of
each OpenGL ES buffer target
(GL_ARRAY_BUFFER, etc.)
Per trace
trace/
gles_draw_mode_use_count
Tracks the numbers of uses of
each OpenGL ES draw mode
(GL_TRIANGLES, etc.)
Per trace
trace/
Tracks the numbers of
gles_fbo_attachment_point_use_count
uses of each OpenGL
ES FBO attachment point
(GL_COLOR_ATTACHMENT0,
etc.)
Per trace
trace/
Tracks the numbers of
gles_fbo_attachment_type_use_count
uses of each OpenGL ES
FBO attachment target
(GL_RENDERBUFFER,
GL_TEXTURE2D, etc.)
Per trace
trace/
Tracks the largest overall area of
gles_fbo_dimensions_largest_areaan FBO encountered
Per trace
trace/
Tracks the largest height of an
gles_fbo_dimensions_largest_height
FBO encountered
Per trace
trace/
Tracks the largest width of an
gles_fbo_dimensions_largest_width
FBO encountered
Per trace
trace/
gles_texture_dimension_largest
Tracks the largest overall area of
any texture encountered
Per trace
trace/
gles_texture_format_use_count
Tracks the numbers of uses of
each OpenGL ES texture format
used (GL_RGBA8, etc.)
Per trace
trace/
gles_texture_target_use_count
Tracks the numbers of uses of
each OpenGL ES texture target
used (GL_TEXTURE2D, etc.)
Per trace
trace/largest_call_count
Tracks the total number of all
function calls
Per trace
trace/
largest_drawcallperframe_count
Tracks the largest number of
draw function calls in a single
frame
Per trace
trace/largest_frame_count
Tracks the total number of
frames
Per trace
trace/
Tracks the largest number of
largest_instancedverticesperframe_count
instanced vertices per frame
Per trace
trace/largest_shader_cycles
Tracks the largest total shader
cycles for any shader
| Legal | 83
Per trace
trace/
largest_verticesperframe_count
Tracks the largest number of
vertices per frame
Per trace
trace/live_target_type
Tracks the type of live target
connected to (Android, Linux)
Per trace
trace/live_version
Tracks the version number of a
trace
Per trace
trace/number_of_generated
Tracks the numbers of each
type of OpenGL ES resource
created (Textures, Shaders,
Sync Objects, etc.)
Per trace
trace/opencl_context_counter
Tracks the number of OpenCL
contexts created
Per trace
trace/read_version
Tracks the version of the trace
file loaded from a saved trace
| Legal | 84
Was this manual useful for you? yes no
Thank you for your participation!

* Your assessment is very important for improving the work of artificial intelligence, which forms the content of this project

Download PDF

advertising