Mobile GPU Performance Testing: From 60fps to 18fps

A game that runs at 60 fps on Pixel 7 can drop to 18 fps on Redmi Note 9 — and it's not because the phone is "weak". It's because the Adreno 618 and Mali-G52 process the same shader differently, and nobody checked behavior on Mali before release. We deal with such cases daily and know how to turn a slideshow into a smooth picture. Over our work, we have tested more than 50 projects — from hyper-casual to open-world RPG. Graphics performance testing is about understanding hardware differences and ensuring the game doesn't lose its audience.

What's included

Why does the game lag only on devices with Mali GPU?

Mali architecture uses tile-based deferred rendering, where overdraw and high-precision shader instructions can cause performance drops. For example, mediump precision in textureCubeLod may trigger a software fallback. We identify such cases using Mali Graphics Debugger.

Where are the real performance bottlenecks?

Draw calls and batching. 200 draw calls on a mobile device is the red zone. UI through Canvas in Overlay mode with multiple child canvases, each doing override sorting, will absolutely break all batches. Result: 80 draw calls just for the HUD, which can be reduced to 5–8 with proper hierarchy.

Overdraw. On mobile GPUs (tile-based deferred rendering), overdraw kills performance faster than on desktop. Rendering one pixel 4 times in a row means 4 times more work for the GPU. Particle systems with Additive blending, UI layers without culling, transparent meshes — typical sources. RenderDoc colors overdraw with a heat map directly in the viewport.

Thermal throttling. Mid-range Android devices after 3–5 minutes of intensive gaming reduce CPU/GPU clock frequencies by 20–40% due to overheating. This cannot be reproduced on an emulator. Therefore, sustained performance testing is done only on real hardware, with a minimum 20-minute gaming session.

How to compose a device matrix for testing?

Testing on a single "representative" device is not enough. Minimal matrix for a mobile project:

• Low-end (target floor): Qualcomm Snapdragon 460/Adreno 610, Mali-G52, 3 GB RAM.
• Mid-range (main audience): Snapdragon 700-series/Adreno 618-619, Mali-G76, 4–6 GB RAM.
• High-end (flagship): Snapdragon 8 Gen 2, Apple A16, 8+ GB RAM.

iOS separately: iPhone SE 2 (A13), iPhone 12 (A14), iPhone 14 Pro (A16) — three generations, three different Metal behaviors.

Why does emulator testing not replace real hardware?

The emulator does not reproduce thermal throttling — it uses host resources without limits. Moreover, it does not emulate the tile-based architecture of Mali and PowerVR, so overdraw and shader issues may go unnoticed. Only on a physical device can you measure actual FPS budget, temperature drops, and battery behavior.

Tools and methodology

Core workflow: Unity Profiler → Frame Debugger → Memory Profiler → platform-specific tools.

Unity Profiler provides a CPU thread breakdown and GPU timeline, but the GPU timeline does not work correctly on all devices. On some Android devices, ADB Profiler shows zeros in the GPU block. In such cases, we use native tools:

• Adreno GPU Profiler (Qualcomm): detailed pipeline stage breakdown, HSR efficiency, shader cycle counts.
• Mali Graphics Debugger (Arm): similar for Mali architectures, plus bandwidth visualization.
• Xcode Instruments + Metal Debugger: for iOS/Metal — mandatory tool.
• RenderDoc — cross-platform frame capture with full state inspector for shader and batching analysis.

For automated benchmarking — Unity Performance Testing Package. Allows writing tests that measure metrics (frame time, GC allocations, draw calls) and save baselines.

How we do it

1. Initial analysis: study the build, determine target devices, agree on a matrix.
2. Baseline profiling: on each device, record frame time, draw calls, overdraw, memory.
3. Identify bottlenecks: find problematic scenes (match start, explosion effects, open areas).
4. Iterative optimization: texture atlasing, LOD groups, GPU Instancing, occlusion culling, Shader LOD.
5. Re-testing: after each change, measure all devices.
6. Validation: check sustained performance (20+ minutes) and deliver a report with recommendations.

Contact us to discuss details and assess your project. Get a consultation from an engineer with experience optimizing for any GPU.

We have seen many times how a project at the finish line turns into a nightmare: everything runs smoothly on the developer's machine, but on a Samsung Galaxy A12 it's 15 FPS and crashes, and on an iPad Air textures are blurry. Without a well-established QA process, game testing becomes a lottery. Our team, with 8 years of experience, has tested over 30 mobile games and in every project found critical issues that standard runs missed. Turnkey game testing — from functional to load testing — with quality assurance and a report ready for implementation. We will evaluate your project in 3 days — contact us.

How Do We Guarantee High Quality Through Testing?

Our comprehensive testing process covers functional, regression, load, and performance testing on real devices to ensure your game runs smoothly.

Testing and QA

How to Automate Testing in Unity?

The most effective way to catch regression is automated tests that run without human intervention. In Unity, this is Unity Test Framework (UTF) based on NUnit. Two modes.

Edit Mode Tests run without the game loop — execution speed in milliseconds. Suitable for damage formulas, economy calculations, config validation. Play Mode Tests run the full game loop — test MonoBehaviour logic, coroutines, scene transitions.

Example:

