Skip to main content
Modules / Tools / Fault injection campaign sizer

Fault injection campaign sizer

Size a fault injection campaign: injections needed for a diagnostic coverage estimate at a confidence, simulation time, licences and calendar time.

Safety and securityFree to useHow it worksSourcesWhere it helps

Fills the inputs below with typical figures. Replace any of them with your own.

Fault list

The population the sample is drawn from. Count each fault model, or enter the size you already have from your fault simulator.

Each net carries a stuck-at-0 and a stuck-at-1 fault.

For a memory, enter the stored bits including the check bits.

Distinct clock cycles of the workload at which a flip can land.

Bridging, delay, multi-bit or any model counted elsewhere.

Structurally safe, unreachable or equivalent faults.

Statistics

Margin of error, confidence and the proportion you assume set the sample size.

Half-width of the interval around the measured coverage.

Worst case needs the most runs. A prior estimate needs fewer but trusts the estimate.

Used as p when chosen, and for the interval and the exact view.

These runs do not count toward coverage but still cost time.

Enter the runs you can afford to see the margin they buy. Leave 0 to skip.

Simulation time

Below 100 when runs stop early once the checker fires or the fault is masked.

Checkpoint restore, fault insertion and result comparison.

Resources

24 for a farm that runs overnight.

Testbench, golden run, fault list generation.

Exact view: prove a coverage target

The injections needed so the lower confidence limit on coverage reaches the target, if coverage turns out as expected above.

Injections to run
9,600
0.047% of 20,400,000 faults, t = 1.960, p = 0.5
Runs including masked faults
9,600
None expected to be masked
Compute time
320 h
2 min a run
Calendar time
1.3 days
1.3 days running plus 0 days set-up
Coverage you can quote
98.80% to 99.20%
Normal interval around 99.00%. Exact (Clopper-Pearson): 98.78% to 99.19%
Injections to prove at least 97.00% (exact)
216
7 compute hours, 0.0 calendar days
Injections needed against margin of error
Line chart of Injections against Margin of error (percentage points), 3 lines: 90% confidence, 95% confidence, 99% confidence. The same numbers are in the table under the chart.0100,000200,000246810Margin of error (percentage points)Injections
  • 90% confidence (solid line, circles)
  • 95% confidence (dashed line, squares)
  • 99% confidence (dotted line, triangles)
Show the data as a table
Injections needed against margin of error
Margin of error (percentage points)90% confidence95% confidence99% confidence
0.25107,651152,510261,988
0.527,02038,34366,134
16,7629,60016,574
21,6912,4014,146
37521,0681,843
5271385664
7.5121171295
106897166

Sign in to save your inputs and come back to them later.

Sample by fault model
Fault modelFaultsAfter pruningSample if sampled aloneInjections in this planCompute hours
Stuck-at-0200,000200,0009,164953.167
Stuck-at-1200,000200,0009,164953.167
Transient bit flip20,000,00020,000,0009,6009,412313.7
Total20,400,00020,400,00027,9289,600320
Injections needed to prove the coverage target, by the coverage you actually have
Coverage you actually haveInjections (exact)Compute hours
100.00%993.3
99.70%1214.033
99.25%1725.733
98.50%37712.57
97.75%1,45748.57

How it works

A fault injection campaign shows what share of dangerous faults a safety mechanism catches, which feeds the diagnostic coverage in the hardware metrics. Injecting every fault is rarely affordable, so the campaign draws a random sample and states a margin of error. This tool sizes that sample, prices it in compute hours and calendar days, and shows the interval you can quote afterwards.

  1. Build the fault list. Each fault model contributes sites. A stuck-at fault can sit on every net at value 0 or 1. A transient bit flip can hit every flip-flop or storage bit at any of the injection times you choose across the workload. Faults proved safe or equivalent by static analysis come off the list. Other fault models (bridging, delay, multi-bit) are added as entered counts.N = (nets + nets + flip-flops x injection times) x (1 − pruned share) + other faults
  2. Choose the confidence factor. The confidence level fixes a cut-off t on the standard normal curve, taken two-sided. 90% gives 1.645, 95% gives 1.960 and 99% gives 2.576.t = z(1 − (1 − confidence) / 2)
  3. Size the sample. Leveugle and co-workers size a random sample of a finite fault list. e is the margin of error you accept on the measured proportion and p is the proportion you expect. The value p = 0.5 is the worst case and needs the most runs. A prior estimate of coverage, say 0.99, needs far fewer but is only safe if the estimate is good. For a very large list the result tends to t^2 p (1 − p) / e^2, the textbook sample size for a proportion.n = N / (1 + e^2 (N − 1) / (t^2 p (1 − p)))
  4. Allow for masked faults. Coverage is measured over faults that could cause a dangerous effect. Faults that turn out safe or masked do not count, so they must be injected too. If a share s of injections is safe, the runs needed rise.runs = n / (1 − s)
  5. Compute hours and calendar days. The run time is either entered in minutes or worked out from the cycles per run and the simulator speed. Early termination, where a run stops once the checker fires or the fault is masked, shortens the average run; a fixed overhead per run covers checkpoint restore and result comparison. Machines or licences work in parallel, and the days add the set-up time before the first injection.run minutes = base minutes x simulated share + overhead; compute hours = runs x run minutes / 60; calendar days = set-up days + compute hours / (machines x hours per day)
  6. Read the margin a budget buys. If the schedule fixes the number of runs, solve the sample size formula for e. At the worst case p = 0.5 this is the largest margin you will see.e = t x sqrt(p (1 − p) (N − n) / (n (N − 1)))
  7. Quote the coverage. After the campaign, the measured coverage is the detected count over the counted injections. The sizing formula gives a normal interval around it; the Clopper-Pearson interval is the exact binomial one and is a little wider. Both are shown for the coverage you expect.coverage = detected / n; normal interval = coverage ± t x sqrt(coverage (1 − coverage) / n x (N − n) / (N − 1))
  8. The exact view: prove a target. To claim that coverage is at least a target, the one-sided lower Clopper-Pearson limit must reach it. For an expected coverage c, the tool finds the fewest injections n for which that limit, with n x c detections, is at or above the target. When no escape is expected, the answer is the success-run count.lower limit = Beta quantile (alpha; k, n − k + 1) with k = n x c; no escapes: n = ln(alpha) / ln(target)

