Oculus Go and Quest: Testing and Performance Analysis

This guide describes basic testing and performance analysis for Oculus Go and Quest development in Unreal Engine.

VR application debugging is a matter of getting insight into how the application is structured and executed, gathering data to evaluate actual performance, evaluating it against expectation, then methodically isolating and eliminating problems.

When analyzing or debugging, it is crucial to proceed in a controlled way so that you know specifically what change results in a different outcome. Focus on bottlenecks first. Only compare apples to apples, and change one thing at a time (e.g., resolution, hardware, quality, configuration).

Always be sure to profile, as systems are full of surprises. We recommend starting with simple code, and optimizing as you go - don’t try to optimize too early.

Performance Targets

Before debugging performance problems, establish clear targets to use as a baseline for calibrating your performance.

These targets can give you a sense of where to aim, and what to look at if you’re not making frame rate or are having performance problems.

Below you will find some general guidelines for establishing your baselines, given as approximate ranges unless otherwise noted.

Display Refresh Rate

• 60 FPS (minimum required by Oculus Store), or 72 FPS if your application can support this display refresh rate
• 50-100 draw calls per frame
• 50,000-100,000 triangles or vertices per frame

VRC Guidance

• Go Virtual Reality Check (VRC) Guidelines
• Quest Virtual Reality Check (VRC) Guidelines

Unreal Profiler Tool

The Unreal Editor provides a built-in Profiler Tool that provides performance metrics for your app.

Oculus has added the ‘Oculus System Metrics’ section of the Profiler Tool to provide real-time VR specific metrics.

The following metrics are available-

• App GPU Time (ms)
• Compositor Dropped Frames
• Compositor GPU Time (ms)
• System CPU Util Avg%
• System CPU Util Worst%
• System CPU Util Util%

Usage - CPU or GPU Bound

The first step of the performance optimization is often determining if the bottleneck is on the CPU or GPU. This can be difficult to determine on Android applications because of difficulty obtaining GPU timing. When the application is running on the Oculus Go with the Profiler Tool, you are able to read the GPU cost to both the application and the VR compositor. If the total GPU time is close or equal to the frame time, the application is likely GPU bound. Otherwise, the bottleneck is CPU.

Usage - Multithreading

Applications can use multiple cores simultaneously on the Oculus Go. The Profiler Tool gathers both the utility percentage on the most occupied CPU core and the average utility percentage among all CPU cores. If the “System CPU Util Worst%” is very high but the “System CPU Util Avg%” is relatively low, that often means opportunity to optimize the application by rebalancing workload among threads.

OVR Metrics Tool

OVR Metrics Tool reports application frame rate, heat, GPU and CPU throttling values, and the number of tears and stale frames per second. It is available for download from our Downloads page.

OVR Metrics Tool can be run two modes. In Report Mode, it displays performance report about a VR session after it is complete. Report data may be easily exported as a CSV and PNG graphs.

In Performance HUD Mode, OVR Metrics Tool renders performance graphs as a VR overlay over any running Oculus application.

For more information, see OVR Metrics Tool in our Mobile SDK Guide.

GDB Debugging

Oculus branches of Unreal add support for debugging mobile sessions using ndk-gdb, a small shell script wrapped around GNU GDB that is included with the Android NDK.

Using ndk-gdb from the command line adds convenient features to your debugging workflow by allowing, for example, adding breakpoints, stepping through code, and inspecting variables with a command line interface.

To use ndk-gdb for debugging:

1. Enable remote port forwarding to link your target mobile port to a PC port: adb forward tcp:$port tcp:$port
2. Set your Oculus Go to Developer Mode, as described in Device Setup - Oculus Go.
3. Launch the application you wish to debug.
4. Start gdbserver on the mobile device with the following Unreal console command: gdbserver $port where $port is your port number. You application should freeze, and will now be ready for debugging.
5. Launch the ndk-gdb client from the command line on your computer with the command gdb.exe. When it launches, type target remote :$port in the GDB command line to attach to your mobile device.

For more information on using GDB for debugging, see the GNU GDB documentation.

Additional Third-Party Tools

Systrace

Reports complete Android system utilization. It is available here: http://developer.android.com/tools/help/systrace.html

Snapdragon Profiler

The Oculus device is based on a Qualcomm chip set, so you can use the Snapdragon Profiler.

APITrace

https://apitrace.github.io/

Other Resources

For detailed information about Oculus development, go to:

• Unreal: Virtual Reality Development: https://docs.unrealengine.com/latest/INT/Platforms/VRZ/
• Unreal: Oculus Rift wiki: https://wiki.unrealengine.com/Oculus_Rift
• Oculus Forums/Unreal: https://forums.oculus.com/developer/categories/unreal
• Unreal Forums/VR Development: https://forums.unrealengine.com/forumdisplay.php?27-VR-Development

Contact

Visit our developer support forums at https://forums.oculusvr.com/developer/.

Our Support Center can be accessed at https://support.oculus.com.