Nursery: Initial integration
StimulusProducer: syncAwaitAllSettlements should pump caller io_context
This commit is contained in:
@@ -1,161 +1,88 @@
|
||||
#include <config.h>
|
||||
#include <chrono>
|
||||
#include <iostream>
|
||||
#include <functional>
|
||||
#include <componentThread.h>
|
||||
#include <adapters/boostAsio/deadlineTimerAReq.h>
|
||||
#include <deviceManager/deviceReattacher.h>
|
||||
#include <deviceManager/deviceManager.h>
|
||||
#include <marionette/marionetteThread.h>
|
||||
#include <spinscale/co/nonViralCompletion.h>
|
||||
|
||||
namespace smo {
|
||||
namespace device {
|
||||
|
||||
namespace {
|
||||
|
||||
constexpr unsigned int reattachInFlightStaleThresholdMultiplier = 4;
|
||||
|
||||
} // namespace
|
||||
|
||||
DeviceReattacher::DeviceReattacher(
|
||||
DeviceManager& parent, std::shared_ptr<sscl::ComponentThread> ioThread)
|
||||
: parent(parent), ioThread(ioThread), timer(ioThread->getIoContext())
|
||||
: parent(parent),
|
||||
ioThread(ioThread), daemonTimer(ioThread->getIoContext())
|
||||
{
|
||||
/** EXPLANATION:
|
||||
* The thread on which DeviceReattacher runs is whichever thread executes
|
||||
* the io_context that owns deadline_timer. Timer async_wait handlers
|
||||
* (onTimeout, holdReattachCReq, reattachKnownListCReq) are dispatched on
|
||||
* that thread. ioThread selects that io_context here; start() only arms
|
||||
* the timer on it.
|
||||
* deviceReattacherCDaemon is a dynamic posting non-viral coroutine: start()
|
||||
* passes ExplicitPostTarget{ioThread->getIoContext()} so the daemon body
|
||||
* always runs on ioThread. daemonTimer is reused each loop iteration.
|
||||
*/
|
||||
}
|
||||
|
||||
mrntt::MrnttNonViralNonPostingInvoker DeviceReattacher::reattachKnownListCReq(
|
||||
sscl::co::DynamicNonViralPostingInvoker
|
||||
DeviceReattacher::deviceReattacherCDaemon(
|
||||
[[maybe_unused]] sscl::co::ExplicitPostTarget postTarget,
|
||||
[[maybe_unused]] std::exception_ptr &exceptionPtr,
|
||||
[[maybe_unused]] std::function<void()> callback)
|
||||
[[maybe_unused]] std::function<void()> callback,
|
||||
sscl::SyncCancelerForAsyncWork &canceler)
|
||||
{
|
||||
/** EXPLANATION:
|
||||
* Non-posting: invoked from holdReattachCReq on the timer callback thread
|
||||
* (see ctor). Nested DeviceManager attach APIs still post to MRNTT as
|
||||
* needed via their own viral posting invokers.
|
||||
*/
|
||||
co_await parent.attachAllUnattachedDevicesFromKnownListCReq();
|
||||
boost::asio::io_context &timerIoContext =
|
||||
sscl::ComponentThread::getSelf()->getIoContext();
|
||||
const auto periodMs = boost::posix_time::milliseconds(
|
||||
CONFIG_MRNTT_DEVMGR_REATTACHER_PERIOD_MS);
|
||||
|
||||
while (!canceler.isCancellationRequested())
|
||||
{
|
||||
const bool expiredNormally = co_await
|
||||
adapters::boostAsio::getDeadlineTimerAReqAwaiter(
|
||||
timerIoContext, daemonTimer, periodMs);
|
||||
|
||||
if (!expiredNormally) {
|
||||
break;
|
||||
}
|
||||
|
||||
co_await parent.attachAllUnattachedDevicesFromKnownListCReq();
|
||||
}
|
||||
|
||||
co_return;
|
||||
}
|
||||
|
||||
void DeviceReattacher::start()
|
||||
{
|
||||
deviceReattacherCanceler.startAcceptingWork();
|
||||
scheduleNextTimeout();
|
||||
}
|
||||
|
||||
void DeviceReattacher::stop()
|
||||
{
|
||||
{
|
||||
sscl::SpinLock::Guard guard(deviceReattacherCanceler.s.lock);
|
||||
reattachOpInFlight = false;
|
||||
deviceReattacherCanceler.s.rsrc.shouldContinue = false;
|
||||
/** EXPLANATION:
|
||||
* Do not call reattachCReqInvoker.reset() here. Forcibly destroying
|
||||
* the invoker would tear down an in-flight reattach coroutine frame
|
||||
* mid-operation. During normal program teardown the optional (and
|
||||
* its invoker) are destroyed with the rest of the binary anyway; leave
|
||||
* a running reattach time to finish if shutdown races with it.
|
||||
*/
|
||||
}
|
||||
|
||||
timer.cancel();
|
||||
}
|
||||
|
||||
void DeviceReattacher::scheduleNextTimeout()
|
||||
{
|
||||
if (deviceReattacherCanceler.isCancellationRequestedUnlocked()) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Schedule the next timeout using the configured period
|
||||
timer.expires_from_now(
|
||||
boost::posix_time::milliseconds(
|
||||
CONFIG_MRNTT_DEVMGR_REATTACHER_PERIOD_MS));
|
||||
|
||||
timer.async_wait(
|
||||
std::bind(&DeviceReattacher::onTimeout, this, std::placeholders::_1));
|
||||
}
|
||||
|
||||
void DeviceReattacher::holdReattachCReq()
|
||||
{
|
||||
reattachOpInFlight = true;
|
||||
lastReattachReqTimestamp = std::chrono::steady_clock::now();
|
||||
|
||||
reattachCReqInvoker.reset();
|
||||
reattachCReqInvoker.emplace(reattachKnownListCReq(
|
||||
reattachLifetimeExceptionPtr,
|
||||
[this]()
|
||||
taskNursery.openAdmission();
|
||||
taskNursery.launch(
|
||||
[this](sscl::co::NonViralTaskNursery::Slot::Lease &lease)
|
||||
{
|
||||
sscl::co::NonViralCompletion nvc(reattachLifetimeExceptionPtr);
|
||||
return deviceReattacherCDaemon(
|
||||
sscl::co::ExplicitPostTarget{ioThread->getIoContext()},
|
||||
lease.getExceptionStorage(),
|
||||
lease.getCallerLambda(),
|
||||
lease.getSyncCanceler());
|
||||
},
|
||||
[](std::exception_ptr &exceptionPtr)
|
||||
{
|
||||
sscl::co::NonViralCompletion nvc(exceptionPtr);
|
||||
if (nvc.hasException())
|
||||
{
|
||||
try {
|
||||
nvc.checkAndRethrowException();
|
||||
} catch (const std::exception &e) {
|
||||
std::cerr << "DeviceReattacher: " << e.what()
|
||||
<< std::endl;
|
||||
std::cerr << "DeviceReattacher: "
|
||||
<< e.what() << std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
sscl::SpinLock::Guard guard(deviceReattacherCanceler.s.lock);
|
||||
reattachOpInFlight = false;
|
||||
}));
|
||||
});
|
||||
}
|
||||
|
||||
void DeviceReattacher::onTimeout(const boost::system::error_code& error)
|
||||
void DeviceReattacher::stop()
|
||||
{
|
||||
// Timer was cancelled, which is expected when stopping
|
||||
if (error == boost::asio::error::operation_aborted) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (error)
|
||||
{
|
||||
std::cerr << "DeviceReattacher: Timer error: " << error.message()
|
||||
<< std::endl;
|
||||
return;
|
||||
}
|
||||
|
||||
sscl::SpinLock::Guard guard(deviceReattacherCanceler.s.lock);
|
||||
if (deviceReattacherCanceler.isCancellationRequestedUnlocked()) {
|
||||
return;
|
||||
}
|
||||
|
||||
const auto staleThreshold = std::chrono::milliseconds(
|
||||
reattachInFlightStaleThresholdMultiplier
|
||||
* CONFIG_MRNTT_DEVMGR_REATTACHER_PERIOD_MS);
|
||||
|
||||
// Attempt to reattach all unattached devices from the known list
|
||||
if (!reattachOpInFlight)
|
||||
{
|
||||
holdReattachCReq();
|
||||
}
|
||||
else
|
||||
{
|
||||
const auto elapsedSinceLastReattachReq =
|
||||
std::chrono::steady_clock::now() - lastReattachReqTimestamp;
|
||||
|
||||
if (elapsedSinceLastReattachReq >= staleThreshold)
|
||||
{
|
||||
std::cerr << "DeviceReattacher: Reattach op still in flight after "
|
||||
<< std::chrono::duration_cast<std::chrono::milliseconds>(
|
||||
elapsedSinceLastReattachReq).count()
|
||||
<< "ms (threshold "
|
||||
<< staleThreshold.count()
|
||||
<< "ms); forcing a new reattach request."
|
||||
<< std::endl;
|
||||
holdReattachCReq();
|
||||
}
|
||||
}
|
||||
|
||||
// Schedule the next timeout
|
||||
scheduleNextTimeout();
|
||||
daemonTimer.cancel();
|
||||
taskNursery.requestCancelOnAll();
|
||||
taskNursery.closeAdmission();
|
||||
taskNursery.syncAwaitAllSettlements(ioThread->getIoContext());
|
||||
}
|
||||
|
||||
} // namespace device
|
||||
|
||||
Reference in New Issue
Block a user