Hold the requested clock at the settle point, not mid-slope above it

Measured on a 5090 under load: the boost settles one 5 mV step below the
flat top's first anchor, at the effective curve's clock there - mid-gap
when the anchor spacing is 10 mV. The stock-slope-continued flatten
therefore realized half a stock step above the request (+7..15 MHz at
the profile caps, +52 MHz for a cap below the curve's knee).

The cap->flat segment is now a straight line through (settle voltage,
requested clock) with a fixed 16 MHz rise - the smallest the driver
reliably keeps distinct (a written 8 MHz rise provably folds the
plateau), which also bounds the realized miss at half the rise, inside
the driver's own one-bin re-shaping noise. Every report now names the
operating point: the plan and post-apply lines from the plan's own
anchors, a replay from its written shape, status by inference from the
flat (with no point fabricated when the top holds no plateau), and a
cap->flat rise that reads back collapsed is flagged as a possible fold.
The measured driver behavior is documented in DEVELOPMENT.md ("Where
the boost settles").

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017bNKonjifgKN2zykAGFNq4

Author: vuplea

CURVE-FILES.md

@@ -67,11 +67,11 @@ base clock):
   "memoryOffset": 1400,
   "curve": [
     { "mv": 890, "offset": 480, "mhz": 2820 },
-    { "mv": 895, "offset": 480, "mhz": 2842 },
+    { "mv": 895, "offset": 480, "mhz": 2850 },
     { "mv": 900, "offset": 480, "mhz": 2872 },
-    { "mv": 910, "offset": 457, "mhz": 2872 },
+    { "mv": 910, "offset": 473, "mhz": 2888 },
     … the flattened anchors above the cap …
-    { "mv": 1240, "offset": -323, "mhz": 2872 }
+    { "mv": 1240, "offset": -307, "mhz": 2888 }
   ]
 }
 ```

DEVELOPMENT.md

@@ -88,6 +88,44 @@ the card.
 The core-domain point slots come first (a per-entry type word says which domain a slot belongs to:
 0 = core, 1 = memory), and the memory slots follow — slot 80 on Pascal, slot 127 on a 5090.
 
+## Where the boost settles
+
+A flatten pins the boost by curve shape alone, so the plan is built on how the boost algorithm
+picks its operating point. NVIDIA doesn't document this; the following is measured on an RTX 5090
+under a sustained FurMark load, comparing written curve shapes against `watch` and `curve`
+read-backs:
+
+- **The settle voltage is one 5 mV step below the flat top's first anchor.** A flat from 910 mV
+  runs the card at 905 mV; a flat from 900 mV runs it at 895 mV. It never runs on the flat itself.
+- **The driver's curve is finer than the anchor table.** Table anchors sit 5 or 10 mV apart
+  (Blackwell cycles 5-5-5-10, with the 10 mV gap right after every multiple of 25 mV), but the
+  settle voltage exists at 5 mV granularity regardless: a flat from 910 mV settles at 905 mV,
+  where no anchor exists — the clock there interpolates between the 900 and 910 anchors.
+- **The realized clock tracks the middle of the cap→flat segment, within one bin.** Clocks
+  quantize to ~7.5 MHz bins on Blackwell (~15 MHz read-back steps on older generations). Measured
+  at a 900 mV cap: a segment written 2880→2903 settles at 2887–2895; written 2872→2888 it settles
+  at 2880; written 2880→2896 it settles at 2887. "Mid-segment" and "one bin below the flat" fit
+  every measurement equally — indistinguishable at bin granularity.
+- **The driver re-shapes written anchors by a bin or two.** A pair written 2872/2888 reads back
+  2880/2887 from the status curve, and neighbouring anchors of the same write shift by anything
+  from 0 to +15 MHz. Aiming the shape finer than a bin is therefore meaningless.
+- **A cap→flat rise below ~2 bins folds.** Written 8 MHz apart, the driver snaps the pair into one
+  plateau: the flat's first anchor becomes the cap anchor itself and the settle drops 5 mV lower,
+  landing a stock-slope step below the request. Written 16 MHz apart, the pair stays distinct. On
+  generations whose clocks step ~15 MHz, 16 MHz is a single bin and folding is plausible but
+  unmeasured; a fold degrades to the settle-a-step-lower shape (less clock at less voltage — the
+  safe direction), and the post-apply report flags a cap→flat rise that reads back collapsed.
+
+`GpuTuning.BuildCurvePlan` encodes the consequences: the cap→flat segment is a straight line
+through (settle voltage, requested clock) with a fixed 16 MHz rise — the smallest the driver
+reliably keeps, which also bounds the realized-clock miss at half the rise, inside the bin noise.
+Where the gap above the cap anchor is 5 mV, the settle point *is* the cap anchor and holds the
+request outright; where it is 10 mV, the segment straddles the request 8 MHz each side and the
+card operates 5 mV above the named cap (`--mv 900` runs at 905 mV). The alternative — starting the
+plateau at the cap anchor so the card stays at or under the named voltage — realizes a clock a
+stock-slope step below the request; running one step higher in voltage at the requested clock is
+the safe side of that trade.
+
 ## Generations
 
 **Pascal (GTX 10xx, 2016) is the architectural floor**: GPU Boost 3.0 introduced the per-point V/F

README.md

@@ -147,9 +147,11 @@ operates on.
 ## Development
 
 Every point above the cap anchor is flattened to one frequency through `ClkVfPointsSetControl`;
-the boost algorithm then pins voltage at the cap. A band of `--cap-points` anchors ending at the cap
-shares the cap's offset, so if the realized voltage settles a bin or two below the cap under load,
-an overclocked cap doesn't fall back down the steep stock curve.
+the boost algorithm then pins its operating point just below the flat. The cap→flat segment is
+aimed so the clock at that point is the requested one (measured settle behavior — see
+[DEVELOPMENT.md](DEVELOPMENT.md)). A band of `--cap-points` anchors ending at the cap shares the
+cap anchor's offset, so if the boost settles deeper below the cap under load, an overclocked cap
+doesn't fall back down the steep stock curve.
 Points below the band stay stock; `--mhz` only raises the cap region. After writing, the tool reads the
 curve back to confirm.
 

e2e/App.cs

@@ -34,7 +34,7 @@ public static void SkipIfCurveTransient(string output)
     /// and the "offsets don't match / reverted" path was not taken.</summary>
     public static void AssertWriteConfirmed(string output)
     {
-        Assert.Contains("Confirming curve point", output);
+        Assert.Contains("Confirming operating point", output);
         Assert.DoesNotContain("didn't change after writing", output);
     }
 

e2e/LoadTests.cs

@@ -7,9 +7,9 @@ namespace SimpleNvidiaUndervolt.E2E;
 /// Tests that need the GPU working, not idle: a Playwright-driven WebGL load
 /// (<see cref="GpuLoadFixture"/>) holds the boost algorithm at its operating point, and the tests
 /// assert where that point lands against an applied cap. This is the tool's actual contract — the
-/// flatten is placed so the boost settles on the requested cap point (one 5 mV step below the flat
-/// start), and only a loaded card shows where the boost settles — so these are the only tests that
-/// verify the undervolt does what it says, rather than that the curve write landed.
+/// cap→flat segment is aimed so the boost, settling one 5 mV step below the flat start, lands on
+/// the requested clock — and only a loaded card shows where the boost settles, so these are the
+/// only tests that verify the undervolt does what it says, rather than that the curve write landed.
 /// </summary>
 [Collection(GpuCollection.Name)]
 public sealed class LoadTests : IClassFixture<GpuLoadFixture>
@@ -36,10 +36,10 @@ public void PlainCapUnderLoad_BoostSettlesOnTheCapPoint()
         var (settleMv, settleMhz) = SampleSettledPointOrSkip();
         AssertSettledOnTheCap(stock, k, settleMv);
 
-        // ...at the cap point's own clock: at or a hair above the stock clock there (the settle can
-        // sit in a 10 mV anchor gap, interpolating toward the flat start), never up at the flat top
-        // and never fallen down the stock curve below the cap.
-        Assert.InRange(settleMhz, stock[k].Mhz - 25, stock[k + 1].Mhz + 25);
+        // ...at the cap point's own stock clock, wherever in the anchor gap the settle voltage
+        // falls - the straddle holds the requested clock at the settle point, so the tolerance is
+        // read-back bins plus the thermal drift since the stock read, not an anchor step.
+        Assert.InRange(settleMhz, stock[k].Mhz - 25, stock[k].Mhz + 25);
     }
 
     [SkippableFact]
@@ -58,8 +58,9 @@ public void ReducedClockCapUnderLoad_BoostHoldsTheTargetAtTheCap()
 
         // The requested clock is held at the settle point. The flatten-at-the-cap shape fails this
         // (and the voltage check above): the boost lands one anchor below the cap, a stock-slope
-        // step (~15-25 MHz) under the target.
-        Assert.InRange(settleMhz, targetMhz - 25, targetMhz + (stock[k + 1].Mhz - stock[k].Mhz) + 25);
+        // step under the target. The stock-slope-continued shape fails it too on a wide anchor gap,
+        // overshooting by half the stock step.
+        Assert.InRange(settleMhz, targetMhz - 25, targetMhz + 25);
     }
 
     [SkippableFact]

e2e/TuningShapeTests.cs

@@ -18,7 +18,7 @@ public sealed class TuningShapeTests
     public TuningShapeTests(GpuFixture gpu) => _gpu = gpu;
 
     [SkippableFact]
-    public void PlainCap_LeavesTheCapAndFlatStartAtStock_AndFlattensOnlyAbove()
+    public void PlainCap_WritesTheStraddle_AndFlattensAbove()
     {
         Skip.IfNot(_gpu.Available, _gpu.SkipReason);
         var (stock, k) = ReadStockAndPickAnchor();
@@ -27,17 +27,23 @@ public void PlainCap_LeavesTheCapAndFlatStartAtStock_AndFlattensOnlyAbove()
         Assert.Equal(0, exitCode);
         App.AssertWriteConfirmed(output);
 
-        // The shape signature, exact in the written deltas: nothing below or at the flat start
-        // moves (a plain cap keeps stock clocks through it - the boost then settles one step below
-        // the flat start, i.e. on the cap point), and everything above only comes down. A
-        // flatten-at-the-cap shape would show a negative delta at k+1.
+        // The shape signature, exact in the written deltas: the cap anchor and the band below share
+        // one offset at most a spread below stock (the segment is aimed so the settle voltage holds
+        // the stock clock, which writes the cap anchor a little under it), the flat top starts
+        // exactly the fixed 16 MHz spread above the cap anchor, and everything from there up is one
+        // level plateau. A flatten-at-the-cap shape would leave no rise between k and k+1; the
+        // stock-slope-continued shape would show a stock-step rise instead of the fixed spread.
         int[] deltas = ReadDeltasAlignedWith(stock);
-        for (int i = 0; i <= k + 1; i++)
+        Assert.Equal(deltas[k], deltas[k - 1]);
+        Assert.InRange(deltas[k], -16_000, 0);
+        long capAnchorKhz = stock[k].Mhz * 1000L + deltas[k];
+        long flatTopKhz = stock[k + 1].Mhz * 1000L + deltas[k + 1];
+        Assert.Equal(16_000, flatTopKhz - capAnchorKhz);
+        for (int i = k + 2; i < deltas.Length; i++)
         {
-            Assert.True(deltas[i] == 0, $"anchor {i} ({stock[i].Mv} mV) moved by {deltas[i]} kHz below the flat start");
+            Assert.Equal(flatTopKhz, stock[i].Mhz * 1000L + deltas[i]);
         }
 
-        Assert.All(deltas, d => Assert.True(d <= 0, $"a plain cap wrote a positive delta ({d} kHz)"));
         Assert.True(deltas[^1] < -15_000,
             $"the top anchor barely moved ({deltas[^1]} kHz) - the cap did not flatten the curve");
     }
@@ -53,18 +59,18 @@ public void ReducedClockCap_WritesOneSharedOffset_FromTheBandThroughTheFlatStart
         Assert.Equal(0, exitCode);
         App.AssertWriteConfirmed(output);
 
-        // The cap's offset is one value carried by the band below the cap, the cap anchor and the
-        // flat start above it - that shared offset is what keeps the clock on a stock-parallel
-        // slope however deep the boost settles. Exact equality holds regardless of whether the run
-        // planned from the saved reference or a live read.
-        // The margin is loose on purpose: planned from the saved reference, the written delta is
-        // (live - reference) - 60, so the thermal gap between this run and the reference capture
-        // rides on it. The two equalities below are the actual shape signature; this only has to
-        // prove a real reduction landed.
+        // The cap anchor's offset is one value carried by the band below it - that shared offset is
+        // what keeps the clock on a stock-parallel slope however deep the boost settles - and the
+        // flat top starts exactly the fixed 16 MHz spread above the cap anchor. Both equalities
+        // hold regardless of whether the run planned from the saved reference or a live read.
+        // The margin on the reduction is loose on purpose: planned from the saved reference, the
+        // written delta is (live - reference) - 60, so the thermal gap between this run and the
+        // reference capture rides on it; this only has to prove a real reduction landed.
         int[] deltas = ReadDeltasAlignedWith(stock);
         Assert.True(deltas[k] < -20_000, $"the cap anchor's delta ({deltas[k]} kHz) is not the requested reduction");
         Assert.Equal(deltas[k], deltas[k - 1]);
-        Assert.Equal(deltas[k], deltas[k + 1]);
+        Assert.Equal(16_000,
+            (stock[k + 1].Mhz * 1000L + deltas[k + 1]) - (stock[k].Mhz * 1000L + deltas[k]));
     }
 
     [SkippableFact]
@@ -85,7 +91,7 @@ public void MemoryOnlyTune_SetsTheMemoryClock_AndLeavesTheCurveAtStock()
     }
 
     [SkippableFact]
-    public void Status_WhileCapped_ReportsTheCapPoint()
+    public void Status_WhileCapped_ReportsTheOperatingPoint()
     {
         Skip.IfNot(_gpu.Available, _gpu.SkipReason);
         var (stock, k) = ReadStockAndPickAnchor();
@@ -96,14 +102,17 @@ public void Status_WhileCapped_ReportsTheCapPoint()
 
         var (exitCode, output) = App.Run(null, "status");
 
-        // The status line names the point the boost settles on - the cap anchor. One anchor of
-        // slack: a read at a temperature away from the reference can seam the flat's edge, which
-        // moves the reported point one anchor down (see GpuTuning.EffectiveCapPoint).
+        // The status line names the point the boost settles on: between the cap anchor and one
+        // boost step below the flat start. One anchor of slack each way: a read at a temperature
+        // away from the reference can seam the flat's edge, which moves the inferred point one
+        // anchor - a seamed flat start puts it one boost step below the anchor above the flat
+        // (see GpuTuning.EffectiveOperatingPoint).
         Assert.Equal(0, exitCode);
-        Match m = Regex.Match(output, @"capped at (\d+) mV");
-        Assert.True(m.Success, $"no 'capped at' report in: {output}");
+        Match m = Regex.Match(output, @"operating point (\d+) mV");
+        Assert.True(m.Success, $"no 'operating point' report in: {output}");
         Assert.InRange(int.Parse(m.Groups[1].Value, CultureInfo.InvariantCulture),
-            stock[k - 1].Mv, stock[k].Mv);
+            stock[k].Mv - GpuTuning.BoostStepMv,
+            Math.Max(stock[k + 1].Mv, stock[k + 2].Mv - GpuTuning.BoostStepMv));
     }
 
     [SkippableFact]