GPU — what it is, architecture and how it works

What is a GPU?

GPU (Graphics Processing Unit) is a specialized microchip designed for massive parallelism. The first GPUs appeared in the late 1990s as 3D graphics accelerators for desktop PCs. Since then, the architecture has evolved from a fixed pipeline to programmable shaders and universal compute units.

The main purpose of a GPU is rasterization: converting geometric data (vertices, triangles) into pixels on the screen. The process includes vertex transformation, culling invisible surfaces, texturing, and color blending. All these operations are performed in parallel for thousands of elements simultaneously.

According to Jon Peddie Research (2025), the mobile GPU market accounts for 58% of the total graphics processor volume, outpacing discrete solutions for PCs and servers. Every smartphone contains at least one GPU integrated into the System-on-Chip (SoC) along with the CPU, DSP, and neural processor.

Modern GPUs are divided into two types: integrated (built into the SoC, sharing memory with the CPU) and discrete (separate board with its own video memory). Mobile development exclusively uses integrated GPUs — Qualcomm Adreno, ARM Mali, Apple GPU, and Imagination PowerVR.

History of GPU Development

GPU evolution has gone through three stages: fixed pipeline (1999–2006), unified shaders (2006–2016), and programmable compute cores (2016 — present). The first stage defined a rigid sequence of operations — transformation, lighting, texturing. Developers could not intervene in the pipeline.

With the advent of unified shaders, the GPU gained the ability to execute arbitrary programs — shaders written in HLSL or GLSL. This opened the door to GPGPU — using the GPU for non-graphics tasks. The third stage added tensor cores for machine learning and real-time ray tracing.

In mobile GPUs, the key milestone was the introduction of Tile-Based Deferred Rendering (TBDR) — an architecture where the frame is split into tiles (16x16 pixels) and processed in fast on-chip memory. This reduces power consumption by 3–5 times compared to immediate mode rendering typical of desktop GPUs.

GPU Architecture

GPU architecture differs radically from CPU. Instead of a few powerful cores with large caches, a GPU contains hundreds or thousands of simple compute units optimized for SIMD (Single Instruction, Multiple Data) — one instruction is executed over multiple data elements.

The basic building block of a GPU is the Shader Core (in NVIDIA terms) or Execution Unit (Intel). Multiple such blocks are combined into Compute Units (AMD) or Streaming Multiprocessors (NVIDIA). Each block includes ALUs for arithmetic, a register file, and a warp scheduler (thread groups).

Mobile GPUs differ architecturally from desktop ones. Qualcomm Adreno uses an architecture with programmable shader processors and a dedicated rasterization block. ARM Mali is based on Bifrost or Valhall — architectures with quad warp processing. Apple GPU has had its own design since 2017 with Metal support and unified memory.

A key feature of mobile GPUs is Unified Memory Architecture (UMA). The GPU and CPU share the same RAM without dedicated video memory. This reduces latency in data exchange and simplifies programming, but limits bandwidth under intensive computations.

GPU vs CPU: Key Differences

CPU is designed for sequential tasks with minimal latency. It contains 4–12 powerful cores with large L1/L2/L3 caches, branch predictors, and speculative execution. The GPU, by contrast, sacrifices latency for throughput — thousands of cores process data with high latency but enormous aggregate performance.

The difference is evident in FLOPS (floating-point operations per second). A top-tier mobile SoC in 2025: CPU — 200 GFLOPS, GPU — 2400 GFLOPS. The GPU outperforms the CPU by 12x on tasks that allow parallelism. However, for sequential algorithms, the CPU remains faster due to lower thread management overhead.

In practice, developers use the CPU for application logic, UI, and IO, and the GPU for rendering, image processing, physics simulation, and neural network inference. According to Google Android Performance Patterns (2025), optimal GPU load in mobile applications is 60–80% — overload leads to throttling and overheating.

// CPU — sequential processing
for (int i = 0; i < N; i++) {
    result[i] = data[i] * 2.0f;
}

// GPU — parallel processing (GLSL compute shader)
#version 300 es
layout(local_size_x = 256) in;
void main() {
    uint idx = gl_GlobalInvocationID.x;
    result[idx] = data[idx] * 2.0f;
}

The CPU code performs multiplication sequentially for each element. The GPU version launches 256 threads in parallel, each multiplying its own element. With N=1 million, the GPU will complete the task 100–1000 times faster than a single CPU core.

GPU in Mobile Devices

Mobile GPUs operate under strict thermal and power constraints. A typical mobile GPU TDP is 2–8 W, compared to 150–450 W for desktop counterparts. This requires a special architecture focused on energy efficiency rather than peak performance.

The main power-saving technology is Tile-Based Rendering. The frame is split into 16x16 or 32x32 pixel tiles. Each tile is fully processed in fast SRAM (Tile Memory), then written to external DRAM. This reduces memory accesses by 4–10x compared to immediate mode.

