dtourolle
28e06675f5
push_blocking parked a scheduler worker inside the push. Nodes own a private single-thread pool, so the parked thread was the only one that could drain that node's own input — hold-and-wait, and under sustained backpressure four nodes of a five-node chain slept in nanosleep at once. channel.hpp already warned about this for sentinels; it applies just as much to data pushes. The scheduler was purely input-driven: on_input_ready() wakes a node when input arrives, with no counterpart for "my output has room". Lacking that signal, blocking the thread was the only way to handle a full output. This adds the missing half. - Channel::try_push + has_space + set_space_callback; the callback fires from both pop() and try_pop_now(). - PoolNode/PoolObjectNode keep a one-slot pending_ buffer with per-element done flags, so a retry cannot duplicate an already-accepted element. One slot suffices because queued_ admits at most one fire_once per node. - The re-check after clearing queued_ closes the lost-wakeup race where a space callback fires while the flag is still up and is swallowed. Two bugs surfaced once nodes actually parked, both fixed here: - pop_one reports an *empty* channel as ChannelClosedError, which is also the node's "upstream finished, self-stop" signal. A node woken by output space with empty inputs therefore killed itself. fire_once now releases the worker when its inputs are not ready rather than falling through. - The drained-park path resubmitted unconditionally instead of via on_input_ready(), firing nodes with nothing to read. compute_priority is now output-aware: mean output fill is deducted from mean input fill, mapped as 0.5·(1 + in - out). Input fill alone asks only "how much work is waiting for me"; a node whose outputs are already full cannot deliver, so running it just parks it again and wastes the slot while the node that would drain that channel waits behind it. The scheduler now favours whoever is furthest downstream of a bottleneck. Also adds a network-level error listener. A node's exception was discarded at the node boundary and survived only as a Closed event, which reports that a node stopped but not why — that missing detail is what made the above slow to diagnose. INode::set_network_error_callback plus StaticNetwork::set_error_handler forward it to the application. Tests: 121/121. test_backpressure_deadlock drives a five-node chain with capacity-2 channels against a slow sink and fails on the old code. The four test_pool_node overflow tests now assert parking rather than the removed drop-and-report behaviour. Known-incomplete: a rare hang remains, roughly 1 run in 20 against a 300s timeout, down from every run failing. Committed because the fix is a large strict improvement and the residual case needs its own reproduction.
54 lines
2.2 KiB
C++
54 lines
2.2 KiB
C++
#pragma once
|
|
#include "diagnostics.hpp"
|
|
#include <chrono>
|
|
#include <functional>
|
|
#include <string>
|
|
#include <string_view>
|
|
|
|
namespace kpn {
|
|
|
|
// Called when a node's function throws. Return true to skip the failed
|
|
// invocation and keep running, false to stop the node.
|
|
using NodeErrorHandler = std::function<bool(std::string_view node_name, std::exception_ptr)>;
|
|
|
|
// Lightweight timestamp-only callback fired on per-node events.
|
|
// The node name is known at registration time so it is not included here.
|
|
using NodeEventCallback = std::function<void(std::chrono::steady_clock::time_point)>;
|
|
|
|
// Event types reported to the network-level aggregate callback.
|
|
enum class NodeEvent { Overflow, Closed };
|
|
|
|
// ── INode — type-erased interface for Network / watchdog ─────────────────────
|
|
|
|
struct INode {
|
|
virtual ~INode() = default;
|
|
virtual void start() = 0;
|
|
virtual void stop() = 0;
|
|
virtual bool running() const = 0;
|
|
virtual const NodeStats& stats() const = 0;
|
|
virtual NodeSnapshot node_snapshot(const std::string& name, double elapsed_s) const = 0;
|
|
virtual void set_name(std::string name) = 0;
|
|
|
|
// Network-injected callbacks (slot 1 of each node's callback array).
|
|
// Default no-ops; overridden by PoolNode, PoolObjectNode, InterruptNode.
|
|
virtual void set_network_overflow_callback(NodeEventCallback) {}
|
|
virtual void set_network_closed_callback(NodeEventCallback) {}
|
|
|
|
// Network-level error listener. Consulted when a node's function throws
|
|
// and no per-node handler resolved it. Without this the exception is
|
|
// discarded and the failure is only visible as a Closed event, which says
|
|
// a node stopped but not why — the difference between a diagnosis and a
|
|
// guess. Same contract as NodeErrorHandler: true to continue, false to
|
|
// stop the node.
|
|
virtual void set_network_error_callback(NodeErrorHandler) {}
|
|
|
|
// halt(): alias for stop() — immediate, discards in-flight work.
|
|
virtual void halt() { stop(); }
|
|
|
|
// shutdown(): graceful drain before stopping. Base implementation falls
|
|
// back to stop(). Network and StaticNetwork override with topo-ordered drain.
|
|
virtual void shutdown() { stop(); }
|
|
};
|
|
|
|
} // namespace kpn
|