Skip to content

Probe runner: pass --probe-notes/--hold to the CLAP prober; copy cost with voices, the LV2 note sweep and the note-onset latency - #108

Merged
linuxnow merged 6 commits into
mainfrom
fix/106-runner-cost-notes
Oct 19, 2026
Merged

linuxnow merged 6 commits into
mainfrom
fix/106-runner-cost-notes

Conversation

@linuxnow

@linuxnow linuxnow commented Oct 19, 2026 •

Copy link
Copy Markdown
Contributor

The probe runner now passes the instrument note counts to the CLAP prober, and copies into the probe output what plugin-qualify's prober and lv2_measure print about an instrument. The probe output format goes to 1.1.

  • run --probe-notes N and --hold N are passed to clap-qualify. Each one takes a positive count, and the prober decides how many notes it can hold.
  • Every grid point carries the cost timed at its own rate: unit, median, percentile {p, value}, min, max, blocks, warmupBlocks, and voices {held, basis[, capacity]} when the line has them. A rate the prober did not time gets no cost. It never takes a neighbour's figures. The schema's cost block gains the optional voices.
  • An LV2 point carries noteSweep from lv2_measure's rtSafety.noteSweep: applicable, dialect, allocations, locks, syscalls. The CLAP and LV2 paths share one copy, so a CLAP point now carries the sweep's counts too. Before this it kept only applicable and dialect, so a CLAP instrument that allocates on a note-on read clean through the runner.
  • A latency taken from a note is written as method: note-onset, with heard (false when the note did not sound). The schema gains note-onset and heard.
  • Fixtures go to 1.1. A fourth fixture, instrument-notes.json, is an instrument, and five broken copies of it are refused.

Tests:

  • The stand-in children print the prober's shapes for every rate they are given, with figures made from the rate. The per-rate tests run at omx-contract's ORACLE_FLOOR_RATES, which is the runner's default and is read from the installed contract.
  • With PLUGIN_QUALIFY_BUILD=<plugin-qualify>/native/build, make test-probe also runs plugin-qualify's real clap-qualify and lv2_measure over its own fixtures. Without it, those tests print skip.
  • make sabotage has 12 new entries, and every one is caught.

Closes #106

The runner builds clap-qualify's argv itself, so the count an instrument
with no voice-info is held at could not reach the prober through it. Both
take a positive count; how many the prober can hold is the prober's to say.

The test child writes the arguments it was given and prints a latency and
a cost for every rate it is asked for, of the shapes clap-qualify prints.
… the notes held (#106)

clap-qualify prints a cost per rate, and for an instrument the voices it
held while it was timed; the runner copied none of it, so a record judged
through the runner had no cost for a CLAP plugin. Each grid point now
carries the figures of its own rate, and voices when the line has them.
A rate the prober did not time keeps no cost, never a neighbour's.

The cost block gains the optional voices object: a minor of the format.
A fourth fixture is an instrument, and three broken copies of it are
refused.
…counts (#106)

lv2_measure prints rtSafety.noteSweep for a plugin with a MIDI input, and
put_lv2_measure copied rtSafety without it, so plugin-qualify's judge
could not read an LV2 instrument's note sweep from a probe output.

One copy now serves both formats: whether the sweep applied, its dialect,
and the allocations, locks and syscalls counted while the notes played.
The CLAP point kept only the first two, so a CLAP instrument allocating on
a note on read clean through the runner; it carries the counts too.
…ded (#106)

clap-qualify marks an instrument's latency as measured from a note, with
heard false when nothing sounded. The point kept only the declared and
measured frames under method impulse-onset, so an instrument read back
looked like an impulse reading with an onset of a frame or more.

The point's method is note-onset beside impulse-onset and declared-port,
and heard is written on every note-onset point: within format 1.1.
…ild is named (#106)

The stand-in children print the prober's shapes; these tests hold the
runner to the real ones. With PLUGIN_QUALIFY_BUILD naming a plugin-qualify
native/build, the CLAP synth is timed holding 32 notes at every rate of
omx-contract's ORACLE_FLOOR_RATES, each point with its own cost, its notes
and a latency from a note that sounded; with no count it has no cost at
any rate; the synth declaring its voices holds that many. The LV2 synth
that allocates on a note counts allocations in its note sweep, its clean
twin none.
Twelve guards, each broken in a scratch copy with the test it must turn
red: the two counts not passed to the prober, a point with no cost, with
the first rate's or a neighbour's, the notes held left out, an LV2 point
without its note sweep, a sweep without its allocations, a note-onset
latency called an impulse's, a silent note heard, and the schema without
voices or note-onset.
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

Probe runner: pass --probe-notes to the CLAP prober and copy its cost, with the notes held, into the grid

1 participant