How scores are calculated

PC Score combines speed, latency and consistency into a single dimensionless index. It cannot be directly converted into FPS or a “Windows speedup percentage”. Below is the score-model-1.2-candidate-1 model for engine 0.5.2. The conditions under which the source metrics are obtained are described in the methodology.

Source metrics

Within a block, throughput is calculated from the number of valid records and the difference between the times of the first and last record:

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

For three repetitions of one workload, the average throughput of the blocks is taken. Instead, one should not take the overall phase row, where a single block mixes scenarios from different points in time.

CPU frame time: the duration of CPU work. For GPU and Combined, frame intervals are calculated between adjacent dedicated GPU timestamps of the start of work. The duration of the GPU work itself between the start and the end is recorded separately.

Positive latencies are not removed, even if they spoil the number. Incorrect timestamps are flagged separately. If a metric is missing, it remains unavailable; zero is not substituted for it.

For the calculation itself, an eligibility rule applies: non-positive, missing, NaN and infinite critical inputs reject the scoring entirely. Values are not clamped or replaced with boundary values — the model has no “corrected” inputs.

Percentiles and Low FPS

For sorted values, linear interpolation Hyndman-Fan Type 7 is used:

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

The index starts at zero. P50 corresponds to the median; P99 shows the boundary below which approximately 99% of observations lie.

• 1% Low = 1000 / P99 of frame time in milliseconds; at least 100 intervals are required.
• 0.1% Low = 1000 / P99.9; at least 1 000 intervals are required.

These values are inverse percentiles of time, not the average FPS for the worst percent of frames. With a different definition of Low FPS, the numbers on the same data may differ.

Additionally, the mean, minimum, maximum, P90, P95, standard deviation with division by n, median absolute deviation and coefficient of variation are calculated.

Normalization and geometric mean

For speed, “higher is better”, so the normalized value equals измерение / эталон. For latency and the tail-to-median ratio, “lower is better”, so эталон / измерение is used.

Weighted geometric mean:

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

It combines the ratios of measurements to references, so different units of measurement are not added together. The influence of each component depends on its weight: doubling one of them does not double the final result.

The reference is a fixed set of constants for normalization; here it is called provisional-dev-reference-2026-08-21. It is not the “average market” and not an industry standard. With a complete match to the reference values, the final index equals 10 000.

Performance

Scenario	Reference throughput, conventional frames/s
CPU	4 000
Geometry	740
Shader	360
Compute	7 600
Combined	665

GPU = G(Geometry / 740, Shader / 360, Compute / 7600)
Performance = 10000 × G(CPU / 4000, GPU, Combined / 665)

In these two formulas, the arguments are balanced. In Performance, the contribution of CPU and Combined is equal (one third each), and each of the three GPU scenarios contributes one ninth in the logarithmic part.

Core Latency

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

Scenario	P50, ms	P95, ms	P99, ms
Baseline	2.5	4	6
Loaded	9	12	16

For each scenario, G(эталон P50 / P50, эталон P95 / P95, эталон P99 / P99) is calculated with weights 50/30/20. Then:

Core Latency Score = 10000 × G(Baseline, Loaded; weights 40/60)

Scores increase as latency decreases. The measurement itself in milliseconds, on the contrary, is better at a lower value.

Consistency

This component looks at the P99 / P50 ratio and shows how strong the latency tail is relative to the typical time. It is not a metric of repeatability between individual runs.

Input	Reference P99/P50
CPU frame time	1.20
Shader frame time	1.15
Combined frame time	1.20
Baseline Core Latency	2.40
Loaded Core Latency	16/9

For each input, эталон / измеренное отношение is calculated, then the geometric mean of the five values with equal weights is taken and multiplied by 10 000. In the current model, the GPU tail is taken from Shader, not from the common bag of Geometry, Shader and Compute.

Final PC Score

PC Score = 10000 ×
  (Performance / 10000)^0.50 ×
  (Core Latency Score / 10000)^0.30 ×
  (Consistency / 10000)^0.20

The weights 50/30/20 are defined within the methodology. They do not mean a universal share of CPU, GPU and latency for all games. Therefore, when comparing results, one should look at both the component breakdown and the source metrics.

For sensitivity analysis, the engine also calculates weight variants 60/20/20 and 40/40/20. Additionally, for each leaf input, an analytical sensitivity is output: the final score when that input deviates by +1, +5 and +10%. They help to see the influence of the choice of weights and individual inputs, but do not replace the main score.

In the check of eight runs, all four scores were recalculated from the saved summary metrics. The discrepancy was less than 0.000001 points. Such a recalculation verifies the arithmetic of the model. Recalculation cannot turn an ineligible capture into an eligible one: cancelled, incomplete and diagnostic runs remain ineligible under any reprocessing. Timer accuracy and repeatability on hardware require separate checks.

Verified: 2026-09-20.