Fatigue-Driven Competition for Fuzzing Energy

A fuzzer (a tool that tests programs by feeding them many mutated inputs and watching for crashes) has to decide where to spend its execution budget. Recent work shows that weighting code by how likely it is to hold a bug beats treating all new coverage as equal. The catch is a dilemma that no current scheduler resolves. If you commit hard to the top-ranked risky functions, you get nothing when the real bug sits just below your cutoff, or when your top pick sits behind a checksum the fuzzer cannot pass. If you spread effort smoothly over every function, you dilute the focus that made the ranking useful.

Brains face the same problem when choosing between actions. Neural circuits handle it with winner-take-all competition: options inhibit each other until one dominates. They also add adaptation, in which a winner that keeps firing without payoff tires, and the runner-up gets released. This note proposes a seed scheduler built on that idea. Candidate target functions compete for energy through shared inhibition. Each target's pull comes from its static risk score multiplied by its observed progress. Each target also accumulates fatigue while it absorbs energy without progress, so a stalled winner hands control to the next candidate on its own. The question is whether this specific dynamic, competition plus fatigue, earns its keep over a well-tuned softmax or a bandit. The experiments are designed to answer that, including the possibility that it does not.

Core Claim

The claim is that importance-aware fuzzers fail in two predictable ways, and that one added state variable addresses both. The first failure is reachability: energy is poured into a high-risk target that the fuzzer cannot reach. The second is the threshold: the bug is ranked just outside the focus set. The added state is per-target fatigue that grows with unrewarded energy, placed inside a competition with global inhibition.

The system competes over code targets, not seeds. A seed's energy is the activation of the targets it makes progress toward. Two consequences follow. Seeds that chase the same target suppress each other automatically, because they draw on one activation. And when a dominant target stalls, its fatigue lowers its activation and releases suppressed competitors in rank order. That release is the continuous fallback that hard top-k cutoffs lack.

This differs from the closest work in specific ways:

Mechanism

Static risk scores. Let $s_j$ be the static risk of candidate target function $j$. It is computed with the binning-and-ranking scheme of LEOPARD: Identifying Vulnerable Code for Vulnerability Assessment through Program Metrics and combined with TortoiseFuzz-style counts of memory operations and loop back-edges.

Why this score source. We use LEOPARD-style metrics because SoK: Where to Fuzz? Assessing Target Selection Methods in Directed Fuzzing finds that simple complexity metrics match or beat learned models at locating crash sites. That finding constrains the design: no learned risk model. The same SoK reports that continuous scoring beats discrete cutoffs offline. It explicitly leaves open how target selection should interact with power scheduling, which is the gap this work fills.

Progress signal. Let $r_j(t)$ be a recent progress rate for target $j$: new edges discovered within its call-graph neighborhood, or reductions in seed distance to it, measured over a sliding window.

Activation dynamics. Each target's activation $a_j$ evolves as

$$\tau \frac{da_j}{dt} = -a_j + \sigma\Big(s_j\, r_j - g(t)\sum_k a_k - h_j\Big), \qquad \tau_h \frac{dh_j}{dt} = -h_j + \kappa\, e_j\,(1 - r_j).$$

The terms are:

  • $\sigma$ is a sigmoid.
  • $g(t)$ is the strength of global inhibition.
  • $h_j$ is the fatigue of target $j$.
  • $e_j$ is the share of energy currently going to target $j$.
  • $\kappa$ sets how fast fatigue builds.
  • $\tau$ and $\tau_h$ are the time constants of activation and fatigue, with $\tau_h \gg \tau$.

Where each piece comes from. The global-inhibition form follows the shared-inhibitory-pool motif in Modeling the Olfactory Bulb - Coupled Nonlinear Oscillators. It costs time linear in the number of targets, not quadratic. The fatigue term is the software analogue of the threshold adaptation that Threshold Adaptation in Spiking Networks Enables Shortest Path Finding and Place Disambiguation uses to move a network off a settled state.

State-dependent sharpness. The inhibition strength $g(t)$ rises as global coverage growth stalls. Early in a campaign competition is soft, so many targets share energy. Late in a campaign, when new coverage is scarce, competition sharpens toward a winner. This mirrors a result in Feeding state-dependent neuropeptidergic modulation of reciprocally interconnected inhibitory neurons biases sensorimotor decisions in Drosophila, where hunger shifts the balance of a reciprocal-inhibition switch without changing sensory input. We use that paper only as motivation. Nothing in the method depends on biological fidelity.

Known risk of winner-take-all. Strong winner-take-all dynamics tend to lock onto one option. We treat this as a known hazard, and fatigue is the specific remedy we test against it.

Research Program

