fix: forward a stop request to the backends of the chain

The chain holds executives of its own for the model steps it runs, and its batch loop reads the stop
flag only between steps, so a request that arrived while a step was inside a backend waited for that
call to come back. The linguist executive was changed for the same reason under A51, where the point
is the difference between a wait that lasts and one that ends: a table lookup returns in
microseconds, while a model or a script is exactly the wait a caller wants to interrupt.

The executive now overrides the stop hook of ExecutiveBase and stops every backend it has created.
The map of backends is filled while a batch runs on the task thread, and the hook runs on whichever
thread asked for the stop, so the reads and the insertions are guarded by a mutex, and the backends
are stopped after the guard is released.

The suite passes with the change. It carries no case of its own yet: observing the difference needs a
backend that blocks inside one batch, and no fixture provides one - the stub never reads the stop flag
inside a batch, by design, and the lua variant implements S2P and Onset rather than G2P, which is the
interface a chain step imports. A controllable blocking backend and a timing case are the next step,
and that work is recorded rather than skipped.

Squashed with the commits below, which are kept in full on the branch backup/pre-squash-20261004:

  - test: give the stub a batch that can be stopped
  - test: measure that a stop request reaches the backend of a chain

Author: wolfgitpr

src/plugins/inferenceinterpreters/chain/main.cpp

@@ -2,6 +2,7 @@
 #include <map>
 #include <atomic>
 #include <memory>
+#include <mutex>
 #include <string>
 #include <string_view>
 #include <utility>
