Slack-Gated DVFS: Making Enclave Federated Learning Energy-Cheap Without Opening the Throttling Side Channel

Federated learning trains a shared model across phones and hospitals without collecting their raw data, but it pays for privacy with relentless communication: every round, every client ships model updates over slow wireless links. A popular fix is to send only the largest gradient coordinates ("Top-k sparsification"). A second fix is to do the sensitive aggregation inside a trusted execution environment (TEE) — a hardware-enforced locked region of the processor that even the cloud operator cannot read. But these two fixes collide: inside a TEE, the memory addresses touched by sparse updates leak which coordinates were kept, and an observer of those addresses can recover private training labels with over 90% accuracy Olive. The known repair — oblivious aggregation, which touches memory in a fixed data-independent order — works, but it burns far more processor cycles, heat, and power. And that creates a third problem: when a processor runs hot, its power-management hardware silently lowers its clock speed, and those speed changes are themselves a leak — attackers have extracted AES keys from inside Intel SGX enclaves purely by watching throttling-induced timing Frequency Throttling Side-Channel Attack.

This proposal argues that dynamic voltage and frequency scaling (DVFS) — the hardware mechanism that adjusts processor speed and voltage at runtime, with power dropping roughly as $V^2 f$ — is not merely the threat here but also the remedy. In enclave-based federated learning, large fractions of every round are slack: clients idle waiting for layer aggregation, world-switches between secure and untrusted code, encrypted memory paging, and network waits. We propose a governor that drops frequency aggressively in exactly those windows and pins it flat during data-dependent computation, so the processor's speed trajectory depends only on the training protocol's schedule and never on anyone's data.

Core Claim

The claim has two halves. First, an energy claim: a DVFS governor keyed to the phase structure of enclave federated training can reclaim most of the roughly 21% client-energy overhead that TEE execution currently costs, at negligible cost in round time or model accuracy. Second, a security claim: because the governor changes frequency only in phases whose duration and instruction stream are already data-independent (network waits, oblivious passes, memory stalls), the observable timing channel that Frequency Throttling Side-Channel Attack exploits carries no information about client data — the defense falls out of the same mechanism as the savings.

Formally, the design target for one federated round is:

$$E_{\text{round}} = \sum_{\phi \in \text{phases}} P(f_\phi)\, t_\phi, \qquad P(f) \propto V(f)^2 f,$$

where the governor assigns each protocol phase $\phi$ a frequency $f_\phi$ from a small set of discrete states (3–4 states capture nearly all attainable savings, per A Survey of Techniques For Improving Energy Efficiency in Embedded Computing Systems). The security invariant is that the sequence $\{(f_\phi, t_\phi)\}$ an outsider can measure is a deterministic function of the published training schedule, independent of every client's data.

Background and Positioning

Three literatures meet here and none crosses the line. The DVFS community has shown, in high-performance computing, that communication and synchronization phases create predictable slack: throttling cores to minimum frequency during MPI collectives saves power without slowing the application Modeling and Evaluation of Application-Aware Dynamic Thermal Control in HPC Nodes, a result replicated on RISC-V clusters RISC-V-Based Platforms for HPC: Analyzing Non-functional Properties for Future HPC and Big-Data Clusters and generalized to thread-contention and memory-stall slack Memory and thread synchronization contention-aware DVFS for HPC systems. Crucially, memory-bound phases are free wins: when the core stalls waiting on off-chip memory, lowering its frequency costs nothing, a point both Mittal surveys establish A Survey of Techniques For Improving Energy Efficiency in Embedded Computing Systems, A Survey of Methods For Analyzing and Improving GPU Energy Efficiency. None of this work considers secure enclaves, encrypted memory paging, or the possibility that frequency changes leak secrets.

The TEE-for-federated-learning line builds the systems we would govern but runs them at fixed clocks. PPFL trains models layer-by-layer inside Arm TrustZone clients and SGX servers, measuring a 15% CPU-time, 18% memory, and 21% energy cost for enclave execution — under default, static frequencies PPFL: Privacy-preserving Federated Learning with Trusted Execution Environments. DarkneTZ partitions networks between trusted and untrusted worlds on edge devices, again at fixed clocks DarkneTZ: Towards Model Privacy at the Edge using Trusted Execution Environments. Marshaled Learning splits large models across memory-constrained enclaves and mitigates stragglers by routing around them — discarding their work and 3–4% of accuracy Marshaled Learning: Bridging Large Neural Networks with Memory-Constrained Trusted Execution Environments in Federated Learning. SEAR optimizes enclave memory layouts so that Byzantine-robust aggregation of 1,000 clients finishes in 4–7 seconds, but never asks what that computation costs in power or heat SEAR: Secure and Efficient Aggregation for Byzantine-Robust Federated Learning.