The work has four parts.

  1. Implementation. We build the scheduler as a drop-in seed-selection and power-schedule module for an AFL-family fuzzer. The dynamics are updated once per scheduling round, so overhead is a single pass over the candidate targets.
  2. Target set. Candidate targets are the top fraction of functions by $s_j$. We vary that fraction, because an advantage that appears only at one setting would be suspicious.
  3. Analysis of the dynamics. We log $a_j$, $h_j$ and per-target energy over time. For every found bug, this lets us reconstruct whether its function won energy directly or was released after a higher-ranked target fatigued.
  4. Characterizing failure cases. We measure where the method breaks down: on targets with grammar-heavy inputs (the barrier that MooFuzz itself acknowledges), and on bugs in low-complexity code that static metrics underrate.

Baselines

Naive reference. The reference point is the stock AFL-family schedule on the same fuzzer core. MooFuzz reports finding 46% more crashes than AFL on its seven-program suite, which gives a sense of the room for improvement.

Strongest existing scheduler. This is T-Scheduler, run from its released configuration on FuzzBench and Magma. Its paper reports outperforming eleven schedulers on 80% of bug-finding metrics and the highest coverage on 13 of 19 FuzzBench targets. The file gives no per-target Magma bug counts, so there is no reported result on Lacuna for T-Scheduler's absolute Magma bug numbers, and we will regenerate them ourselves.

Because our method uses static risk and T-Scheduler does not, we also run a strengthened variant, T-Scheduler with importance-weighted reward. Here a seed's Bernoulli reward is weighted by the $s_j$ of newly covered targets. This separates the effect of the competition dynamics from the effect of simply having risk scores.

Other existing schedulers. MooFuzz is run on its own seven-application suite, where it reports 32–153% more crashes than AFLFast, FairFuzz and PerfFuzz. TortoiseFuzz-style static accounting is the importance-only reference.

Ablations. Three ablations isolate the proposal's ingredients:

  • the dynamics with fatigue removed ($\kappa = 0$);
  • the dynamics with fixed $g$ (no state-dependent sharpness);
  • a top-k directed schedule that gives energy only to the top-k targets.

Fairness. All arms share the same fuzzer core, the same seed corpora, and the same instrumentation. Each has an equal tuning budget of the same number of short pilot campaigns on held-out targets. Runs last 24 hours, with at least ten repetitions per program. We report Mann-Whitney tests and Vargha-Delaney $A_{12}$ effect sizes as UNIFUZZ recommends.

What counts as beating. We count it a win if the method finds significantly more unique Magma bugs, or finds the same bugs earlier, than importance-weighted T-Scheduler, on a majority of targets, with $A_{12}$ above 0.6. Coverage that is merely higher does not count.

Why not just…?

Why not just use a softmax over risk times yield, with temperature annealed by coverage stagnation? This is the most serious threat. It reproduces state-dependent sharpness and continuous allocation without any dynamics. What it lacks is memory of stalled winners. A high-$s_j$ target with zero progress keeps a nonzero share indefinitely, and nothing explicitly releases the runner-up. We include this softmax as a baseline under the identical tuning budget.

If it matches the full method on bug finding and on the decisive checks below, we will conclude that fatigue is unnecessary and report the simpler scheduler as the finding. We will not argue for the dynamics in that case.

Why not just add importance weights to a bandit? A discounted bandit already forgets stale reward, so it partly mimics fatigue. Its arms, however, are seeds, and seeds that share a target do not suppress one another. This is the redundancy that the target-level coupling is meant to remove. The importance-weighted T-Scheduler arm tests this directly. As a secondary metric, we measure the fraction of executions spent on seeds whose coverage overlaps another active seed's by more than 90%.

Why not just use MooFuzz-style energy recovery, or rotate top-k targets periodically? Both are cheap ways to escape a stalled target. Recovery acts once per seed, after most of its budget is already spent. Rotation ignores rank, so after a stall it is as likely to jump to a weak target as to the near-miss one. The energy wasted before abandonment, as defined below, compares these directly.

Decisive Checks

Threshold check. Using Leopard-V ranks recomputed on Magma and FuzzBench programs, we split ground-truth bugs into three groups by where the static ranking places their function: inside the top-k focus set, just outside it (ranks k+1 to 2k), and far below it. The SoK reports that Leopard-V ranks the crashing function first in 13% of its 1,621 OSS-Fuzz crashes. Near-misses are therefore common, not edge cases.

The proposal predicts a specific pattern:

  • On in-set bugs, the method matches top-k directed fuzzing.
  • On near-miss bugs, it clearly beats top-k.
  • Both effects disappear when fatigue is ablated.

Reachability check. Using Magma programs whose high-risk functions sit behind magic-value or checksum guards, we measure the energy wasted before abandonment. This is the share of executions given to a target between its last progress event and the moment its energy share drops below 5%. We compare this across the full method, the annealed softmax, MooFuzz recovery and top-k.

Supporting replications. On the MooFuzz seven-program suite and the UNIFUZZ real-world programs, we rerun the main comparison to confirm that gains are not an artifact of one benchmark. UNIFUZZ found that no single fuzzer wins everywhere, so we expect, and will report, programs where the method loses.

Failure modes. We report results separately for grammar-heavy targets such as LibSass, where we expect little benefit because no target makes progress for any scheduler. Such a case would mark a limit of importance-aware allocation in general, not of this method specifically.