DPL: distinguish between exit and stop callbacks

Author: ktf

Framework/Core/include/Framework/ServiceRegistry.h

@@ -97,6 +97,8 @@ struct ServiceRegistry {
   std::vector<ServiceDispatchingHandle> mPostDispatchingHandles;
   /// Callbacks for services to be executed before Start
   std::vector<ServiceStartHandle> mPreStartHandles;
+  /// Callbacks for services to be executed on the Stop transition
+  std::vector<ServiceStopHandle> mPostStopHandles;
   /// Callbacks for services to be executed on exit
   std::vector<ServiceExitHandle> mPreExitHandles;
 
@@ -149,6 +151,9 @@ struct ServiceRegistry {
   /// Invoke callbacks to monitor inputs after dispatching, regardless of them
   /// being discarded, consumed or processed.
   void postDispatchingCallbacks(ProcessingContext&);
+
+  /// Invoke callbacks on stop.
+  void postStopCallbacks();
   /// Invoke callbacks on exit.
   void preExitCallbacks();
 

Framework/Core/include/Framework/ServiceSpec.h

@@ -41,9 +41,11 @@ class DanglingContext;
 
 /// A callback to create a given Service.
 using ServiceInit = std::function<ServiceHandle(ServiceRegistry&, DeviceState&, fair::mq::ProgOptions&)>;
-/// A callback invoked whenever we start running, before the user callback.
+/// A callback invoked whenever we start running, before the user processing callback.
 using ServiceStartCallback = std::function<void(ServiceRegistry&, void*)>;
-/// A callback invoked whenever we stop running, before we exit.
+/// A callback invoked whenever we stop running, after the user processing callback.
+using ServiceStopCallback = std::function<void(ServiceRegistry&, void*)>;
+/// A callback invoked whenever we stop running completely, before we exit.
 using ServiceExitCallback = std::function<void(ServiceRegistry&, void*)>;
 
 /// A callback to configure a given Service. Notice that the
@@ -150,6 +152,8 @@ struct ServiceSpec {
 
   /// Callback invoked on Start
   ServiceStartCallback start = nullptr;
+  /// Callback invoked on Start
+  ServiceStopCallback stop = nullptr;
   /// Callback invoked on exit
   ServiceExitCallback exit = nullptr;
   /// Callback invoked on driver entering the INIT state
@@ -197,6 +201,11 @@ struct ServiceStartHandle {
   void* service;
 };
 
+struct ServiceStopHandle {
+  ServiceStopCallback callback;
+  void* service;
+};
+
 struct ServiceExitHandle {
   ServiceExitCallback callback;
   void* service;

Framework/Core/src/DataProcessingDevice.cxx

@@ -586,10 +586,13 @@ void DataProcessingDevice::PreRun()
 void DataProcessingDevice::PostRun()
 {
   mServiceRegistry.get<CallbackService>()(CallbackService::Id::Stop);
-  mServiceRegistry.preExitCallbacks();
+  mServiceRegistry.postStopCallbacks();
 }
 
-void DataProcessingDevice::Reset() { mServiceRegistry.get<CallbackService>()(CallbackService::Id::Reset); }
+void DataProcessingDevice::Reset()
+{
+  mServiceRegistry.get<CallbackService>()(CallbackService::Id::Reset);
+}
 
 void DataProcessingDevice::Run()
 {

Framework/Core/src/ServiceRegistry.cxx

@@ -103,6 +103,9 @@ void ServiceRegistry::bindService(ServiceSpec const& spec, void* service)
   if (spec.start) {
     mPreStartHandles.push_back(ServiceStartHandle{spec.start, service});
   }
+  if (spec.stop) {
+    mPostStopHandles.push_back(ServiceStopHandle{spec.stop, service});
+  }
   if (spec.exit) {
     mPreExitHandles.push_back(ServiceExitHandle{spec.exit, service});
   }
@@ -172,6 +175,15 @@ void ServiceRegistry::preStartCallbacks()
   }
 }
 
+void ServiceRegistry::postStopCallbacks()
+{
+  // FIXME: we need to call the callback only once for the global services
+  /// I guess...
+  for (auto& stopHandle : mPostStopHandles) {
+    stopHandle.callback(*this, stopHandle.service);
+  }
+}
+
 /// Invoke callback to be executed on exit, in reverse order.
 void ServiceRegistry::preExitCallbacks()
 {

Framework/Core/src/runDataProcessing.cxx

@@ -1074,7 +1074,9 @@ int doChild(int argc, char** argv, ServiceRegistry& serviceRegistry,
   };
 
   runner.AddHook<fair::mq::hooks::InstantiateDevice>(afterConfigParsingCallback);
-  return runner.Run();
+  auto result = runner.Run();
+  serviceRegistry.preExitCallbacks();
+  return result;
 }
 
 struct WorkflowInfo {