Qualcomm Adreno is the most widespread mobile GPU. Adreno 750 (Snapdragon 8 Gen 3) contains 12 shader processors with a shared register pool. It supports Vulkan 1.3, OpenGL ES 3.2, OpenCL 3.0, and hardware ray tracing. According to Qualcomm (2025), Adreno delivers 45% generation-over-generation performance improvement while maintaining power consumption.

ARM Mali is the second most popular GPU in Android devices. Mali-G720 is based on 5th generation Valhall architecture with Variable Rate Shading and ASTC HDR support. A distinctive feature of Mali is quad processing: four threads are combined into one warp for better ALU utilization.

Apple GPU is designed exclusively for the Metal API. Since the A13 Bionic, Apple has used its own GPU design with Metal 3 support, ray tracing, and mesh shaders. The Apple GPU architecture features Unified Memory with up to 800 GB/s bandwidth on the M4 Ultra.

Power Consumption and Throttling

GPU throttling — frequency reduction under overheating — is the main problem in mobile gaming. Under sustained load, the SoC temperature reaches 85–95°C, and the GPU reduces frequency by 30–50%. According to AnandTech (2025), the Qualcomm Adreno 750 loses up to 35% performance after 15 minutes in Genshin Impact.

Developers can mitigate throttling through draw call optimization, reducing rendering resolution, and using Foveated Rendering. Metal Performance Shaders on iOS and Android Frame Pacing API on Android help synchronize load with the device's thermal budget.

GPGPU: Computing on GPU

GPGPU (General-Purpose computing on GPU) is the use of a graphics processor for non-graphics computations. The idea originated in the mid-2000s when developers realized that shaders could be adapted for matrix operations, cryptography, and physics simulation.

Today, GPGPU is a standard tool for tasks requiring massive parallelism: machine learning (training and inference of neural networks), cryptography (hashing, encryption), image and video processing (filters, codecs), and scientific simulations (fluid dynamics, quantum chemistry).

On mobile devices, GPGPU is accessed through Compute Shaders — shaders without graphical output that work only with data. A Compute Shader launches a grid of workgroups, each containing several threads. Memory access is through buffers and textures without any screen binding.

#version 310 es
layout(local_size_x = 16, local_size_y = 16) in;
layout(binding = 0) buffer Input  { float data[]; };
layout(binding = 1) buffer Output { float result[]; };

void main() {
    uvec2 idx = gl_GlobalInvocationID.xy;
    uint offset = idx.y * gl_NumWorkGroups.x * gl_WorkGroupSize.x + idx.x;
    result[offset] = sqrt(data[offset]) + 1.0;
}

The example compute shader calculates the square root for each array element. A 16x16 workgroup processes 256 elements simultaneously. Modern mobile GPUs support up to 1024 workgroups and millions of global threads.

APIs for Working with GPU

GPU access APIs determine how developers send commands and data to the graphics processor. Three main APIs are used on mobile platforms: Vulkan, Metal, and OpenGL ES. Each has its own advantages and limitations that affect performance and compatibility.

Vulkan

Vulkan is a low-level cross-platform API from the Khronos Group, the successor to OpenGL. Vulkan gives developers direct control over GPU memory, command queues, and synchronization. According to Khronos (2025), Vulkan provides a 30–60% performance improvement over OpenGL ES by reducing driver overhead.

On Android, Vulkan is mandatory since Android 7.0 (API 24), and all modern SoCs support Vulkan 1.3. Vulkan Memory Allocator and SPIR-V as an intermediate representation allow writing shaders in GLSL, HLSL, or Rust GPU.

Metal

Metal is Apple's proprietary GPU API for all ecosystem devices: iPhone, iPad, Mac, Apple TV. Metal provides minimal overhead and predictable command execution time. According to Apple Developer Documentation (2025), Metal handles up to 100,000 draw calls per frame without FPS drops.

A key feature is Metal Shading Language (MSL) based on C++. Shaders are compiled to machine code together with the application, eliminating the JIT compilation typical of Vulkan. Metal supports Mesh Shaders, Ray Tracing, and Dynamic Libraries for loading shaders at runtime.

OpenGL ES

OpenGL ES is a simplified version of OpenGL for embedded systems. It is used on older devices and for backward compatibility. OpenGL ES 3.2 is supported on 94% of Android devices according to Android Studio (2025). For new projects, Google recommends Vulkan over OpenGL ES.

WebGL is the browser-based analogue of OpenGL ES, the foundation for 3D graphics on the web. WebGL 2.0 (corresponding to OpenGL ES 3.0) is supported on 92% of mobile browsers. WebGPU is the next generation, with an architecture close to Vulkan and Metal.