How scores are calculated

PC Score is a dimensionless index. In the new model it combines CPU, GPU and internal latency. Base weights: CPU 60%, GPU 20%, Latency 20%. The reference values and weights below describe the base configuration, not a promise of unchanging online rating settings: the server may publish a new methodology.

Source metrics

For a block, throughput is calculated from the number of valid records and the time between the first and last:

throughput = (N_valid − 1) × QPC_frequency / (last_QPC − first_QPC)

For three blocks of one load, the arithmetic mean of throughput is taken. CPU frame time describes CPU work time. For GPU and Combined, frame intervals are determined from adjacent GPU timestamps of the start of work; the duration of the GPU work itself is stored separately. The number of conditional benchmark frames is not gaming FPS.

Missing measurements are not replaced with zeros. If there is not enough data for an estimate, the unavailability of a component cannot be interpreted as zero performance.

Percentiles and Low FPS

Percentiles are calculated by Hyndman–Fan Type 7 linear interpolation for sorted values:

h = (n − 1) × p
i = floor(h)
percentile = x[i] + (h − i) × (x[min(i + 1, n − 1)] − x[i])

P50 is the median. P99 of frame time characterizes the slow tail: approximately 99% of observations do not exceed this boundary.

• 1% Low = 1000 / P99 frame time in milliseconds.
• 0,1% Low = 1000 / P99,9 frame time.

Here Low FPS is an inverse percentile, not the average FPS of the worst percent of frames. Numbers from another test with a different definition of Low FPS may differ even on the same data. 0,1% Low is sensitive to rare events and recording length. In the base new formula, CPU uses P99; P99,9 is shown as an additional metric and has no separate weight in PC Score.

Normalization and geometric mean

For speed, the normalized value is measurement / reference, for latency reference / measurement. Weighted geometric mean:

G(x, w) = exp(Σ(w × ln(x)) / Σw)

The reference values are fixed numbers for normalization, not averages across all computers or a market standard. The scale of the base score is 10 000: matching all used inputs with the reference gives 10 000 points. Weights are normalized to their sum.

CPU Score

CPU combines the execution speed of the CPU scenario and P99 of its frame time. Base reference values: throughput 4000 conditional frames/s, P99 0,3 ms. Internal CPU weights: 60% speed and 40% frame time tail.

CPU Score = 10000 ×
  (CPU throughput / 4000)^0.60 ×
  (0.3 / CPU frame P99_ms)^0.40

The second part is equivalent to normalizing 1% Low CPU to 1000 / 0.3, that is, approximately 3333,33 conditional frames/s. Rarer latencies can improve CPU Score even with a similar average throughput. This is not 1% Low in CS2 or another game: the benchmark’s own CPU simulation is measured.

GPU Score

Scenario	Reference throughput, conditional frames/s	Weight within GPU
Geometry	740	45%
Shader	360	45%
Compute	7600	10%

GPU Score = 10000 ×
  (Geometry / 740)^0.45 ×
  (Shader / 360)^0.45 ×
  (Compute / 7600)^0.10

Compute has a lower weight than the two graphics scenarios. A separately high compute shader speed therefore does not mean a proportionally high overall score. GPU Score also depends on the driver, command submission and system state; it is not an isolated spec-sheet estimate of the video card.

Core Latency

P50, P95 and P99 latency are used from the software signal to the completion of GPU work.

Scenario	Reference P50, ms	Reference P95, ms	Reference P99, ms	Scenario weight
Baseline	2,5	4	6	20%
Loaded	9	12	16	80%

Within each scenario, the weights of P50/P95/P99 are 50/30/20:

Baseline = (2.5 / B50)^0.50 × (4 / B95)^0.30 × (6 / B99)^0.20
Loaded = (9 / L50)^0.50 × (12 / L95)^0.30 × (16 / L99)^0.20
Core Latency Score = 10000 × Baseline^0.20 × Loaded^0.80

Latencies in milliseconds are better at a lower value; the corresponding score then increases. PresentMon frame output metrics are not included in this component.

Final PC Score

PC Score = 10000 ×
  (CPU Score / 10000)^0.60 ×
  (GPU Score / 10000)^0.20 ×
  (Core Latency Score / 10000)^0.20

This is a geometric, not arithmetic, sum. For example, with the other inputs unchanged:

• a 10% increase in CPU throughput raises PC Score by approximately 3,5%: 1.10^(0.60 × 0.60);
• a 10% decrease in CPU P99 raises PC Score by approximately 2,6%: (1 / 0.90)^(0.40 × 0.60);
• doubling Compute raises PC Score by approximately 1,4%: 2^(0.10 × 0.20).

These are arithmetic examples, not a measured effect of overclocking or optimization. In practice, a single setting can change several metrics at once.

Performance

Performance may be retained in old results and extended diagnostics. Its base formula combines CPU, Geometry, Shader, Compute and Combined with relative weights 3/1/1/1/3 and reference values 4000/740/360/7600/665. In the CPU/GPU/Latency model, Performance is not an input of the final PC Score. Combined remains a separate measured scenario, but is not directly included in the new final formula.

Consistency

Consistency describes the ratio of the slow tail to the typical time within a run. For base diagnostics, the ratios P99/P50 of CPU, Shader and Combined are used, normalized to 1,20 / 1,15 / 1,20 and combined by geometric mean with equal weights.

Consistency is not a separate multiplier of the new formula. This is not a rejection of smoothness evaluation: P99 CPU is already taken into account in CPU Score, and P95/P99 latency is included in Latency. Repeatability between full runs is still checked separately.

Methodology updates and old results

The client receives scoring parameters from the server. After a new methodology is published, the server may recalculate saved results from the available measurements and change rating positions. Recalculation changes scores, but does not repeat the test and does not fix the old load, driver or launch conditions.

The rating is not split into separate tables just because of the methodology version. For your own before/after experiment, still choose the same load version and conditions. If the necessary data for a component of an old result is missing, it cannot be restored from the overall score or the missing value treated as zero.

The archived version 0.5.2 series preserves the original scores of the old Performance / Latency / Consistency model with weights 50/30/20. Its tables and script are not a check of the new formula. The intermediate 70/20/10 also belong to the previous model, not to the CPU/GPU/Latency described here.

Updated: 2026-10-02.