Assumptions

  • The sample is drawn at random, without replacement, from the whole fault list; a hand-picked set of faults has no stated margin.
  • Each injection gives one outcome, detected or not detected, and the outcomes are independent.
  • The normal approximation behind the sizing formula is good while n p and n (1 − p) are both above about 10.
  • Run time is the same for every fault, apart from the early termination share you enter.
  • The exact view treats the fault list as very large; for a small list, sampling without replacement makes the true interval a little narrower, so the result is on the safe side.

Limits and warnings

  • A coverage figure from sampling is only as good as the fault list. Missing fault models, or workloads that never exercise a block, bias the result and no margin of error covers that.
  • Equal weighting of faults is assumed. Safety standards weight failure modes by failure rate, so a coverage claim may need a stratified sample, one stratum per failure mode (use the sampling-per-model option).
  • Statistical sampling gives coverage for the fault models you inject. It does not replace formal or structural analysis for faults that need proof.
  • Compute time ignores licence queues, failed runs and re-runs. Treat the calendar days as an estimate and add contingency.
  • The default figures in the presets are editorial examples. Replace them with numbers from your own netlist, workload and simulator.

Sources

The methods and default figures rest on these public sources. The wording here is our own; read the source for its full text.

  • Statistical fault injection: Quantified error and confidence (opens in a new tab), R. Leveugle, A. Calvez, P. Maistri and P. Vanhauwaert, Design, Automation and Test in Europe (DATE), IEEE, pages 502 to 506, April 2009. The finite-population sample size for a fault list, with the margin of error, confidence and assumed proportion used here.
  • ISO 26262-11:2018, Road vehicles, Functional safety, Part 11: Guidelines on application of ISO 26262 to semiconductors, International Organization for Standardization, December 2018. Clause 4.8 Fault injection (characteristics or variables of fault injection, fault injection results), clause 5.1.2 and 5.1.3 fault models of digital components and memories, and clause 5.1.10 verification using fault injection simulation. Cited by name and clause only.
  • ISO 26262-5:2018, Road vehicles, Functional safety, Part 5: Product development at the hardware level, International Organization for Standardization, December 2018. Clause 8 evaluation of the hardware architectural metrics (single-point and latent fault metrics) and Annex D evaluation of diagnostic coverage. Cited by name and clause only.
  • The use of confidence or fiducial limits illustrated in the case of the binomial (opens in a new tab), C. J. Clopper and E. S. Pearson, Biometrika, volume 26, issue 4, pages 404 to 413 (Oxford University Press), 1934. The exact binomial limits used in the interval and in the exact view.

Where it helps

The lifecycle stages this tool serves: 4 stages in 3 lifecycles.

Method notev1Formula, ranges, sources and limits

Sizes a statistical fault injection campaign from the fault list, the margin of error, the confidence and the assumed coverage, then prices it in compute hours and calendar days and gives the exact injections needed to prove a coverage target.

Formula

N = (nets + nets + flip-flops x injection times) x (1 − pruned share) + other faults; t = z(1 − (1 − confidence) / 2); n = N / (1 + e^2 (N − 1) / (t^2 p (1 − p))); runs = n / (1 − s); run minutes = base minutes x simulated share + overhead; compute hours = runs x run minutes / 60; calendar days = set-up days + compute hours / (machines x hours per day); e = t x sqrt(p (1 − p) (N − n) / (n (N − 1))); coverage = detected / n; normal interval = coverage ± t x sqrt(coverage (1 − coverage) / n x (N − n) / (N − 1)); lower limit = Beta quantile (alpha; k, n − k + 1) with k = n x c; no escapes: n = ln(alpha) / ln(target)

