Searcharxiv⌕ Search

arXiv · 2609.11940

The Battery Price of edge AI: A study of the Environmental Impact of LLM Inference on Mobile Devices

Abstract

The rapid diffusion of generative artificial intelligence raises privacy, latency, and performance concerns that motivate a shift toward "local-first" AI, where inferences are performed on the user's device instead of on remote cloud servers. This paradigm also places a significant computational load on battery-powered smartphones, potentially shortening battery life and increasing the overall replacement rate of mobile devices. This paper presents a systematic study of the energy consumption, performance, and accuracy of on-device large language model (LLM) inference. We evaluate 18 models from different model families, sizes, and quantization levels, on two modern smartphones and on a server, using the respective state-of-the-art for such deployments. We measure the energy per generated token, inter-token latency, model accuracy, and battery-cycle consumption. Our results show that (i) on-device inference is on average 3 times less energy-efficient than batched server inference; (ii) the relationship between quantization bit-width and energy per token is non-monotonic, with energy sweet spots on both tested smartphones; (iii) eight out of 18 model configurations lie on the Pareto front of accuracy and energy-efficiency, allowing practitioners to build battery-aware model routers; and (iv) realistic modeling assumptions do not allow local inference to be less environmentally impacting per token than batched server inference, with 88--90% of that impact attributable to device embodied carbon rather than electricity consumption. These findings challenge the premise that local AI is more sustainable than cloud inference, and motivate the need for context-aware and life-cycle-aware model selection when deploying edge AI on battery-powered mobile platforms.

Explore related subjects

Keep this discovery

Explore connections, maps & timelines

BibTeXRIS

Édouard Guégain, Tristan Coignion. 2026-07-10. The Battery Price of edge AI: A study of the Environmental Impact of LLM Inference on Mobile Devices. https://searcharxiv.com/abs/2609.11940

Citations retain the original authors and DOI and include this site’s record URL. If this discovery service contributed to your research, you can also cite Searcharxiv by Indiciae: BibTeX · RIS.

KEEP EXPLORING

Related papers

Optimizing Winograd Convolution on ARMv8 processors

As Convolutional Neural Networks (CNNs) gain increasing prominence in deep learning, algorithms such as Winograd convolution have been introduced to boost computational efficiency. However, existing Winograd implementations often face challenges, including significant transformation overhead, suboptimal computation efficiency, and reduced parallel performance in certain layers. In this work, we present an ARMv8-specific execution framework for Winograd convolution based on a cache-resident, block-wise schedule. By maintaining consecutive memory access where possible and packing data in a customized z-shaped layout, our approach fully exploits a meticulously optimized GEMM micro-kernel that employs a ping-pong technique. Furthermore, we introduce a multidimensional parallelization strategy that selects a thread decomposition across the batch, tile, input-channel, and output-channel loops according to layer shape and coordinates the resulting thread groups with the fused block-wise execution schedule. To further boost performance, we manually optimize each micro-kernel in AArch64 assembly, carefully tuning blocking parameters for the ARMv8 architecture to minimize transformation overhead and maximize computational throughput. Experimental results demonstrate that our method achieves up to $4.74\times$, $4.10\times$, $4.72\times$, and $10.57\times$ speedups over NCNN, NNPACK, FastConv, and ACL, respectively, on the Kunpeng 920 platform when using multiple threads, with corresponding gains of $5.46\times$, $2.81\times$, $6.11\times$, and $8.05\times$ on the AWS Graviton2, and $3.32\times$, $3.68\times$, $5.84\times$, and $9.28\times$ on the Phytium 2000+.

cs.PF↗

Warpline: Binary-Level Tracing and Unified Evidence for Agentic GPU Kernel Optimization

LLM agents are becoming GPU kernel engineers, but they still tune kernels without seeing where the time goes. Hardware profilers report how busy each unit was, not where each warp's time went; intra-kernel tracers can show it, but only with hand-placed probes and a recompilation that alters the very kernel being measured. We present Warpline, which gives agents this view automatically while leaving the kernel essentially unchanged. Warpline analyzes the binary to decide which events to record and inserts probes into the binary itself without recompilation or any manual step. It then aligns the trace with hardware profiling data on one unified timeline. Because it needs only the binary, it can regenerate this evidence for every new version of the kernel at whatever level the agent edits it (source, IR, or PTX), closing the optimization loop without human intervention. On NVIDIA B200, across 35 kernels in Triton, CuTe DSL, and CUDA C++, Warpline adds a median overhead of 1.2% and leaves a median 99.9% of executed instructions unchanged, whereas existing tracers have median overheads of 1.6% to 13.2% and leave only 4.6% to 32.7% unchanged. Warpline also traces closed-source kernels, which these tracers cannot. On 10 SOL-ExecBench problems, agents using Warpline spend less time and fewer model requests than a bare coding agent and NVIDIA's Kernel Design Agents (KDA), yet lead both after every round in geometric mean and reach a 7.69$\times$ geometric-mean speedup, against 6.94$\times$ and 6.13$\times$. Two case studies further demonstrate that Warpline reveals hidden bottlenecks and provides actionable optimization insights.

cs.PF↗

How well does graph superoptimization transfer? Adapting tensor-graph superoptimizer to a Triton-based NPU

For automatic optimization systems, performance portability across increasingly diverse AI accelerators remains a challenge. We investigate how well graph-level superoptimization transfers across architectures by adapting Mirage from its CUDA-oriented design to the Huawei Ascend 910B3 through a Triton-based compilation stack. We evaluate the adapted system on transformer-relevant workloads, including matrix multiplication, softmax, RMSNorm+MatMul, gated MLP, FNN, and attention. The results show that graph-level optimization can successfully transfer and outperform available reference implementations by up to 87.0% on fused workloads. However, performance is highly dependent on tensor shape and workload structure, with substantial regressions for other configurations. We identify target-specific tensor partitioning, execution-resource modeling, backend lowering and fusion, and search and verification costs as key limitations. Our findings demonstrate that a portable graph representation and programming model do not imply a portable optimization space, motivating modular target-specific mechanisms within otherwise reusable compiler infrastructure.

cs.PF↗