The closest existing work to ours is OLIVE, which demonstrates the label-leakage attack on sparsified updates in SGX and answers it with oblivious sorting and folding aggregation, running up to 10x faster than PathORAM-based alternatives Olive: Oblivious Federated Learning on Trusted Execution Environment Against the Risk of Sparsification. OLIVE measures runtime, not power, and its oblivious passes inflate instruction counts — precisely the kind of sustained, uniform compute that provokes reactive throttling, the attack vector of Frequency Throttling Side-Channel Attack, which was evaluated only on standalone constant-cycle AES and left defensive design explicitly open. We differ from OLIVE by treating its oblivious aggregation as a workload to be power-managed safely rather than a finished artifact, and we differ from the HPC DVFS line by making data-independence of the frequency trajectory a hard constraint rather than an afterthought.

Research Program

We will build three things. First, a phase profiler for enclave federated training that instruments an PPFL-style layer-wise client pipeline and an OLIVE-style oblivious server aggregation, labeling every interval as one of: data-dependent compute, network wait, world-switch, EPC/secure-memory paging stall, or oblivious fixed-trace pass. The profiler outputs the expected duration and variance of each slack class, which determines both the energy opportunity and whether a frequency transition pays off (transitions have microsecond-to-millisecond costs and a break-even threshold below which switching loses energy, per A Survey of Techniques For Improving Energy Efficiency in Embedded Computing Systems).

Second, the governor itself: a small controller, running in the untrusted world, that reads the phase labels published by the enclave runtime and drives 3–4 discrete frequency states. During data-dependent phases the governor pins frequency and disables turbo/boost so the hardware power-management unit never has occasion to throttle data-dependently; during certified slack it drops to the minimum state. The design question we expect to be genuinely hard is the boundary case: memory stalls during data-dependent code, where scaling down is energy-free but stall lengths are data-dependent. We will quantify how much timing information stall-duration variance actually carries for federated workloads, and if it is non-negligible, restrict scaling to stalls inside oblivious passes, where the trace is fixed by construction.

Third, an extended analysis connecting the governor to the straggler problem: rather than dropping slow clients as Marshaled Learning does, the server can assign a lagging client a lighter compression ratio (following the flexible Top-k formulation of To Talk or to Work: Flexible Communication Compression for Energy Efficient Federated Learning over Heterogeneous Mobile Edge Devices) while the client raises its compute frequency — trading "talk" for "work" using the TEE's real energy profile instead of that paper's static, unencrypted GPU cost model.

Baselines

The do-nothing reference is the existing enclave federated pipeline under the default OS governor at stock frequencies: PPFL reports that layer-wise TrustZone training already costs up to ~15% more CPU time and ~21% more client energy than plaintext training PPFL: Privacy-preserving Federated Learning with Trusted Execution Environments, so this baseline sets the energy headroom we aim to reclaim; any governor that does not beat it on joules per round is not worth deploying. The strongest existing competitor on the security question is OLIVE's oblivious aggregation, which defends the memory-pattern leak and runs up to 10x faster than PathORAM while finishing million-parameter aggregation in seconds Olive: Oblivious Federated Learning on Trusted Execution Environment Against the Risk of Sparsification; we run it unchanged on identical hardware as both the obliviousness target to match (attacker label-inference accuracy no better than chance) and the workload whose energy we reduce. On the energy question the strongest competitor is a straight port of the MPI-style communication-slack governor of Modeling and Evaluation of Application-Aware Dynamic Thermal Control in HPC Nodes, scaled during every communication and synchronization window without any data-independence gating; it may match our energy savings, and the point of comparing against it is to show it leaks where we do not. We also run two cheaper references: a static minimum-frequency clamp, and a race-to-sleep policy that sprints then enters deep idle. All baselines get the same datasets, the same models, the same number of rounds, the same tuning budget (a grid over the same 3–4 frequency states), and the same power instrumentation; beating the default governor means at least a 15% reduction in client joules per round at under 5% extra round time and no accuracy loss; beating the naive slack governor means indistinguishable timing under the throttling-attacker model; beating OLIVE means matching its defense at strictly lower aggregation energy. The key ablation is our own governor with the data-independence gate removed — slack-aware DVFS everywhere — which isolates exactly the ingredient (gated, not greedy, scaling) that the proposal is built on.

