Searcharxiv⌕ Search

arXiv · 2609.11932

Throughput per Megabyte: A Pilot Benchmark of Language-Stack Efficiency for Self-Hosted HTTP Services on a Raspberry Pi 5

Abstract

Cloud-centric web benchmarks miss constraints that matter for self-hosted services on ARM64 single-board computers, especially idle RAM footprint and energy per request. We ran a pilot benchmark on one Raspberry Pi 5, measuring equivalent SQLite-backed CRUD APIs implemented in Go 1.26/net/http, Rust 1.95/Axum, Python 3.13/FastAPI+Granian, Node.js 24/Fastify, and .NET 10 Native AOT across N=50 randomized runs per stack and endpoint, with a separate concurrency sweep and memory time-series collection. Rust achieved the highest weighted throughput-to-RAM ratio (310.25 req/s/MB, 2.8x Go) because its weighted peak RSS was 7.36 MB, while .NET, Node.js, Go, and Rust formed a raw-throughput cluster with overlapping bootstrap CIs (2,125--2,461 req/s) and Python remained below that cluster at 969 req/s. The concurrency sweep on GET /items/:id showed divergent scaling: .NET reached 26,209 req/s at c=240, Go and Rust plateaued near c=120, Node.js saturated near 9,700 req/s, and Python stayed below 2,300 req/s; memory snapshots showed Rust holding a flat 7.8 MB RSS while Node.js grew by 117 MB without visible GC drops. For RAM-constrained self-hosted CRUD-over-SQLite deployments on this Pi 5 unit, the data support Rust as the most resource-efficient measured stack, .NET as the strongest high-concurrency stack, and Go as a practical option where ecosystem breadth matters; replication is needed before extending these findings to other devices or storage backends.

Explore related subjects

Keep this discovery

Explore connections, maps & timelines

BibTeXRIS

William Oliveira. 2026-05-23. Throughput per Megabyte: A Pilot Benchmark of Language-Stack Efficiency for Self-Hosted HTTP Services on a Raspberry Pi 5. https://searcharxiv.com/abs/2609.11932

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↗