[UnityTest]
public IEnumerator PlayerTakeDamage_HealthReduces()
{
    var go = new GameObject();
    var health = go.AddComponent<HealthComponent>();
    health.Initialize(100);

    health.ApplyDamage(30);

    yield return null;

    Assert.AreEqual(70, health.CurrentHealth);
}

Cover what breaks most often: save system, economy, combat logic. 100% coverage is not needed — critical paths are enough. UI (UGUI, UI Toolkit) is harder to automate: use InputSystem.QueueEvent or Appium on mobile platforms. Automated tests run 50 times faster than manual runs during regression — this reduces the regression testing budget by 40%.

Why Is Profiling on a Real Device Critical?

Tests don't catch performance issues. For that, you need a profiler on the target platform. Unity Profiler is a starting point. Key steps:

1. Profile on device, not in the Editor — Editor adds overhead. Connect the device via USB with a Development Build and Autoconnect Profiler.
2. Look at Main Thread and Render Thread separately. Typical issues:
   • Physics.FixedUpdate >2ms — complex physics
   • Canvas.BuildBatch every frame — unnecessary UI Dirty calls
   • GC.Collect — memory allocation in hot path (inside Update)
3. Use ProfilerMarker for localization:

using Unity.Profiling;

static readonly ProfilerMarker k_PathfindMarker = new ProfilerMarker("Pathfinding.Calculate");

void UpdateAI()
{
    using (k_PathfindMarker.Auto())
    {
        // pathfinding code
    }
}

Memory Profiler (package com.unity.memoryprofiler) provides memory snapshots: finds leaks (objects not freed after scene change), compares two snapshots. Most common causes of issues on mobile: textures without correct format (ASTC for iOS, ETC2 for Android), audio in WAV instead of Vorbis, objects in DontDestroyOnLoad that accumulate.

Frame Debugger (Window → Analysis → Frame Debugger) allows you to go through each draw call in the frame. For mobile projects, the norm is 50–150 draw calls; if more than 300, batching is not working or the scene is overloaded. Software performance testing emphasizes the importance of profiling on real hardware.

Profiling on a real device is mandatory — the Unity Editor gives distorted results due to its own overhead, so always use a Development Build on the target device.

Functional and Regression Testing

Functional testing is based on test plans: for each feature — expected result, reproduction steps, pass criteria. We cover smoke, sanity, and acceptance tests. Regression testing — running accumulated cases before each release, not just before major ones.

Management tools: TestRail, Qase, Zephyr. For small teams — Notion or Google Sheets with structured checklists.

Testing on Real Devices

Emulators do not reproduce thermal throttling, real GPU, and memory limitations. Minimum set — 20+ devices from all segments:

For large-scale testing — cloud farms: Firebase Test Lab, BrowserStack App Automate, AWS Device Farm. They allow running hundreds of parallel tests on real devices.

Load Testing (Multiplayer)

Goal — find server degradation before release. Tools: k6 (WebSocket/HTTP API), Gatling (complex stateful scenarios). For specific protocols, write a custom stress client in Go or C#.

Check parameters:

• Behavior at peak CCU (concurrent users) — up to 1000+ CCU
• Latency degradation under load (p95 latency)
• Memory leaks on the server over 72+ hours of operation
• Graceful degradation when one node fails

Crash Reporting and Monitoring

After release, QA continues through monitoring. Firebase Crashlytics is the standard for mobile games: automatic crash collection with stack trace symbolication, real-time notifications. Sentry — for server components and WebGL. ANR (Application Not Responding) is configured separately — Play Console shows them in a separate section. Investment in testing pays off in 2–3 releases, reducing post-release bug fixing costs by 60%.

What Our Work Includes

• Detailed test plan (checklist, scenarios, priorities)
• Automated test suite (economy, saves, critical paths — 70% coverage)
• CPU/GPU/memory profiling with report per bug
• Manual testing on 20+ real devices (low-end / mid-range / flagship)
• Server load testing (up to 1000+ CCU for 12 hours)
• Dashboard with metrics and run history
• Training your team in automated testing and profiling basics

Get a consultation for your project — we will evaluate your current build and propose an optimization plan.

Work Process

1. Analysis — study the architecture, collect current build metrics, define FPS and stability targets.
2. Test Plan — create a checklist, select tools, agree on scope.
3. Automation — write tests for critical paths, set up CI runs.
4. Manual Testing — run scenarios on devices, log bugs in tracker.
5. Report and Recommendations — provide a document with found issues, their priority, and specific fixes (shader optimization, batching settings, leaks).

Our Metrics

• 8+ years of experience in game development (Unity, Unreal, mobile/PC/console)
• 30+ mobile games tested
• Average FPS increase after optimization — 30%
• Reduction in regression testing time — 40%
• Guarantee: all critical/high priority bugs are fixed before release

Typical Mistakes in QA Process

• Testing only on flagships — most players are on mid-end and low-end.
• Lack of automated tests for economy and saves — they break on any refactoring.
• Skipping server load testing — game launches, gains 10k DAU, and server goes down.
• Regression only before major releases — critical before every public update.

Order turnkey game testing. We will evaluate your project in 3 days and offer a plan with guaranteed results. Write to us — we will analyze your build for free.