Android GPU Thermal Throttling and gpu.js Throughput

Running GPU-accelerated calculations on mobile Android devices using gpu.js offers significant performance benefits for parallel computing tasks, but sustained execution inevitably collides with hardware thermal limits. Because smartphones rely entirely on passive cooling, extended compute loads cause rapid heat accumulation in the System-on-Chip (SoC). This triggers aggressive thermal throttling via Dynamic Voltage and Frequency Scaling (DVFS), which significantly degrades sustained compute throughput, increases kernel execution times, and introduces unpredictable latency in browser-based GPU applications.

How gpu.js Operates on Android

gpu.js accelerates JavaScript operations by compiling user code into WebGL fragment shaders (or WebGPU compute passes where supported). On Android, these shaders execute directly on integrated mobile GPUs, such as ARM Mali, Qualcomm Adreno, or MediaTek Immortalis chipsets.

When a compute kernel executes:

  1. Data arrays are serialized and uploaded to the GPU as WebGL textures.
  2. The compiled fragment shader processes the data in parallel across multiple GPU execution units.
  3. The resulting textures are read back to the CPU via gl.readPixels or mapped memory buffers.

During short execution windows, this architecture provides massive speedups over single-threaded or multi-threaded CPU execution in JavaScript.

The Onset of Thermal Throttling

Unlike desktop environments with active fans and large heatsinks, Android smartphones manage thermal dissipation strictly through conduction across the chassis. An intensive compute kernel can cause SoC junction temperatures to escalate to safe operational limits (typically 75°C to 85°C) within 30 to 90 seconds of continuous execution.

To prevent hardware damage and maintain a safe surface temperature for user handling, the Android Linux kernel's thermal governor initiates throttling:

  • Clock Frequency Scaling: The GPU core clock is lowered incrementally or sharply, often dropping from peak boost frequencies (e.g., 800–1000 MHz) down to base or sub-base frequencies (e.g., 300–400 MHz).
  • Voltage Scaling: Core voltage is reduced alongside frequency to drop power draw exponentially.
  • CPU Downclocking: Because the CPU coordinates WebGL pipeline dispatches and readbacks, throttling of CPU clusters simultaneously impairs the data dispatch pipeline feeding the GPU.

Impact on Sustained Compute Throughput

The reduction in operating frequency directly degrades the raw floating-point operations per second (FLOPS) available to gpu.js kernels:

1. Significant Throughput Degradation

Initial benchmarks often reflect "burst" performance, misleading developers into expecting consistent speeds. As thermal limits are reached, sustained throughput typically drops by 30% to 60%. A matrix multiplication task that initially takes 15ms per iteration may take 40ms or longer once the device reaches steady-state thermal equilibrium.

2. High Pipeline Latency and Stalls

Mobile GPU architectures use tiled-based deferred rendering (TBDR). When thermal throttling occurs, the memory bandwidth between the GPU cache and system LPDDR RAM is also frequently throttled. Operations involving large memory transfers—such as reading back results via gl.readPixels—suffer disproportionately, creating bottlenecks where the CPU stalls while waiting for throttled GPU pipelines to clear.

3. Jitter and Unpredictable Frame Budgets

Thermal management systems continuously oscillate clock speeds as temperatures fluctuate near safety thresholds. This behavior causes compute execution times to swing wildly from run to run, making it impossible to guarantee deterministic execution timing for real-time applications such as on-device image processing or real-time sensor analytics.

Strategies to Mitigate Thermal Bottlenecks

To maintain acceptable sustained throughput in gpu.js under mobile thermal constraints, developers must design algorithms around thermal budgets:

  • Workload Batching and Yielding: Rather than running calculations in continuous, tight loops, divide the compute tasks into smaller chunks. Yield control back to the browser's event loop using requestAnimationFrame or setTimeout to provide periodic cooling windows for the SoC.
  • Precision Downscaling: Where permissible, use lower-precision data structures to minimize register pressure and memory bandwidth consumption inside the shader units.
  • Dynamic Workload Adaptation: Monitor the execution duration of each kernel run in JavaScript. If execution time increases past a baseline threshold without an increase in input size, assume thermal throttling has begun and dynamically scale down problem sizes or lower computation frequency.