{

auto* state = (DeviceState*)handle->data;

state->loopReason |= DeviceState::TIMER_EXPIRED;

{

auto* state = (DeviceState*)s->data;

state->loopReason |= DeviceState::METRICS_MUST_FLUSH;

ServiceRegistryRef& ref;

locked_execution(ServiceRegistryRef& ref_) : ref(ref_) { ref.lock(); }

~locked_execution() { ref.unlock(); }

: mRunningDevice{running},

mConfigRegistry{nullptr},

mServiceRegistry{registry}

{

GetConfig()->Subscribe<std::string>("dpl", [&registry = mServiceRegistry](const std::string& key, std::string value) {

if (key == "cleanup") {

auto ref = ServiceRegistryRef{registry, ServiceRegistry::globalDeviceSalt()};

auto& deviceState = ref.get<DeviceState>();

int64_t cleanupCount = deviceState.cleanupCount.load();

int64_t newCleanupCount = std::stoll(value);

if (newCleanupCount <= cleanupCount) {

return;

}

deviceState.cleanupCount.store(newCleanupCount);

for (auto& info : deviceState.inputChannelInfos) {

fair::mq::Parts parts;

while (info.channel->Receive(parts, 0)) {

LOGP(debug, "Dropping {} parts", parts.Size());

if (parts.Size() == 0) {

break;

}

}

}

}

});

std::function<void(const fair::mq::State)> stateWatcher = [this, &registry = mServiceRegistry](const fair::mq::State state) -> void {

auto ref = ServiceRegistryRef{registry, ServiceRegistry::globalDeviceSalt()};

auto& deviceState = ref.get<DeviceState>();

auto& control = ref.get<ControlService>();

auto& callbacks = ref.get<CallbackService>();

control.notifyDeviceState(fair::mq::GetStateName(state));

callbacks.call<CallbackService::Id::DeviceStateChanged>(ServiceRegistryRef{ref}, (int)state);

if (deviceState.nextFairMQState.empty() == false) {

auto state = deviceState.nextFairMQState.back();

(void)this->ChangeState(state);

deviceState.nextFairMQState.pop_back();

}

};

// 99 is to execute DPL callbacks last

this->SubscribeToStateChange("99-dpl", stateWatcher);

// One task for now.

mStreams.resize(1);

mHandles.resize(1);

ServiceRegistryRef ref{mServiceRegistry};

mAwakeHandle = (uv_async_t*)malloc(sizeof(uv_async_t));

auto& state = ref.get<DeviceState>();

assert(state.loop);

int res = uv_async_init(state.loop, mAwakeHandle, on_communication_requested);

mAwakeHandle->data = &state;

if (res < 0) {

LOG(error) << "Unable to initialise subscription";

}

/// This should post a message on the queue...

SubscribeToNewTransition("dpl", [wakeHandle = mAwakeHandle](fair::mq::Transition t) {

int res = uv_async_send(wakeHandle);

if (res < 0) {

LOG(error) << "Unable to notify subscription";

}

LOG(debug) << "State transition requested";

});

{

auto* task = (TaskStreamInfo*)handle->data;

auto ref = ServiceRegistryRef{*task->registry, ServiceRegistry::globalStreamSalt(task->id.index + 1)};

// We create a new signpost interval for this specific data processor. Same id, same data processor.

auto& dataProcessorContext = ref.get<DataProcessorContext>();

O2_SIGNPOST_ID_FROM_POINTER(sid, device, &dataProcessorContext);

O2_SIGNPOST_START(device, sid, "run_callback", "Starting run callback on stream %d", task->id.index);

DataProcessingDevice::doPrepare(ref);

DataProcessingDevice::doRun(ref);

O2_SIGNPOST_END(device, sid, "run_callback", "Done processing data for stream %d", task->id.index);

{

auto* task = (TaskStreamInfo*)handle->data;

// Notice that the completion, while running on the main thread, still

// has a salt which is associated to the actual stream which was doing the computation

auto ref = ServiceRegistryRef{*task->registry, ServiceRegistry::globalStreamSalt(task->id.index + 1)};

auto& state = ref.get<DeviceState>();

auto& quotaEvaluator = ref.get<ComputingQuotaEvaluator>();

using o2::monitoring::Metric;

using o2::monitoring::Monitoring;

using o2::monitoring::tags::Key;

using o2::monitoring::tags::Value;

static std::function<void(ComputingQuotaOffer const&, ComputingQuotaStats&)> reportConsumedOffer = [ref](ComputingQuotaOffer const& accumulatedConsumed, ComputingQuotaStats& stats) {

auto& dpStats = ref.get<DataProcessingStats>();

stats.totalConsumedBytes += accumulatedConsumed.sharedMemory;

// For now we give back the offer if we did not use it completely.

// In principle we should try to run until the offer is fully consumed.

stats.totalConsumedTimeslices += std::min<int64_t>(accumulatedConsumed.timeslices, 1);

dpStats.updateStats({static_cast<short>(ProcessingStatsId::SHM_OFFER_BYTES_CONSUMED), DataProcessingStats::Op::Set, stats.totalConsumedBytes});

dpStats.updateStats({static_cast<short>(ProcessingStatsId::TIMESLICE_OFFER_NUMBER_CONSUMED), DataProcessingStats::Op::Set, stats.totalConsumedTimeslices});

dpStats.processCommandQueue();

assert(stats.totalConsumedBytes == dpStats.metrics[(short)ProcessingStatsId::SHM_OFFER_BYTES_CONSUMED]);

assert(stats.totalConsumedTimeslices == dpStats.metrics[(short)ProcessingStatsId::TIMESLICE_OFFER_NUMBER_CONSUMED]);

};

static std::function<void(ComputingQuotaOffer const&, ComputingQuotaStats const&)> reportExpiredOffer = [ref](ComputingQuotaOffer const& offer, ComputingQuotaStats const& stats) {

auto& dpStats = ref.get<DataProcessingStats>();

dpStats.updateStats({static_cast<short>(ProcessingStatsId::RESOURCE_OFFER_EXPIRED), DataProcessingStats::Op::Set, stats.totalExpiredOffers});

dpStats.updateStats({static_cast<short>(ProcessingStatsId::ARROW_BYTES_EXPIRED), DataProcessingStats::Op::Set, stats.totalExpiredBytes});

dpStats.updateStats({static_cast<short>(ProcessingStatsId::TIMESLICE_NUMBER_EXPIRED), DataProcessingStats::Op::Set, stats.totalExpiredTimeslices});

dpStats.processCommandQueue();

};

for (auto& consumer : state.offerConsumers) {

quotaEvaluator.consume(task->id.index, consumer, reportConsumedOffer);

}

state.offerConsumers.clear();

quotaEvaluator.handleExpired(reportExpiredOffer);

quotaEvaluator.dispose(task->id.index);

task->running = false;

enum struct PollerState : char { Stopped,

Disconnected,

Connected,

Suspended };

char const* name = nullptr;

uv_loop_t* loop = nullptr;

DataProcessingDevice* device = nullptr;

DeviceState* state = nullptr;

fair::mq::Socket* socket = nullptr;

InputChannelInfo* channelInfo = nullptr;

int fd = -1;

bool read = true;

PollerState pollerState = PollerState::Stopped;

{

auto* context = (PollerContext*)poller->data;

assert(context);

O2_SIGNPOST_ID_FROM_POINTER(sid, sockets, poller);

context->state->loopReason |= DeviceState::DATA_SOCKET_POLLED;

switch (events) {

case UV_READABLE: {

O2_SIGNPOST_EVENT_EMIT(sockets, sid, "socket_state", "Data pending on socket for channel %{public}s", context->name);

context->state->loopReason |= DeviceState::DATA_INCOMING;

} break;

case UV_WRITABLE: {

O2_SIGNPOST_END(sockets, sid, "socket_state", "Socket connected for channel %{public}s", context->name);

if (context->read) {

O2_SIGNPOST_START(sockets, sid, "socket_state", "Socket connected for read in context %{public}s", context->name);

uv_poll_start(poller, UV_READABLE | UV_DISCONNECT | UV_PRIORITIZED, &on_socket_polled);

context->state->loopReason |= DeviceState::DATA_CONNECTED;

} else {

O2_SIGNPOST_START(sockets, sid, "socket_state", "Socket connected for write for channel %{public}s", context->name);

context->state->loopReason |= DeviceState::DATA_OUTGOING;

// If the socket is writable, fairmq will handle the rest, so we can stop polling and

// just wait for the disconnect.

uv_poll_start(poller, UV_DISCONNECT | UV_PRIORITIZED, &on_socket_polled);

}

context->pollerState = PollerContext::PollerState::Connected;

} break;

case UV_DISCONNECT: {

O2_SIGNPOST_END(sockets, sid, "socket_state", "Socket disconnected in context %{public}s", context->name);

} break;

case UV_PRIORITIZED: {

O2_SIGNPOST_EVENT_EMIT(sockets, sid, "socket_state", "Socket prioritized for context %{public}s", context->name);

} break;

}

// We do nothing, all the logic for now stays in DataProcessingDevice::doRun()

{

O2_SIGNPOST_ID_FROM_POINTER(sid, sockets, poller);

auto* context = (PollerContext*)poller->data;

context->state->loopReason |= DeviceState::OOB_ACTIVITY;

if (status < 0) {

LOGP(fatal, "Error while polling {}: {}", context->name, status);

uv_poll_start(poller, UV_WRITABLE, &on_out_of_band_polled);

}

switch (events) {

case UV_READABLE: {

O2_SIGNPOST_EVENT_EMIT(sockets, sid, "socket_state", "Data pending on socket for channel %{public}s", context->name);

context->state->loopReason |= DeviceState::DATA_INCOMING;

assert(context->channelInfo);

context->channelInfo->readPolled = true;

} break;

case UV_WRITABLE: {

O2_SIGNPOST_END(sockets, sid, "socket_state", "OOB socket connected for channel %{public}s", context->name);

if (context->read) {

O2_SIGNPOST_START(sockets, sid, "socket_state", "OOB socket connected for read in context %{public}s", context->name);

uv_poll_start(poller, UV_READABLE | UV_DISCONNECT | UV_PRIORITIZED, &on_out_of_band_polled);

} else {

O2_SIGNPOST_START(sockets, sid, "socket_state", "OOB socket connected for write for channel %{public}s", context->name);

context->state->loopReason |= DeviceState::DATA_OUTGOING;

}

} break;

case UV_DISCONNECT: {

O2_SIGNPOST_END(sockets, sid, "socket_state", "OOB socket disconnected in context %{public}s", context->name);

uv_poll_start(poller, UV_WRITABLE, &on_out_of_band_polled);

} break;

case UV_PRIORITIZED: {

O2_SIGNPOST_EVENT_EMIT(sockets, sid, "socket_state", "OOB socket prioritized for context %{public}s", context->name);

} break;

}

// We do nothing, all the logic for now stays in DataProcessingDevice::doRun()

{

auto ref = ServiceRegistryRef{mServiceRegistry};

auto& context = ref.get<DataProcessorContext>();

auto& spec = getRunningDevice(mRunningDevice, ref);

O2_SIGNPOST_ID_FROM_POINTER(cid, device, &context);

O2_SIGNPOST_START(device, cid, "Init", "Entering Init callback.");

context.statelessProcess = spec.algorithm.onProcess;

context.statefulProcess = nullptr;

context.error = spec.algorithm.onError;

context.initError = spec.algorithm.onInitError;

auto configStore = DeviceConfigurationHelpers::getConfiguration(mServiceRegistry, spec.name.c_str(), spec.options);

if (configStore == nullptr) {

std::vector<std::unique_ptr<ParamRetriever>> retrievers;

retrievers.emplace_back(std::make_unique<FairOptionsRetriever>(GetConfig()));

configStore = std::make_unique<ConfigParamStore>(spec.options, std::move(retrievers));

configStore->preload();

configStore->activate();

}

using boost::property_tree::ptree;

/// Dump the configuration so that we can get it from the driver.

for (auto& entry : configStore->store()) {

std::stringstream ss;

std::string str;

if (entry.second.empty() == false) {

boost::property_tree::json_parser::write_json(ss, entry.second, false);

str = ss.str();

str.pop_back(); // remove EoL

} else {

str = entry.second.get_value<std::string>();

}

std::string configString = fmt::format("[CONFIG] {}={} 1 {}", entry.first, str, configStore->provenance(entry.first.c_str())).c_str();

mServiceRegistry.get<DriverClient>(ServiceRegistry::globalDeviceSalt()).tell(configString.c_str());

}

mConfigRegistry = std::make_unique<ConfigParamRegistry>(std::move(configStore));

// Setup the error handlers for init

if (context.initError) {

context.initErrorHandling = [&errorCallback = context.initError,

&serviceRegistry = mServiceRegistry](RuntimeErrorRef e) {

/// FIXME: we should pass the salt in, so that the message

/// can access information which were stored in the stream.

ServiceRegistryRef ref{serviceRegistry, ServiceRegistry::globalDeviceSalt()};

auto& context = ref.get<DataProcessorContext>();

auto& err = error_from_ref(e);

O2_SIGNPOST_ID_FROM_POINTER(cid, device, &context);

O2_SIGNPOST_EVENT_EMIT_ERROR(device, cid, "Init", "Exception caught while in Init: %{public}s. Invoking errorCallback.", err.what);

BacktraceHelpers::demangled_backtrace_symbols(err.backtrace, err.maxBacktrace, STDERR_FILENO);

auto& stats = ref.get<DataProcessingStats>();

stats.updateStats({(int)ProcessingStatsId::EXCEPTION_COUNT, DataProcessingStats::Op::Add, 1});

InitErrorContext errorContext{ref, e};

errorCallback(errorContext);

};

} else {

context.initErrorHandling = [&serviceRegistry = mServiceRegistry](RuntimeErrorRef e) {

auto& err = error_from_ref(e);

/// FIXME: we should pass the salt in, so that the message

/// can access information which were stored in the stream.

ServiceRegistryRef ref{serviceRegistry, ServiceRegistry::globalDeviceSalt()};

auto& context = ref.get<DataProcessorContext>();

O2_SIGNPOST_ID_FROM_POINTER(cid, device, &context);

O2_SIGNPOST_EVENT_EMIT_ERROR(device, cid, "Init", "Exception caught while in Init: %{public}s. Exiting with 1.", err.what);

BacktraceHelpers::demangled_backtrace_symbols(err.backtrace, err.maxBacktrace, STDERR_FILENO);

auto& stats = ref.get<DataProcessingStats>();

stats.updateStats({(int)ProcessingStatsId::EXCEPTION_COUNT, DataProcessingStats::Op::Add, 1});

exit(1);

};

}

context.expirationHandlers.clear();

context.init = spec.algorithm.onInit;

if (context.init) {

static bool noCatch = getenv("O2_NO_CATCHALL_EXCEPTIONS") && strcmp(getenv("O2_NO_CATCHALL_EXCEPTIONS"), "0");

InitContext initContext{*mConfigRegistry, mServiceRegistry};

if (noCatch) {

try {

context.statefulProcess = context.init(initContext);

} catch (o2::framework::RuntimeErrorRef e) {

if (context.initErrorHandling) {

(context.initErrorHandling)(e);

}

}

} else {

try {

context.statefulProcess = context.init(initContext);

} catch (std::exception& ex) {

/// Convert a standard exception to a RuntimeErrorRef

/// Notice how this will lose the backtrace information

/// and report the exception coming from here.

auto e = runtime_error(ex.what());

(context.initErrorHandling)(e);

} catch (o2::framework::RuntimeErrorRef e) {

(context.initErrorHandling)(e);

}

}

}

auto& state = ref.get<DeviceState>();

state.inputChannelInfos.resize(spec.inputChannels.size());

/// Internal channels which will never create an actual message

/// should be considered as in "Pull" mode, since we do not

/// expect them to create any data.

int validChannelId = 0;

for (size_t ci = 0; ci < spec.inputChannels.size(); ++ci) {

auto& name = spec.inputChannels[ci].name;

if (name.find(spec.channelPrefix + "from_internal-dpl-clock") == 0) {

state.inputChannelInfos[ci].state = InputChannelState::Pull;

state.inputChannelInfos[ci].id = {ChannelIndex::INVALID};

validChannelId++;

} else {

state.inputChannelInfos[ci].id = {validChannelId++};

}

}

// Invoke the callback policy for this device.

if (spec.callbacksPolicy.policy != nullptr) {

InitContext initContext{*mConfigRegistry, mServiceRegistry};

spec.callbacksPolicy.policy(mServiceRegistry.get<CallbackService>(ServiceRegistry::globalDeviceSalt()), initContext);

}

// Services which are stream should be initialised now

auto* options = GetConfig();

for (size_t si = 0; si < mStreams.size(); ++si) {

ServiceRegistry::Salt streamSalt = ServiceRegistry::streamSalt(si + 1, ServiceRegistry::globalDeviceSalt().dataProcessorId);

mServiceRegistry.lateBindStreamServices(state, *options, streamSalt);

}

O2_SIGNPOST_END(device, cid, "Init", "Exiting Init callback.");

{

O2_SIGNPOST_ID_FROM_POINTER(sid, device, handle);

O2_SIGNPOST_START(device, sid, "signal_state", "Signal %d received.", signum);

auto* registry = (ServiceRegistry*)handle->data;

if (!registry) {

O2_SIGNPOST_END(device, sid, "signal_state", "No registry active. Ignoring signal.");

return;

}

ServiceRegistryRef ref{*registry};

auto& state = ref.get<DeviceState>();

auto& quotaEvaluator = ref.get<ComputingQuotaEvaluator>();

auto& stats = ref.get<DataProcessingStats>();

state.loopReason |= DeviceState::SIGNAL_ARRIVED;

size_t ri = 0;

while (ri != quotaEvaluator.mOffers.size()) {

auto& offer = quotaEvaluator.mOffers[ri];

// We were already offered some sharedMemory, so we

// do not consider the offer.

// FIXME: in principle this should account for memory

// available and being offered, however we

// want to get out of the woods for now.

if (offer.valid && offer.sharedMemory != 0) {

O2_SIGNPOST_END(device, sid, "signal_state", "Memory already offered.");

return;

}

ri++;

}

// Find the first empty offer and have 1GB of shared memory there

for (auto& offer : quotaEvaluator.mOffers) {

if (offer.valid == false) {

offer.cpu = 0;

offer.memory = 0;

offer.sharedMemory = 1000000000;

offer.valid = true;

offer.user = -1;

break;

}

}

stats.updateStats({(int)ProcessingStatsId::TOTAL_SIGUSR1, DataProcessingStats::Op::Add, 1});

O2_SIGNPOST_END(device, sid, "signal_state", "Done processing signals.");

{

if (infos.empty() == false) {

std::vector<fair::mq::RegionInfo> toBeNotified;

toBeNotified.swap(infos); // avoid any MT issue.

static bool dummyRead = getenv("DPL_DEBUG_MAP_ALL_SHM_REGIONS") && atoi(getenv("DPL_DEBUG_MAP_ALL_SHM_REGIONS"));

for (auto const& info : toBeNotified) {

if (dummyRead) {

for (size_t i = 0; i < info.size / sizeof(region_read_global_dummy_variable); i += 4096 / sizeof(region_read_global_dummy_variable)) {

region_read_global_dummy_variable = ((int*)info.ptr)[i];

}

}

registry.get<CallbackService>().call<CallbackService::Id::RegionInfoCallback>(info);

}

}

{

auto* state = (DeviceState*)handle->data;

state->loopReason |= DeviceState::ASYNC_NOTIFICATION;

{

auto ref = ServiceRegistryRef{mServiceRegistry};

auto& deviceContext = ref.get<DeviceContext>();

auto& context = ref.get<DataProcessorContext>();

auto& spec = ref.get<DeviceSpec const>();

auto& state = ref.get<DeviceState>();

// We add a timer only in case a channel poller is not there.

if ((context.statefulProcess != nullptr) || (context.statelessProcess != nullptr)) {

for (auto& [channelName, channel] : GetChannels()) {

InputChannelInfo* channelInfo;

for (size_t ci = 0; ci < spec.inputChannels.size(); ++ci) {

auto& channelSpec = spec.inputChannels[ci];

channelInfo = &state.inputChannelInfos[ci];

if (channelSpec.name != channelName) {

continue;

}

channelInfo->channel = &this->GetChannel(channelName, 0);

break;

}

if ((channelName.rfind("from_internal-dpl", 0) == 0) &&

(channelName.rfind("from_internal-dpl-aod", 0) != 0) &&

(channelName.rfind("from_internal-dpl-ccdb-backend", 0) != 0) &&

(channelName.rfind("from_internal-dpl-injected", 0)) != 0) {

LOGP(detail, "{} is an internal channel. Skipping as no input will come from there.", channelName);

continue;

}

// We only watch receiving sockets.

if (channelName.rfind("from_" + spec.name + "_", 0) == 0) {

LOGP(detail, "{} is to send data. Not polling.", channelName);

continue;

}

if (channelName.rfind("from_", 0) != 0) {

LOGP(detail, "{} is not a DPL socket. Not polling.", channelName);

continue;

}

// We assume there is always a ZeroMQ socket behind.

int zmq_fd = 0;

size_t zmq_fd_len = sizeof(zmq_fd);

// FIXME: I should probably save those somewhere... ;-)

auto* poller = (uv_poll_t*)malloc(sizeof(uv_poll_t));

channel[0].GetSocket().GetOption("fd", &zmq_fd, &zmq_fd_len);

if (zmq_fd == 0) {

LOG(error) << "Cannot get file descriptor for channel." << channelName;

continue;

}

LOGP(detail, "Polling socket for {}", channelName);

auto* pCtx = (PollerContext*)malloc(sizeof(PollerContext));

pCtx->name = strdup(channelName.c_str());

pCtx->loop = state.loop;

pCtx->device = this;

pCtx->state = &state;

pCtx->fd = zmq_fd;

assert(channelInfo != nullptr);

pCtx->channelInfo = channelInfo;

pCtx->socket = &channel[0].GetSocket();

pCtx->read = true;

poller->data = pCtx;

uv_poll_init(state.loop, poller, zmq_fd);

if (channelName.rfind("from_", 0) != 0) {

LOGP(detail, "{} is an out of band channel.", channelName);

state.activeOutOfBandPollers.push_back(poller);

} else {

channelInfo->pollerIndex = state.activeInputPollers.size();

state.activeInputPollers.push_back(poller);

}

}

// In case we do not have any input channel and we do not have

// any timers or signal watchers we still wake up whenever we can send data to downstream

// devices to allow for enumerations.

if (state.activeInputPollers.empty() &&

state.activeOutOfBandPollers.empty() &&

state.activeTimers.empty() &&

state.activeSignals.empty()) {

// FIXME: this is to make sure we do not reset the output timer

// for readout proxies or similar. In principle this should go once

// we move to OutOfBand InputSpec.

if (state.inputChannelInfos.empty()) {

LOGP(detail, "No input channels. Setting exit transition timeout to 0.");

deviceContext.exitTransitionTimeout = 0;

}

for (auto& [channelName, channel] : GetChannels()) {

if (channelName.rfind(spec.channelPrefix + "from_internal-dpl", 0) == 0) {

LOGP(detail, "{} is an internal channel. Not polling.", channelName);

continue;

}

if (channelName.rfind(spec.channelPrefix + "from_" + spec.name + "_", 0) == 0) {

LOGP(detail, "{} is an out of band channel. Not polling for output.", channelName);

continue;

}

// We assume there is always a ZeroMQ socket behind.

int zmq_fd = 0;

size_t zmq_fd_len = sizeof(zmq_fd);

// FIXME: I should probably save those somewhere... ;-)

auto* poller = (uv_poll_t*)malloc(sizeof(uv_poll_t));

channel[0].GetSocket().GetOption("fd", &zmq_fd, &zmq_fd_len);

if (zmq_fd == 0) {

LOGP(error, "Cannot get file descriptor for channel {}", channelName);

continue;

}

LOG(detail) << "Polling socket for " << channel[0].GetName();

// FIXME: leak

auto* pCtx = (PollerContext*)malloc(sizeof(PollerContext));

pCtx->name = strdup(channelName.c_str());

pCtx->loop = state.loop;

pCtx->device = this;

pCtx->state = &state;

pCtx->fd = zmq_fd;

pCtx->read = false;

poller->data = pCtx;

uv_poll_init(state.loop, poller, zmq_fd);

state.activeOutputPollers.push_back(poller);

}

}

} else {

LOGP(detail, "This is a fake device so we exit after the first iteration.");

deviceContext.exitTransitionTimeout = 0;

// This is a fake device, so we can request to exit immediately

ServiceRegistryRef ref{mServiceRegistry};

ref.get<ControlService>().readyToQuit(QuitRequest::Me);

// A two second timer to stop internal devices which do not want to

auto* timer = (uv_timer_t*)malloc(sizeof(uv_timer_t));

uv_timer_init(state.loop, timer);

timer->data = &state;

uv_update_time(state.loop);

uv_timer_start(timer, on_idle_timer, 2000, 2000);

state.activeTimers.push_back(timer);

}

{

auto ref = ServiceRegistryRef{mServiceRegistry};

auto& deviceContext = ref.get<DeviceContext>();

auto& state = ref.get<DeviceState>();

for (auto* poller : state.activeInputPollers) {

O2_SIGNPOST_ID_FROM_POINTER(sid, device, poller);

O2_SIGNPOST_START(device, sid, "socket_state", "Input socket waiting for connection.");

uv_poll_start(poller, UV_WRITABLE, &on_socket_polled);

((PollerContext*)poller->data)->pollerState = PollerContext::PollerState::Disconnected;

}

for (auto& poller : state.activeOutOfBandPollers) {

uv_poll_start(poller, UV_WRITABLE, &on_out_of_band_polled);

((PollerContext*)poller->data)->pollerState = PollerContext::PollerState::Disconnected;

}

for (auto* poller : state.activeOutputPollers) {

O2_SIGNPOST_ID_FROM_POINTER(sid, device, poller);

O2_SIGNPOST_START(device, sid, "socket_state", "Output socket waiting for connection.");

uv_poll_start(poller, UV_WRITABLE, &on_socket_polled);

((PollerContext*)poller->data)->pollerState = PollerContext::PollerState::Disconnected;

}

deviceContext.gracePeriodTimer = (uv_timer_t*)malloc(sizeof(uv_timer_t));

deviceContext.gracePeriodTimer->data = new ServiceRegistryRef(mServiceRegistry);

uv_timer_init(state.loop, deviceContext.gracePeriodTimer);

deviceContext.dataProcessingGracePeriodTimer = (uv_timer_t*)malloc(sizeof(uv_timer_t));

deviceContext.dataProcessingGracePeriodTimer->data = new ServiceRegistryRef(mServiceRegistry);

uv_timer_init(state.loop, deviceContext.dataProcessingGracePeriodTimer);

{

auto ref = ServiceRegistryRef{mServiceRegistry};

auto& deviceContext = ref.get<DeviceContext>();

auto& state = ref.get<DeviceState>();

LOGP(detail, "Stopping {} input pollers", state.activeInputPollers.size());

for (auto* poller : state.activeInputPollers) {

O2_SIGNPOST_ID_FROM_POINTER(sid, device, poller);

O2_SIGNPOST_END(device, sid, "socket_state", "Output socket closed.");

uv_poll_stop(poller);

((PollerContext*)poller->data)->pollerState = PollerContext::PollerState::Stopped;

}

LOGP(detail, "Stopping {} out of band pollers", state.activeOutOfBandPollers.size());

for (auto* poller : state.activeOutOfBandPollers) {

uv_poll_stop(poller);

((PollerContext*)poller->data)->pollerState = PollerContext::PollerState::Stopped;

}

LOGP(detail, "Stopping {} output pollers", state.activeOutOfBandPollers.size());

for (auto* poller : state.activeOutputPollers) {

O2_SIGNPOST_ID_FROM_POINTER(sid, device, poller);

O2_SIGNPOST_END(device, sid, "socket_state", "Output socket closed.");

uv_poll_stop(poller);

((PollerContext*)poller->data)->pollerState = PollerContext::PollerState::Stopped;

}

uv_timer_stop(deviceContext.gracePeriodTimer);

delete (ServiceRegistryRef*)deviceContext.gracePeriodTimer->data;

free(deviceContext.gracePeriodTimer);

deviceContext.gracePeriodTimer = nullptr;

uv_timer_stop(deviceContext.dataProcessingGracePeriodTimer);

delete (ServiceRegistryRef*)deviceContext.dataProcessingGracePeriodTimer->data;

free(deviceContext.dataProcessingGracePeriodTimer);

deviceContext.dataProcessingGracePeriodTimer = nullptr;

{

auto ref = ServiceRegistryRef{mServiceRegistry};

auto& deviceContext = ref.get<DeviceContext>();

auto& context = ref.get<DataProcessorContext>();

O2_SIGNPOST_ID_FROM_POINTER(cid, device, &context);

O2_SIGNPOST_START(device, cid, "InitTask", "Entering InitTask callback.");

auto& spec = getRunningDevice(mRunningDevice, mServiceRegistry);

auto distinct = DataRelayerHelpers::createDistinctRouteIndex(spec.inputs);

auto& state = ref.get<DeviceState>();

int i = 0;

for (auto& di : distinct) {

auto& route = spec.inputs[di];

if (route.configurator.has_value() == false) {

i++;

continue;

}

ExpirationHandler handler{

.name = route.configurator->name,

.routeIndex = RouteIndex{i++},

.lifetime = route.matcher.lifetime,

.creator = route.configurator->creatorConfigurator(state, mServiceRegistry, *mConfigRegistry),

.checker = route.configurator->danglingConfigurator(state, *mConfigRegistry),

.handler = route.configurator->expirationConfigurator(state, *mConfigRegistry)};

context.expirationHandlers.emplace_back(std::move(handler));

}

if (state.awakeMainThread == nullptr) {

state.awakeMainThread = (uv_async_t*)malloc(sizeof(uv_async_t));

state.awakeMainThread->data = &state;

uv_async_init(state.loop, state.awakeMainThread, on_awake_main_thread);

}

deviceContext.expectedRegionCallbacks = std::stoi(fConfig->GetValue<std::string>("expected-region-callbacks"));

deviceContext.exitTransitionTimeout = std::stoi(fConfig->GetValue<std::string>("exit-transition-timeout"));

deviceContext.dataProcessingTimeout = std::stoi(fConfig->GetValue<std::string>("data-processing-timeout"));

for (auto& channel : GetChannels()) {

channel.second.at(0).Transport()->SubscribeToRegionEvents([&context = deviceContext,

&registry = mServiceRegistry,

&pendingRegionInfos = mPendingRegionInfos,

&regionInfoMutex = mRegionInfoMutex](fair::mq::RegionInfo info) {

std::lock_guard<std::mutex> lock(regionInfoMutex);

LOG(detail) << ">>> Region info event" << info.event;

LOG(detail) << "id: " << info.id;

LOG(detail) << "ptr: " << info.ptr;

LOG(detail) << "size: " << info.size;

LOG(detail) << "flags: " << info.flags;

// Now we check for pending events with the mutex,

// so the lines below are atomic.

pendingRegionInfos.push_back(info);

context.expectedRegionCallbacks -= 1;

// We always want to handle these on the main loop,

// so we awake it.

ServiceRegistryRef ref{registry};

uv_async_send(ref.get<DeviceState>().awakeMainThread);

});

}

// Add a signal manager for SIGUSR1 so that we can force

// an event from the outside, making sure that the event loop can

// be unblocked (e.g. by a quitting DPL driver) even when there

// is no data pending to be processed.

if (deviceContext.sigusr1Handle == nullptr) {

deviceContext.sigusr1Handle = (uv_signal_t*)malloc(sizeof(uv_signal_t));

deviceContext.sigusr1Handle->data = &mServiceRegistry;

uv_signal_init(state.loop, deviceContext.sigusr1Handle);

uv_signal_start(deviceContext.sigusr1Handle, on_signal_callback, SIGUSR1);

}

// If there is any signal, we want to make sure they are active

for (auto& handle : state.activeSignals) {

handle->data = &state;

}

// When we start, we must make sure that we do listen to the signal

deviceContext.sigusr1Handle->data = &mServiceRegistry;

/// Initialise the pollers

DataProcessingDevice::initPollers();

// Whenever we InitTask, we consider as if the previous iteration

// was successful, so that even if there is no timer or receiving

// channel, we can still start an enumeration.

DataProcessorContext* initialContext = nullptr;

bool idle = state.lastActiveDataProcessor.compare_exchange_strong(initialContext, (DataProcessorContext*)-1);

if (!idle) {

LOG(error) << "DataProcessor " << state.lastActiveDataProcessor.load()->spec->name << " was unexpectedly active";

}

// We should be ready to run here. Therefore we copy all the

// required parts in the DataProcessorContext. Eventually we should

// do so on a per thread basis, with fine grained locks.

// FIXME: this should not use ServiceRegistry::threadSalt, but

// more a ServiceRegistry::globalDataProcessorSalt(N) where

// N is the number of the multiplexed data processor.

// We will get there.

this->fillContext(mServiceRegistry.get<DataProcessorContext>(ServiceRegistry::globalDeviceSalt()), deviceContext);

O2_SIGNPOST_END(device, cid, "InitTask", "Exiting InitTask callback waiting for the remaining region callbacks.");

auto hasPendingEvents = [&mutex = mRegionInfoMutex, &pendingRegionInfos = mPendingRegionInfos](DeviceContext& deviceContext) {

std::lock_guard<std::mutex> lock(mutex);

return (pendingRegionInfos.empty() == false) || deviceContext.expectedRegionCallbacks > 0;

};

O2_SIGNPOST_START(device, cid, "InitTask", "Waiting for registation events.");

/// We now run an event loop also in InitTask. This is needed to:

/// * Make sure region registration callbacks are invoked

/// on the main thread.

/// * Wait for enough callbacks to be delivered before moving to START

while (hasPendingEvents(deviceContext)) {

// Wait for the callback to signal its done, so that we do not busy wait.

uv_run(state.loop, UV_RUN_ONCE);

// Handle callbacks if any

{

O2_SIGNPOST_EVENT_EMIT(device, cid, "InitTask", "Memory registration event received.");

std::lock_guard<std::mutex> lock(mRegionInfoMutex);

handleRegionCallbacks(mServiceRegistry, mPendingRegionInfos);

}

}

O2_SIGNPOST_END(device, cid, "InitTask", "Done waiting for registration events.");

{

context.isSink = false;

// If nothing is a sink, the rate limiting simply does not trigger.

bool enableRateLimiting = std::stoi(fConfig->GetValue<std::string>("timeframes-rate-limit"));

auto ref = ServiceRegistryRef{mServiceRegistry};

auto& spec = ref.get<DeviceSpec const>();

// The policy is now allowed to state the default.

context.balancingInputs = spec.completionPolicy.balanceChannels;