induwara.lk
induwara.lkAI · GPU efficiency

AI Model FLOPs Utilization (MFU) Calculator

Find out what fraction of your GPUs' peak compute an LLM training or inference run actually uses. Enter model size, measured tokens/second, GPU count and precision to get your MFU %, a rating, and a full breakdown. Uses the published 6N / 2N convention, runs in your browser, no signup.

By Induwara AshinsanaUpdated Jul 8, 2026
Model FLOPs UtilizationMFU %
Kaplan 2020 · PaLM 2022 (6N / 2N)

Total parameters, in billions. MoE: enter active params.

Measured tokens/second across all GPUs combined.

How many GPUs the run spans.

Dense (non-sparse) tensor-core peak, from NVIDIA datasheets.

NVIDIA H100 SXM peak at this precision: 989.5 TFLOP/s per GPU.

Presets
Model FLOPs Utilization
36.38%
0%Typical dense-training ceiling ≈ 40–55%100%
Typical

A common, healthy range for dense-transformer training on this class of hardware. Modest tuning may still help, but the run is not obviously broken.

Achieved compute
2,880 TFLOP/s
6N × throughput
Theoretical peak
7,916 TFLOP/s
8 × 989.5 TFLOP/s
FLOPs per token
48 GFLOP
6N (training)
Per-GPU throughput
7,500 tok/s
Total ÷ GPU count

How this was computed

F/token = 6N = 6 × 8e9 = 48 GFLOP
achieved = F/token × throughput = 48e9 × 60,000 = 2,880 TFLOP/s
peak = GPUs × per-GPU peak = 8 × 989.5 = 7,916 TFLOP/s
MFU = achieved ÷ peak = 2,880 ÷ 7,916 = 36.38%
per-GPU check: (7,500 tok/s × 6N) ÷ 989.5 TFLOP/s = 36.38%

This is MFU (model FLOPs), which excludes activation recomputation, so it is always ≤ HFU (hardware FLOPs) and is the fair cross-implementation metric.

FLOPs-per-token convention and MFU definition from the papers.

How it works

Model FLOPs Utilization answers one question: of all the arithmetic your GPUs coulddo per second, how much is your run actually doing useful model math with? It is the standard efficiency yardstick for large-language-model training, introduced in Google's PaLM paper (Chowdhery et al., 2022), which defines MFU as observed throughput relative to the theoretical maximum throughput of a system running at peak FLOPs.

The calculation is four deterministic steps, all shown in the breakdown above:

  1. FLOPs per token. A forward pass costs about 2N FLOPs per token and the backward pass about 4N, where N is the parameter count (Kaplan et al., 2020). So training costs 6N per token and forward-only inference costs 2N.
  2. Achieved compute. Multiply FLOPs-per-token by your measured tokens/second: achieved = F_token × throughput. This is the real work your run performs each second.
  3. Theoretical peak. peak = GPUs × per-GPU peak, where the per-GPU peak is the dense (non-sparse) tensor-core rate from the NVIDIA datasheet for your GPU and precision. The tool pins these values with a verification date.
  4. MFU. MFU = achieved ÷ peak, reported as a percentage. Above 100% is impossible and is flagged as an input error.

The tool verifies the same number two ways — once on the whole-fleet aggregate, and once on a per-GPU basis (throughput and peak both divided by the GPU count) — so you can see they agree. It reports MFU, not HFU: MFU excludes activation-recomputation overhead, so it is always at or below HFU and is the fair metric to compare across different implementations. Use dense peaks only, because real dense-transformer training does not use 2:4 structured sparsity; the sparse peak would understate your MFU by roughly half. For Mixture-of-Experts models, enter the active parameters per token rather than the total.

Worked examples

Healthy training — GPT-3 175B, 6N, 1024×A100 BF16, 153,600 tok/s

  1. F/token = 6 × 175e9 = 1.05e12 FLOPs (1,050 GFLOP)
  2. achieved = 1.05e12 × 153,600 = 1.6128e17 = 161,280 TFLOP/s
  3. peak = 1,024 × 312 TFLOP/s = 319,488 TFLOP/s
  4. MFU = 161,280 ÷ 319,488 = 50.5% → Strong
  5. Matches the ~40–55% range reported for well-tuned dense pre-training.

Inference decode — Llama-3-8B, 2N, 1×H100 SXM BF16, 3,000 tok/s

  1. F/token = 2 × 8e9 = 1.6e10 FLOPs (16 GFLOP)
  2. achieved = 1.6e10 × 3,000 = 4.8e13 = 48 TFLOP/s
  3. peak = 1 × 989.5 TFLOP/s = 989.5 TFLOP/s
  4. MFU = 48 ÷ 989.5 = 4.85% → Poor, but expected
  5. Single-stream decode is memory-bound; raise batch size to lift MFU.

Edge case — MFU over 100% flags an input error (8B, 6N, 8×H100, 1e9 tok/s)

  1. F/token = 6 × 8e9 = 4.8e10 FLOPs
  2. achieved = 4.8e10 × 1,000,000,000 = 4.8e19 = 48,000,000 TFLOP/s
  3. peak = 8 × 989.5 = 7,916 TFLOP/s
  4. MFU = 48,000,000 ÷ 7,916 = 606,371% — impossible
  5. The tool flags it: a mistyped throughput or a sparse peak, not a real run.

Frequently asked questions

Sources & references

The FLOPs-per-token convention (Kaplan 2020 · PaLM 2022 (6N / 2N)) and the GPU dense tensor-core peaks were last cross-checked against these sources on 2026-07-08. The two worked examples above (50.5% and 4.85%) are reproduced exactly by the calculator.

Related tools

Rate this tool
Be the first to rate

Comments & feedback

Spotted a bug or want an improvement? Tell us — our team reviews every comment, and good ideas get built. Comments are public and anonymous.

Found a bug, edge case, or want to suggest an improvement?

Email me at [email protected] — most fixes ship within 24 hours.