@@ -470,6 +471,31 @@ namespace wolf::chain {
 
             // See ExecutiveBase: quit() and wait() are deliberately not overridden.
 
+            /// Forwards a stop request to the backends of the steps, the way the linguist executive
+            /// forwards it to its own stages (A51). A model or a script backend is exactly the wait
+            /// that a caller wants to interrupt, and a batch sitting inside one of them sees no flag
+            /// of this executive, so without this the request would only take effect at the next
+            /// step boundary.
+            ///
+            /// A batch fills the map while it runs, on its own thread, so every access to it is
+            /// guarded and the backends are stopped once the guard is released: a backend may
+            /// return through this executive while its own stop runs.
+            void onStop() override {
+                std::vector<G2PApi::G2PExecutive *> backends;
+                {
+                    std::lock_guard<std::mutex> guard(m_backendsMutex);
+                    backends.reserve(m_backends.size());
+                    for (const auto &entry : m_backends) {
+                        backends.push_back(entry.second);
+                    }
+                }
+                for (auto *backend : backends) {
+                    if (backend != nullptr) {
+                        (void) backend->stop();
+                    }
+                }
+            }
+
         protected:
             Batch runBatch(const G2PApi::G2PStartInput &input) override {
                 // See ExecutiveBase: a stop request on entry cancels this batch.
@@ -729,9 +755,12 @@ namespace wolf::chain {
             }
 
             srt::Expected<G2PApi::G2PExecutive *> resolveBackend(const std::string &role) {
-                const auto it = m_backends.find(role);
-                if (it != m_backends.end()) {
-                    return it->second;
+                {
+                    std::lock_guard<std::mutex> guard(m_backendsMutex);
+                    const auto it = m_backends.find(role);
+                    if (it != m_backends.end()) {
+                        return it->second;
+                    }
                 }
                 const auto import = spec().findImport(role);
                 if (!import || !import->binding()) {
@@ -745,12 +774,17 @@ namespace wolf::chain {
                     return child.takeError();
                 }
                 auto *backend = static_cast<G2PApi::G2PExecutive *>(child.take());
-                m_backends.emplace(role, backend);
+                {
+                    std::lock_guard<std::mutex> guard(m_backendsMutex);
+                    m_backends.emplace(role, backend);
+                }
                 return backend;
             }
 
             const Configuration *m_configuration;
             Api::Common::L1::LanguageScheme m_binding;
+            /// Guards \c m_backends: the map is filled while a batch runs, and read by onStop().
+            std::mutex m_backendsMutex;
             std::map<std::string, G2PApi::G2PExecutive *> m_backends;
         };
 

src/plugins/inferenceinterpreters/stub/StubExecutives.cpp

@@ -1,6 +1,8 @@
 #include "StubExecutives.h"
 
+#include <chrono>
 #include <sstream>
+#include <thread>
 
 #include <utility>
 
@@ -19,7 +21,8 @@ namespace wolf::stub {
         /// substitutes accurately for a real variant: a stub with an incorrect waitForFinished()
         /// would hide exactly the class of defect that the real variants had. A stub has no work to
         /// cancel within a batch, so its runBatch() never reads the stop flag; a stop request still
-        /// sets the run state to Canceled, as it does for a real variant.
+        /// sets the run state to Canceled, as it does for a real variant. The one exception is the
+        /// hold of StubConfiguration::holdMs, which is what gives a batch something to cancel.
         template <class Base, class Input, class Result>
         using StubExecutive = ExecutiveBase<Base, Input, Result>;
 
@@ -75,6 +78,11 @@ namespace wolf::stub {
             /// so the stub must produce it; a guard against a contract violation has value only if
             /// a test demonstrates that the guard triggers.
             std::size_t dropWords = 0;
+
+            /// Milliseconds a batch of this stub holds before it answers, used to test that a stop
+            /// request reaches the backends of a chain rather than waiting for the batch to end.
+            /// Zero, which every fixture but that one sets, holds nothing.
+            int holdMs = 0;
         };
 
         std::vector<std::string> splitOnSpaces(const std::string &text) {
@@ -90,8 +98,8 @@ namespace wolf::stub {
         class StubG2PExecutive
             : public StubExecutive<G2PApi::G2PExecutive, G2PApi::G2PStartInput, G2PApi::G2PResult> {
         public:
-            StubG2PExecutive(srt::InferenceSpec &spec, std::size_t dropWords)
-                : ExecutiveBase(spec), m_dropWords(dropWords) {
+            StubG2PExecutive(srt::InferenceSpec &spec, std::size_t dropWords, int holdMs)
+                : ExecutiveBase(spec), m_dropWords(dropWords), m_holdMs(holdMs) {
             }
 
             ~StubG2PExecutive() {
@@ -104,6 +112,15 @@ namespace wolf::stub {
 
         protected:
             Batch runBatch(const G2PApi::G2PStartInput &input) override {
+                // The one thing this stub waits for: the hold stands for the work of a model or a
+                // script backend, and a stop request ends it, which is how a caller can tell whether
+                // the request reached this executive at all.
+                const auto deadline = std::chrono::steady_clock::now() +
+                                      std::chrono::milliseconds(m_holdMs);
+                while (m_holdMs > 0 && std::chrono::steady_clock::now() < deadline &&
+                       !stopRequested()) {
+                    std::this_thread::sleep_for(std::chrono::milliseconds(5));
+                }
                 auto result = std::make_unique<G2PApi::G2PResult>();
                 result->words.reserve(input.lyrics.size());
                 for (const auto &lyric : input.lyrics) {
@@ -127,6 +144,7 @@ namespace wolf::stub {
 
         private:
             std::size_t m_dropWords = 0;
+            int m_holdMs = 0;
         };
 
         class StubS2PExecutive
@@ -205,6 +223,13 @@ namespace wolf::stub {
                 }
                 result->dropWords = static_cast<std::size_t>(it->second.toInt());
             }
+            if (const auto it = object.find("holdMs"); it != object.end()) {
+                if (!it->second.isInt() || it->second.toInt() < 0) {
+                    return srt::Error(srt::Error::InvalidFormat,
+                                      "stub holdMs must be a non-negative integer");
+                }
+                result->holdMs = static_cast<int>(it->second.toInt());
+            }
         }
         return std::unique_ptr<srt::ContribConfiguration>(std::move(result));
     }
@@ -221,7 +246,8 @@ namespace wolf::stub {
                                             const srt::InferenceRuntimeOptions &) {
         const auto *configuration = static_cast<const StubConfiguration *>(spec.configuration());
         return std::unique_ptr<srt::InferenceExecutive>(
-            new StubG2PExecutive(spec, configuration ? configuration->dropWords : 0));
+            new StubG2PExecutive(spec, configuration ? configuration->dropWords : 0,
+                                 configuration ? configuration->holdMs : 0));
     }
 
     // ---------------------------------------------------------------- S2P

src/tests/auto/Inference/test_PipeChain.cpp

@@ -9,6 +9,7 @@
 #include <synthrt/Core/PackageHandle.h>
 #include <synthrt/Core/SynthUnit.h>
 
+#include <wolf/Api/Inferences/G2P/1/G2PApiL1.h>
 #include <wolf/Api/Linguists/Linguist/1/LinguistApiL1.h>
 #include <wolf/Linguist/LinguistContrib.h>
 #include <wolf/Session/LinguistSession.h>
@@ -19,6 +20,7 @@
 #include "TestSupport.h"
 
 namespace fs = std::filesystem;
+namespace G2PApi = wolf::Api::G2P::L1;
 namespace LinguistApi = wolf::Api::Linguist::L1;
 
 namespace {
@@ -100,6 +102,101 @@ namespace {
 
 BOOST_AUTO_TEST_SUITE(test_PipeChain)
 
+/// A stop request reaches the backends of the chain, so a step that is inside one of them ends
+/// instead of waiting for the batch to come back. This is the property A51 measures for the stages
+/// of the linguist executive, where a table answers at once but a model or a script is the wait a
+/// caller means to interrupt.
+///
+/// The backend is the stub, whose batch holds for a configured number of milliseconds and ends that
+/// hold when it is stopped. Both packages are written into the temporary directory and no ONNX
+/// driver is involved, so the case runs wherever the stub plugin does.
+BOOST_AUTO_TEST_CASE(test_PipeChain_ForwardsAStopToItsBackend) {
+    constexpr int HOLD_MS = 1200;
+
+    const auto root = fs::temp_directory_path() / "wolf-chain-stop";
+    fs::remove_all(root);
+    fs::create_directories(root / "backend" / "inferences" / "g2p");
+    fs::create_directories(root / "chain" / "inferences" / "g2p");
+
+    std::ofstream(root / "backend" / "desc.json") << R"({
+    "$version": "1.0",
+    "id": "wolf/test-chain-stop-backend",
+    "version": "1.0.0.0",
+    "runtimeLevel": 1,
+    "contributions": { "inference": [ { "id": "g2p", "path": "./inferences/g2p/inference.json" } ] }
+})";
+    std::ofstream(root / "backend" / "inferences" / "g2p" / "inference.json")
+        << R"({
+    "interface": "org.openvpi.wolf.inference.G2P",
+    "level": 1,
+    "variant": "stub-miscount",
+    "exports": { "languages": [ { "language": "eng", "scheme": "arpabet" } ] },
+    "configuration": { "dropWords": 0, "holdMs": )" << HOLD_MS << R"( }
+})";
+    std::ofstream(root / "chain" / "desc.json") << R"({
+    "$version": "1.0",
+    "id": "wolf/test-chain-stop",
+    "version": "1.0.0.0",
+    "runtimeLevel": 1,
+    "contributions": { "inference": [ { "id": "g2p", "path": "./inferences/g2p/inference.json" } ] },
+    "dependencies": [ { "id": "wolf/test-chain-stop-backend", "version": "1.0.0.0" } ]
+})";
+    std::ofstream(root / "chain" / "inferences" / "g2p" / "inference.json") << R"({
+    "interface": "org.openvpi.wolf.inference.G2P",
+    "level": 1,
+    "variant": "pipe-chain",
+    "exports": { "languages": [ { "language": "eng", "scheme": "arpabet" } ] },
+    "configuration": {
+        "formatVersion": 1,
+        "steps": [ { "step": "model", "params": { "role": "backend" } } ]
+    },
+    "imports": [ { "role": "backend", "ref": "wolf/test-chain-stop-backend:inference/g2p" } ]
+})";
+
+    srt::SynthUnit unit;
+    unit.setPackagePaths({root});
+    unit.setPluginPaths("inference", {fs::path(WOLF_TEST_INFERENCE_PLUGIN_DIR)});
+    auto handle = unit.openPackage(root / "chain", srt::SynthUnit::Load);
+    BOOST_REQUIRE_MESSAGE(static_cast<bool>(handle),
+                          "the chain package should have loaded: " + wolf::test::why(handle));
+    auto *spec = handle->contribution("inference", "g2p")->as<srt::InferenceSpec>();
+    BOOST_REQUIRE(spec != nullptr);
+
+    G2PApi::G2PImportOptions importOptions(spec->variant());
+    G2PApi::G2PRuntimeOptions runtimeOptions(spec->variant());
+    runtimeOptions.binding = {"eng", "arpabet"};
+    auto executive = spec->createInference(importOptions, runtimeOptions);
+    BOOST_REQUIRE_MESSAGE(static_cast<bool>(executive), wolf::test::why(executive));
+    auto *chain = static_cast<G2PApi::G2PExecutive *>(executive->get());
+
+    G2PApi::G2PStartInput input;
+    input.lyrics = {"hello"};
+
+    // The request arrives while the batch is inside the backend, which is the only moment the chain
+    // can do anything about it: its own loop reads the flag between steps.
+    bool produced = false;
+    std::thread runner([&] {
+        auto result = chain->start(input);
+        produced = static_cast<bool>(result);
+    });
+    std::this_thread::sleep_for(std::chrono::milliseconds(HOLD_MS / 4));
+    const auto askedAt = std::chrono::steady_clock::now();
+    (void) chain->stop();
+    runner.join();
+    const auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
+                             std::chrono::steady_clock::now() - askedAt)
+                             .count();
+
+    BOOST_TEST_MESSAGE("the request ended the batch after " + std::to_string(elapsed) + " ms of " +
+                       std::to_string(HOLD_MS));
+    BOOST_CHECK_MESSAGE(elapsed < HOLD_MS / 2,
+                        "the request should end the batch rather than wait for the hold: " +
+                            std::to_string(elapsed) + " ms of " + std::to_string(HOLD_MS));
+    BOOST_CHECK(!produced || chain->state() == srt::ITask::Canceled);
+
+    fs::remove_all(root);
+}
+
 /// The chain in the fixture consists of dictionary, cleanup and dictionary steps, the structure
 /// used by the shipped English package. A word that only the second lookup can find proves that
 /// the later step reads the cleanup result and that the two lookups do not conflict on one word.