Inputs
InputUnitRange it holds forComes from
Fault list sourcechoicederive, enterYour figure
Nets for stuck-at faultsnetsfrom 0Your figure
Flip-flops or storage bitsbitsfrom 0Your figure
Injection times per flip-floptimesfrom 0Your figure
Other faults enteredfaultsfrom 0Your figure
Include stuck-at-0choiceyes, noYour figure
Include stuck-at-1choiceyes, noYour figure
Include transient bit flipschoiceyes, noYour figure
Fault list size as enteredfaultsfrom 0Your figure
Faults removed by static analysis%0 to 95Your figure
Margin of error% points0.01 to 50Your figure
Confidence%50 to 99.99Your figure
Assumed proportionchoiceworst, expectedYour figure
Expected diagnostic coverage%0 to 100Your figure
Injections expected to be safe or masked%0 to 95Your figure
Budget of runs, 0 for nonerunsfrom 0Your figure
Run time given aschoiceminutes, cyclesYour figure
Minutes per runminfrom 0Your figure
Cycles per runcyclesfrom 0Your figure
Simulator speedcycles per secondfrom 0Your figure
Share of each run simulated%0 to 100Your figure
Overhead per runminfrom 0Your figure
Machines or licences in parallelcountfrom 1Your figure
Productive hours per dayh0.1 to 24Your figure
Set-up days before the first rundaysfrom 0Your figure
Sampling scopechoicewhole, eachYour figure
Coverage target to prove%0 to 99.9999Your figure
Confidence for the exact view%50 to 99.99Your figure

Outputs: Fault list size (faults); Counted injections (faults); Runs including masked faults (runs); Compute time (h); Calendar time (days); Injections to prove the target (exact) (faults).

Assumptions

  • The sample is drawn at random, without replacement, from the whole fault list; a hand-picked set of faults has no stated margin.
  • Each injection gives one outcome, detected or not detected, and the outcomes are independent.
  • The normal approximation behind the sizing formula is good while n p and n (1 − p) are both above about 10.
  • Run time is the same for every fault, apart from the early termination share you enter.
  • The exact view treats the fault list as very large; for a small list, sampling without replacement makes the true interval a little narrower, so the result is on the safe side.

Uncertainty: The sample size formula is exact algebra; its statistical meaning rests on random sampling, independent outcomes and a good fault list. Times are as good as the run time entered.

Known limits

  • A coverage figure from sampling is only as good as the fault list. Missing fault models, or workloads that never exercise a block, bias the result and no margin of error covers that.
  • Equal weighting of faults is assumed. Safety standards weight failure modes by failure rate, so a coverage claim may need a stratified sample, one stratum per failure mode (use the sampling-per-model option).
  • Statistical sampling gives coverage for the fault models you inject. It does not replace formal or structural analysis for faults that need proof.
  • Compute time ignores licence queues, failed runs and re-runs. Treat the calendar days as an estimate and add contingency.
  • The default figures in the presets are editorial examples. Replace them with numbers from your own netlist, workload and simulator.

Where the method comes from

Follows Leveugle, Calvez, Maistri and Vanhauwaert, Statistical fault injection: Quantified error and confidence (DATE 2009) (opens in a new tab). The platform's version departs from it as follows.

  • Adds the exact Clopper-Pearson view for proving a coverage target Why: Practitioners claim a lower bound on coverage, which the normal approximation sample size does not give directly.
  • Adds masked-fault inflation, compute time, parallel licences and calendar days Why: A campaign is planned in days and licences, not only in a count of faults.

Reference example, checked by test: Worked example in this method note: a list of 1,000,000 faults, margin of error 1 point, confidence 95% (t = 1.95996), worst case p = 0.5, 2 minutes a run on 10 machines for 24 hours a day. The sample size follows from the formula by hand: 1,000,000 / (1 + 0.0001 x 999,999 / 0.96036) = 9,512.1, rounded up to 9,513. The large-list limit is the textbook 9,604. Fault list size 1,000,000; Counted injections 9,513; Runs including masked faults 9,513; Compute time 317.1; Calendar time 1.321.

Versions

  • v1 (2026-10-25): First version, built from the tool idea.

All models in the register

Terms on this page

Fault injection testing
Deliberately introducing errors, such as corrupted memory, stuck sensor values, bus failures or flipped bits, to verify that detection and safe-state mechanisms work.
Diagnostic coverage
The percentage of a part's dangerous failure rate that a given safety mechanism detects or controls in time.
Safety mechanism
A technical measure built into a design to detect, control or contain faults so that a safety goal is still met, such as error correcting codes, lockstep cores, watchdogs or voltage monitors.
Stuck-at fault
The canonical fault model in which a single node is permanently held at logic 0 or logic 1 regardless of what drives it.
SEU
A soft error in which one strike flips the state of a memory cell, flip-flop or latch.
Flip-flop
An edge-triggered storage element that captures its data input at a clock edge and holds it until the next edge, forming the basic register bit of synchronous digital design.
Static analysis
Automated inspection of source or binary code without executing it, to find defects such as null dereferences, overflows, data races and coding-standard violations.
Failure mode
The way in which a part or function fails, as seen from outside, such as an open, a short, a stuck output, a drift or a loss of function.
Netlist
A structural description of a circuit as a list of instances and the nets that connect their pins.

The full glossary

Need help acting on this?

Tell us what you're after and leave your email: we'll connect you with the right person on the Hub.