Why not just…?

Why not just clamp the CPU to a static low frequency? This is the simplest defense against the throttling side channel, and its cost is documented: the authors of the throttling attack themselves evaluate it and report a prohibitive performance penalty Frequency Throttling Side-Channel Attack, and it stacks onto a pipeline that already carries 10–15% TEE overhead DarkneTZ, PPFL. Our experiments include this clamp as a baseline precisely so the energy-versus-latency frontier of static and gated scaling can be plotted on the same hardware; if the clamp turns out to dominate on both axes, the proposal is wrong and the data will say so.

Why not just port the existing HPC communication-slack governors? This is the most serious objection, because the mechanism is proven Cesarini et al., Green computing and communications. The difference is that those governors assume trusted execution and uniform cluster nodes: they scale during synchronization without checking whether the scaled or throttled phases carry data-dependent timing, and they know nothing of encrypted-memory paging stalls or world-switch latencies specific to enclaves. The head-to-head experiment against a ported MPI governor, run under the RDTSC-based attacker model of Frequency Throttling Side-Channel Attack, is designed to settle this: if the ported governor's timing trace turns out to carry no usable signal on real federated workloads, our security contribution shrinks to an energy engineering exercise, and we will report that honestly.

Why not just drop the stragglers, as Marshaled Learning does? Marshaled Learning's greedy bypass buys up to a 2.78x speedup but pays 3–4% accuracy, because discarded clients hold non-IID data the global model needs Marshaled Learning. Our frequency-plus-compression rebalancing targets the same stragglers without discarding them; the decisive comparison is accuracy under Dirichlet $\beta=0.5$ skew at matched round deadlines, where recovering that 3–4% while holding energy constant would favor us.

Why not just abandon TEEs for pure cryptography? Homomorphic encryption is 120x slower than enclave execution for comparable analytics PRESAGE, and cryptographic secure aggregation runs 4–6x slower than SEAR's enclave aggregation SEAR, so this alternative concedes the performance regime entirely; it is not a competitor on any metric we optimize.

Why not just race to sleep instead of scaling frequency? Sleep states have a break-even duration, and layer-wise enclave training generates idle windows at microsecond-to-millisecond granularity — too short to amortize wake costs — while sprinting at peak frequency maximizes the thermal spikes that trigger reactive throttling A Survey of Techniques For Improving Energy Efficiency in Embedded Computing Systems. We include it as a baseline to confirm this on our workload rather than assert it.

Proposed Experiments

The testbed pairs an SGX-class server enclave (for OLIVE-style and SEAR-style aggregation) with Arm TrustZone/OP-TEE edge clients, with power measured by onboard energy telemetry and an external power monitor. Workloads follow the file's established settings: CIFAR-10 and CIFAR-100 under Dirichlet $\beta=0.5$ with ResNet and small ViT backbones (matching Marshaled Learning and OLIVE), MNIST/LeNet for the TrustZone clients (matching PPFL), and FEMNIST and Shakespeare from the LEAF framework for realistic cross-device heterogeneity LEAF: A Benchmark for Federated Settings.

Four checks decide the proposal. The energy check measures joules per round across all baselines; success means reclaiming at least 15 of the 21 percentage points of TEE energy overhead that PPFL reports, without slowing rounds by more than 5% or moving accuracy. The convergence check verifies that compression ratios interact safely with non-IID skew, since aggressive compression is known to amplify drift under heterogeneous data Enhancing Communication Compression via Discrepancy-aware Calibration for Federated Learning. The memory-privacy check replays OLIVE's gradient-index inference attack on our aggregation: OLIVE reports over 90% label-inference accuracy on CIFAR-100 at top-1.25% sparsification against non-oblivious baselines, and our pipeline must hold the attacker near chance. The timing-privacy check is the decisive one: we apply the methodology of Frequency Throttling Side-Channel Attack — RDTSC timing across data-dependent executions — to the oblivious aggregation workload under each governor. That attack recovered 14 of 16 AES key bytes inside SGX, so it is a proven, strong adversary; success for us means its classifier degrades to chance on the gated governor while remaining effective on the ungated ablation. If the ungated governor turns out to be just as safe, the gating ingredient is unnecessary and the proposal should collapse into a simpler systems paper — the ablation exists to let the data make that call.