Nursery: Initial integration
StimulusProducer: syncAwaitAllSettlements should pump caller io_context
This commit is contained in:
@@ -3,10 +3,9 @@
|
||||
#include <chrono>
|
||||
#include <algorithm>
|
||||
#include <boost/asio/io_context.hpp>
|
||||
#include <boost/asio/deadline_timer.hpp>
|
||||
#include <boost/system/error_code.hpp>
|
||||
#include <opts.h>
|
||||
#include <componentThread.h>
|
||||
#include <adapters/boostAsio/deadlineTimerAReq.h>
|
||||
#include <spinscale/spinLock.h>
|
||||
#include <user/stimulusProducer.h>
|
||||
#include <user/stimulusBuffer.h>
|
||||
@@ -88,115 +87,137 @@ void StimulusProducer::destroyAttachedStimulusBuffer(
|
||||
}
|
||||
}
|
||||
|
||||
sscl::co::NonViralNonPostingInvoker StimulusProducer::productionCDaemon(
|
||||
std::exception_ptr &, std::function<void()>,
|
||||
sscl::SyncCancelerForAsyncWork &canceler)
|
||||
{
|
||||
int nextDelayMs = CONFIG_STIMBUFF_FRAME_PERIOD_MS;
|
||||
|
||||
do
|
||||
{
|
||||
bool shouldProduceFrame = false;
|
||||
|
||||
if (!canceler.execUncancelableSegmentOrAbort([&]()
|
||||
{
|
||||
/** EXPLANATION:
|
||||
* We need to ensure that there's only ever one stimframe being
|
||||
* produced during any CONFIG_STIMBUFF_FRAME_PERIOD_MS period. To
|
||||
* guarantee this, we use a spinlock.
|
||||
*
|
||||
* When a new frame is to be produced, the async producer will
|
||||
* first acquire the frameAssemblyLimiter spinlock. This ensures
|
||||
* that only one stimframe is produced during any
|
||||
* CONFIG_STIMBUFF_FRAME_PERIOD_MS interval. When the next
|
||||
* timeout fires, it checks if the previous stimframe has
|
||||
* finished production. If the previous stimframe is still
|
||||
* being produced, we will sleep for
|
||||
* CONFIG_STIMBUFF_FRAME_RETRY_DELAY_MS ms before retrying.
|
||||
*/
|
||||
if (frameAssemblyRateLimiter.tryAcquire())
|
||||
{
|
||||
nextDelayMs = CONFIG_STIMBUFF_FRAME_PERIOD_MS;
|
||||
|
||||
// Check if we're ending a deferral period
|
||||
if (nDeferrals > 0)
|
||||
{
|
||||
auto deferralEndTime =
|
||||
std::chrono::high_resolution_clock::now();
|
||||
auto duration = deferralEndTime - deferralStartTime;
|
||||
auto durationMs = std::chrono::duration_cast<
|
||||
std::chrono::milliseconds>(duration);
|
||||
|
||||
std::cout << "productionCDaemon: Deferral period ended. "
|
||||
<< "Total deferrals: " << nDeferrals
|
||||
<< ", Duration: " << durationMs.count()
|
||||
<< "ms" << std::endl;
|
||||
|
||||
nDeferrals = 0;
|
||||
}
|
||||
|
||||
shouldProduceFrame = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
nextDelayMs = CONFIG_STIMBUFF_FRAME_RETRY_DELAY_MS;
|
||||
|
||||
++nDeferrals;
|
||||
// If this is first deferral, capture start stamp and print message
|
||||
if (nDeferrals == 1)
|
||||
{
|
||||
deferralStartTime =
|
||||
std::chrono::high_resolution_clock::now();
|
||||
std::cerr << "productionCDaemon: Deferral period "
|
||||
"beginning. Configured deferral period: "
|
||||
<< nextDelayMs << "ms" << std::endl;
|
||||
}
|
||||
}
|
||||
}))
|
||||
{ break; }
|
||||
|
||||
if (shouldProduceFrame)
|
||||
{
|
||||
/** EXPLANATION:
|
||||
* Call the derived class's frame production handler
|
||||
* Note: The derived class's frame production handler (aka
|
||||
* its implementation of stimFrameProductionTimesliceCInd()) must
|
||||
* release the lock when frame production completes
|
||||
*/
|
||||
co_await stimFrameProductionTimesliceCInd(canceler);
|
||||
}
|
||||
else if (OptionParser::getOptions().verbose)
|
||||
{
|
||||
std::cerr << "productionCDaemon: Deferring frame by "
|
||||
<< nextDelayMs << "ms due to rate limit." << std::endl;
|
||||
}
|
||||
|
||||
// Schedule the next timeout using the provided delay
|
||||
const bool expiredNormally = co_await
|
||||
adapters::boostAsio::getDeadlineTimerAReqAwaiter(
|
||||
ioContext,
|
||||
daemonTimer,
|
||||
boost::posix_time::milliseconds(nextDelayMs));
|
||||
|
||||
if (!expiredNormally) {
|
||||
// Timer was cancelled, which is expected when stopping
|
||||
break;
|
||||
}
|
||||
|
||||
// FIXME: We should be able to release the start/stop lock at this point.
|
||||
|
||||
} while (!canceler.isCancellationRequested());
|
||||
|
||||
co_return;
|
||||
}
|
||||
|
||||
void StimulusProducer::start()
|
||||
{
|
||||
std::cout << __func__ << ": Starting stimulus producer for device "
|
||||
<< deviceAttachmentSpec->deviceSelector << std::endl;
|
||||
|
||||
nDeferrals = 0;
|
||||
taskNursery.openAdmission();
|
||||
taskNursery.launch(
|
||||
[this](sscl::co::NonViralTaskNursery::Slot::Lease &lease)
|
||||
{
|
||||
return productionCDaemon(
|
||||
lease.getExceptionStorage(),
|
||||
lease.getCallerLambda(),
|
||||
lease.getSyncCanceler());
|
||||
});
|
||||
}
|
||||
|
||||
void StimulusProducer::stop()
|
||||
{
|
||||
(void)stimulusProducerCanceler.requestStop();
|
||||
|
||||
// Cancel timer immediately
|
||||
timer.cancel();
|
||||
daemonTimer.cancel();
|
||||
taskNursery.requestCancelOnAll();
|
||||
taskNursery.closeAdmission();
|
||||
taskNursery.syncAwaitAllSettlements(
|
||||
sscl::ComponentThread::getSelf()->getIoContext());
|
||||
|
||||
std::cout << __func__ << ": Stopped stimulus producer for device "
|
||||
<< deviceAttachmentSpec->deviceSelector << std::endl;
|
||||
}
|
||||
|
||||
void StimulusProducer::scheduleNextTimeout(int delayMs)
|
||||
{
|
||||
if (stimulusProducerCanceler.isCancellationRequestedUnlocked())
|
||||
{ return; }
|
||||
|
||||
// Schedule the next timeout using the provided delay
|
||||
timer.expires_from_now(
|
||||
boost::posix_time::milliseconds(delayMs));
|
||||
|
||||
timer.async_wait(
|
||||
std::bind(
|
||||
&StimulusProducer::onTimeout, this, std::placeholders::_1));
|
||||
}
|
||||
|
||||
void StimulusProducer::onTimeout(const boost::system::error_code& error)
|
||||
{
|
||||
// Timer was cancelled, which is expected when stopping
|
||||
if (error == boost::asio::error::operation_aborted) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (error)
|
||||
{
|
||||
std::cerr << "StimulusProducer: Timer error: " << error.message()
|
||||
<< std::endl;
|
||||
return;
|
||||
}
|
||||
|
||||
sscl::SpinLock::Guard guard(stimulusProducerCanceler.s.lock);
|
||||
if (stimulusProducerCanceler.isCancellationRequestedUnlocked())
|
||||
{ return; }
|
||||
|
||||
/** EXPLANATION:
|
||||
* We need to ensure that there's only ever one stimframe being produced
|
||||
* during any CONFIG_STIMBUFF_FRAME_PERIOD_MS period. To guarantee this, we
|
||||
* use a spinlock.
|
||||
*
|
||||
* When a new frame is to be produced, the async producer will first acquire
|
||||
* the frameAssemblyLimiter spinlock. This way, when the next timeout is
|
||||
* fired it can check whether its predecessor stimframe has finished being
|
||||
* produced. If the preceding stimframe is still being produced, then we'll
|
||||
* sleep for CONFIG_STIMBUFF_FRAME_RETRY_DELAY_MS ms before trying again.
|
||||
*/
|
||||
int nextWakeupDelayMs;
|
||||
bool deferred = false;
|
||||
if (frameAssemblyRateLimiter.tryAcquire())
|
||||
{
|
||||
nextWakeupDelayMs = CONFIG_STIMBUFF_FRAME_PERIOD_MS;
|
||||
|
||||
// Check if we're ending a deferral period
|
||||
if (nDeferrals > 0)
|
||||
{
|
||||
auto deferralEndTime = std::chrono::high_resolution_clock::now();
|
||||
auto duration = deferralEndTime - deferralStartTime;
|
||||
auto durationMs = std::chrono::duration_cast<
|
||||
std::chrono::milliseconds>(duration);
|
||||
|
||||
std::cout << __func__ << ": Deferral period ended. "
|
||||
<< "Total deferrals: " << nDeferrals
|
||||
<< ", Duration: " << durationMs.count() << "ms" << std::endl;
|
||||
|
||||
nDeferrals = 0;
|
||||
}
|
||||
|
||||
/** EXPLANATION:
|
||||
* Call the derived class's frame production handler
|
||||
* Note: The derived class's frame production handler (aka
|
||||
* its implementation of stimFrameProductionTimesliceInd()) must
|
||||
* release the lock when frame production completes
|
||||
*/
|
||||
stimFrameProductionTimesliceInd();
|
||||
}
|
||||
else
|
||||
{
|
||||
nextWakeupDelayMs = CONFIG_STIMBUFF_FRAME_RETRY_DELAY_MS;
|
||||
deferred = true;
|
||||
|
||||
++nDeferrals;
|
||||
// If this is first deferral, capture start stamp and print message
|
||||
if (nDeferrals == 1)
|
||||
{
|
||||
deferralStartTime = std::chrono::high_resolution_clock::now();
|
||||
std::cerr << __func__ << ": Deferral period beginning. "
|
||||
"Configured deferral period: " << nextWakeupDelayMs << "ms"
|
||||
<< std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
scheduleNextTimeout(nextWakeupDelayMs);
|
||||
|
||||
// FIXME: We should be able to release the start/stop lock at this point.
|
||||
|
||||
if (deferred && OptionParser::getOptions().verbose)
|
||||
{
|
||||
std::cerr << __func__ << ": Deferring frame by " << nextWakeupDelayMs
|
||||
<< "ms due to rate limit." << std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace stim_buff
|
||||
} // namespace smo
|
||||
|
||||
Reference in New Issue
Block a user