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.
- 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
- 90% confidence (solid line, circles)
- 95% confidence (dashed line, squares)
- 99% confidence (dotted line, triangles)
Show the data as a table
| Margin of error (percentage points) | 90% confidence | 95% confidence | 99% confidence |
|---|---|---|---|
| 0.25 | 107,651 | 152,510 | 261,988 |
| 0.5 | 27,020 | 38,343 | 66,134 |
| 1 | 6,762 | 9,600 | 16,574 |
| 2 | 1,691 | 2,401 | 4,146 |
| 3 | 752 | 1,068 | 1,843 |
| 5 | 271 | 385 | 664 |
| 7.5 | 121 | 171 | 295 |
| 10 | 68 | 97 | 166 |
Sign in to save your inputs and come back to them later.
| Fault model | Faults | After pruning | Sample if sampled alone | Injections in this plan | Compute hours |
|---|---|---|---|---|---|
| Stuck-at-0 | 200,000 | 200,000 | 9,164 | 95 | 3.167 |
| Stuck-at-1 | 200,000 | 200,000 | 9,164 | 95 | 3.167 |
| Transient bit flip | 20,000,000 | 20,000,000 | 9,600 | 9,412 | 313.7 |
| Total | 20,400,000 | 20,400,000 | 27,928 | 9,600 | 320 |
| Coverage you actually have | Injections (exact) | Compute hours |
|---|---|---|
| 100.00% | 99 | 3.3 |
| 99.70% | 121 | 4.033 |
| 99.25% | 172 | 5.733 |
| 98.50% | 377 | 12.57 |
| 97.75% | 1,457 | 48.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.
- 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 - 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) - 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))) - 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) - 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) - 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))) - 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)) - 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.
More safety and security tools
- Hardware safety metrics calculator
- Safety integrity level determination
- Fault tree calculator
- Safety function failure probability calculator
- Threat risk assessment calculator
- Vulnerability severity calculator
- Side-channel leakage assessment
- Software update impact assessment
- SBOM licence checker
- Development assurance objectives checklist
- Medical device classification helper
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)
| Input | Unit | Range it holds for | Comes from |
|---|---|---|---|
| Fault list source | choice | derive, enter | Your figure |
| Nets for stuck-at faults | nets | from 0 | Your figure |
| Flip-flops or storage bits | bits | from 0 | Your figure |
| Injection times per flip-flop | times | from 0 | Your figure |
| Other faults entered | faults | from 0 | Your figure |
| Include stuck-at-0 | choice | yes, no | Your figure |
| Include stuck-at-1 | choice | yes, no | Your figure |
| Include transient bit flips | choice | yes, no | Your figure |
| Fault list size as entered | faults | from 0 | Your figure |
| Faults removed by static analysis | % | 0 to 95 | Your figure |
| Margin of error | % points | 0.01 to 50 | Your figure |
| Confidence | % | 50 to 99.99 | Your figure |
| Assumed proportion | choice | worst, expected | Your figure |
| Expected diagnostic coverage | % | 0 to 100 | Your figure |
| Injections expected to be safe or masked | % | 0 to 95 | Your figure |
| Budget of runs, 0 for none | runs | from 0 | Your figure |
| Run time given as | choice | minutes, cycles | Your figure |
| Minutes per run | min | from 0 | Your figure |
| Cycles per run | cycles | from 0 | Your figure |
| Simulator speed | cycles per second | from 0 | Your figure |
| Share of each run simulated | % | 0 to 100 | Your figure |
| Overhead per run | min | from 0 | Your figure |
| Machines or licences in parallel | count | from 1 | Your figure |
| Productive hours per day | h | 0.1 to 24 | Your figure |
| Set-up days before the first run | days | from 0 | Your figure |
| Sampling scope | choice | whole, each | Your figure |
| Coverage target to prove | % | 0 to 99.9999 | Your figure |
| Confidence for the exact view | % | 50 to 99.99 | Your 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.
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.
Tell us what you're after and leave your email: we'll connect you with the right person on the Hub.