Compute-Equivalent Gain (CEG) Accounting

• Compute-Equivalent Gain (CEG) Accounting is a quantitative methodology that normalizes compute usage by comparing throughput and efficiency against a chosen reference system.
• The framework enables fair allocation and forecasting in HPC and AI by converting diverse computational outputs into standardized reference units.
• CEG incorporates both energy-based and scale-dependent metrics to assess hardware performance upgrades and algorithmic efficiency improvements for policy and regulatory analysis.

Compute-Equivalent Gain (CEG) Accounting is a quantitative methodology for comparing, allocating, and forecasting the efficiency and value of computational resources and algorithmic innovations in heterogeneous and rapidly evolving high-performance computing (HPC) and AI research settings. CEG metrics allow practitioners, system operators, and regulators to assess how much scientific or AI progress can be attributed to computational hardware improvements versus algorithmic advances, and to establish accounting frameworks that normalize for dramatic throughput and efficiency differences across resources and methods.

1. Conceptual Foundations of CEG

CEG was originally introduced as a relative throughput metric to enable fair accounting in environments with heterogeneous computing resources—most notably, GPUs of differing generations, architectures, and performance characteristics (Sfiligoi et al., 2022). Traditional resource accounting methods, such as wall-clock “GPU-hours,” fail to reflect the actual computational output of newer, more capable hardware. For example, as the per-GPU throughput between NVIDIA K80 and A100 generations increased by nearly an order of magnitude, a naive “per-GPU-hour” metric systematically undervalued newer GPUs while overvaluing legacy hardware.

The CEG paradigm weights compute usage by the actual work produced, not just time occupied, effectively normalizing compute consumption to a chosen reference device or baseline algorithm. This allows scientific, operational, and regulatory stakeholders to quantify equivalent resource use or performance gains in “reference units,” regardless of underlying heterogeneity.

2. Mathematical Definition and Derivation

CEG quantifies how much more efficient a resource or algorithm is relative to a fixed reference in achieving a specific performance threshold. The core formulations arise in both hardware allocation (GPUs, CPU cores) and in algorithmic ablation/advancement (FLOP-efficiency for model improvements).

Hardware-Relative CEG (HPC/Clusters)

Let $j$ be the reference GPU model and $i$ another GPU model:

• $\Phi_i =$ measured compute throughput of GPU model $i$ (jobs/unit time)
• $\Phi_j =$ throughput of the reference GPU

The compute-equivalent gain is

$\mathrm{CEG}_i = \frac{\Phi_i}{\Phi_j}$

Thus, one wall-hour on machine $i$ is equivalent to $\mathrm{CEG}_i$ hours on the reference $j$ in terms of work accomplished (Sfiligoi et al., 2022).

Algorithmic CEG (AI Training/LLMs)

Let $C_0$ and $C_1$ be the minimal compute budgets (e.g., total FLOPs) required for baseline and improved algorithms to reach a predefined performance $p^*$:

$\mathrm{CEG} = \frac{C_0}{C_1}$

This ratio expresses how much more efficient the new algorithm is: a CEG $> 1$ indicates a net gain; $< 1$ signals inefficiency for that regime (Sanderson et al., 7 May 2025, Gundlach et al., 26 Nov 2025). If extrapolated across compute scales, the appropriate CEG can be computed at each $C$ as a function, $f(C)$, reflecting scale-dependent efficiency (see Section 5).

Energy-Based Accounting Interpretation

An analogous “compute-equivalent” principle is used in energy-based accounting models, where the charge for compute use is directly proportional to the energy consumed by each resource. Here, the CEG is operationalized as the number of floating-point operations per unit of energy (FLOPs/Wh) (Pietrantonio et al., 2021).

3. Methodologies for Measuring and Applying CEG

Resource Benchmarking and CEG in Clusters

Empirical CEG accounting for hardware resources requires benchmark workflows executed on each hardware type. For GPUs, “jobs per day” or “jobs per hour” is measured via production workloads (e.g., IceCube photon propagation jobs), with careful aggregation by model, sharing factor, and workload profile. These are mapped into look-up tables indexed by (GPU model, sharing configuration) (Sfiligoi et al., 2022).

When accounting for shared or partitioned resources (e.g., NVIDIA A100 MIG or Kubernetes/HTCondor slot sharing), throughput is measured for each sharing scenario, as sharing can increase aggregate throughput (up to ~4× in measured cases) by mitigating underutilization of powerful hardware.

Algorithmic CEG in AI/ML

For algorithmic advances, CEG estimation involves:

1. Running both baseline and improved implementations across several compute budgets ($C$).
2. Recording performance at each $C$ (e.g., validation loss, accuracy).
3. Fitting smooth scaling curves (often power laws $P(C) = aC^{-\beta} + d$) for each method.
4. Solving for $C_0$ and $C_1$ required to reach fixed $p^*$.
5. Computing $\mathrm{CEG} = C_0 / C_1$.

Bootstrapping and replication are used for uncertainty quantification. Multiple factors (algorithmic changes) are typically analyzed for independence and possible sub-multiplicative interaction effects (Sanderson et al., 7 May 2025, Gundlach et al., 26 Nov 2025).

Worked Example: Hardware-Based CEG

Given:

• K80 (reference): $\Phi_{K80} \approx 0.0833$ jobs/hr
• A100-SXM4: $\Phi_{A100} \approx 0.492$ jobs/hr

Then,

$$\mathrm{CEG}_{A100} = \frac{0.492}{0.0833} \approx 5.9$$

Ten wall-hours on the A100 corresponds to $5.9 \times 10 = 59$ K80-equivalent hours. For core hour equivalence (factoring physical cores per GPU), all conversions are explicitly performed as in (Sfiligoi et al., 2022).

Worked Example: Algorithmic CEG

Consider two algorithms for training LLMs:

• $C_0 =$ baseline FLOPs to achieve $p^*$
• $C_1 =$ new method’s FLOPs for same $p^*$

If $C_0 = 3.5 \times C_1$, then $\mathrm{CEG} = 3.5$; the baseline would require 3.5× more compute to match the improved method’s performance (Sanderson et al., 7 May 2025).

4. Empirical Results and Reference Dependence

CEG is highly sensitive to:

• The choice of reference system or algorithm.
• The compute scale at which it is measured (critical for AI scaling-law regimes).

In small-scale ablation studies (3.6M-param transformers, $< 100\times$ CEG total improvements are typically observed for algorithmic advances), with strong sub-multiplicative effects. At the AI compute frontier, historical CEG improvement for LLM pretraining (2012–2023) was ~6,930×—dominated by architectural scaling exponent change (LSTM→Transformer, $\sim725\times$), efficiency from data/model balancing, and compounded small gains (Gundlach et al., 26 Nov 2025).

Table: CEG Multipliers by Component (from (Gundlach et al., 26 Nov 2025))

Component	CEG Multiplier
Small-scale (scale-inv.)	~2.6×
LSTM→Transformer exponent	~725×
Data/parameter ratio (Chin.)	~3.7×
Combined Frontier Total	~6,930×

A key result is that CEG multipliers are not invariant. For scale-dependent innovations, the CEG function $f(C)$ is monotonically increasing—e.g., at small $C$, LSTM to Transformer is ~6×; at large $C$, it approaches $10^2$–$10^3×$.

5. Impact of Sharing, Energy-Based Charging, and Reference Point

CEG-based accounting frameworks are especially valuable in contexts with:

• Hardware resource sharing (e.g., partitioned GPUs, shared job slots).
• Environments aiming for fair allocation (i.e., billing, quotas).
• Ecological or energy-aware operations (e.g., supercomputing centers incentivizing FLOPs/W or minimizing carbon).

In both (Sfiligoi et al., 2022) and (Pietrantonio et al., 2021), systems are configured to either benchmark throughput empirically, or to use energy consumption (thermal design power) to charge for resource use. In energy-based accounting, only jobs maximizing FLOPs/Wh (high CEG) minimize service unit (SU) charges, thereby aligning financial and carbon incentives.

CEG-based policies require:

• Storing throughput tables indexed by (resource, sharing factor).
• Benchmarking empirical performance for each configuration.
• Dynamic translation of job execution time into reference-equivalent units.

6. Policy, Forecasting, and Regulatory Implications

CEG is increasingly recognized as critical for AI oversight and compute governance. In both (Sanderson et al., 7 May 2025) and (Gundlach et al., 26 Nov 2025), the CEG framework is applied to evaluate the effectiveness of regulatory compute constraints and to forecast residual progress under fixed hardware budgets.

• Pure hardware restrictions are insufficient to arrest progress; software and algorithmic innovations with high CEG can substitute for raw compute (compute-independent), while compute-dependent ones manifest their gains chiefly at frontier scale.
• Forecasting frameworks can catalog all known compute-independent CEG multipliers to estimate possible further advances, and, by tracking scale-dependent CEGs, anticipate when new paradigms might yield substantial breakthroughs.

A robust accounting regime must always specify the reference (hardware, algorithm) and the target compute regime, and, for non-scale-invariant gains, represent CEG as a continuous function rather than as a single scalar.

7. Summary Table: CEG Regimes and Applications

CEG Context	Measurement Unit	Formula/Approach
Hardware (HPC)	Throughput (jobs/hr)	$\mathrm{CEG}_i = \Phi_i/\Phi_j$
Algorithmic (AI)	FLOP efficiency	$\mathrm{CEG} = C_0/C_1$
Energy Accounting	Service Unit (SU)	SU $\propto$ energy consumed

Each use context requires careful benchmarking and explicit communication of reference standards, measurement scales, and sharing policies. CEG accounting ensures fairness, comparability, and scientific clarity across rapidly evolving computing landscapes.