6 #include <boost/tokenizer.hpp>
7 #include <boost/filesystem.hpp>
8 #include <boost/algorithm/string.hpp>
9 #include <boost/exception/all.hpp>
10 #include <boost/throw_exception.hpp>
12 #include "fhiclcpp/ParameterSet.h"
14 #define TRACE_NAME "DispatcherCore"
17 #include "artdaq-core/Core/SimpleMemoryReader.hh"
18 #include "artdaq-core/Data/RawEvent.hh"
20 #include "artdaq/Application/DispatcherCore.hh"
21 #include "artdaq/TransferPlugins/MakeTransferPlugin.hh"
31 TLOG_DEBUG(name_) <<
"Destructor" << TLOG_ENDL;
36 TLOG_DEBUG(name_) <<
"initialize method called with DAQ " <<
"ParameterSet = \"" << pset.to_string() <<
"\"." << TLOG_ENDL;
39 pset_.erase(
"outputs");
40 pset_.erase(
"physics");
44 fhicl::ParameterSet daq_pset;
47 daq_pset = pset.get<fhicl::ParameterSet>(
"daq");
52 <<
"Unable to find the DAQ parameters in the initialization "
53 <<
"ParameterSet: \"" + pset.to_string() +
"\"." << TLOG_ENDL;
56 fhicl::ParameterSet agg_pset;
59 agg_pset = daq_pset.get<fhicl::ParameterSet>(
"dispatcher", daq_pset.get<fhicl::ParameterSet>(
"aggregator"));
64 <<
"Unable to find the Dispatcher parameters in the DAQ "
65 <<
"initialization ParameterSet: \"" + daq_pset.to_string() +
"\"." << TLOG_ENDL;
69 broadcast_mode_ = agg_pset.get<
bool>(
"broadcast_mode",
true);
70 if (broadcast_mode_ && !agg_pset.has_key(
"broadcast_mode"))
72 agg_pset.put<
bool>(
"broadcast_mode",
true);
73 agg_pset.put<
int>(
"art_analyzer_count", 0);
77 fhicl::ParameterSet metric_pset;
81 metric_pset = daq_pset.get<fhicl::ParameterSet>(
"metrics");
85 return initializeDataReceiver(pset, agg_pset, metric_pset);
90 TLOG_DEBUG(name_) <<
"DispatcherCore::register_monitor called with argument \"" << pset.to_string() <<
"\"" << TLOG_ENDL;
91 std::lock_guard<std::mutex> lock(dispatcher_transfers_mutex_);
95 TLOG_DEBUG(name_) <<
"Getting unique_label from input ParameterSet" << TLOG_ENDL;
96 auto label = pset.get<std::string>(
"unique_label");
97 TLOG_DEBUG(name_) <<
"Unique label is " << label << TLOG_ENDL;
98 if (registered_monitors_.count(label))
100 throw cet::exception(
"DispatcherCore") <<
"Unique label already exists!";
103 registered_monitors_[label] = pset;
104 if (event_store_ptr_ !=
nullptr)
106 if (broadcast_mode_) {
107 fhicl::ParameterSet ps = merge_parameter_sets_(pset_, label, pset);
108 TLOG_DEBUG(name_) <<
"Starting art process with received fhicl" << TLOG_ENDL;
109 registered_monitor_pids_[label] = event_store_ptr_->StartArtProcess(ps);
113 TLOG_DEBUG(name_) <<
"Generating new fhicl and reconfiguring art" << TLOG_ENDL;
114 event_store_ptr_->ReconfigureArt(generate_filter_fhicl_());
119 TLOG_ERROR(name_) <<
"Unable to add monitor as there is no SharedMemoryEventManager instance!" << TLOG_ENDL;
122 catch (
const cet::exception& e)
124 std::stringstream errmsg;
125 errmsg <<
"Unable to create a Transfer plugin with the FHiCL code \"" << pset.to_string() <<
"\", a new monitor has not been registered" << std::endl;
126 errmsg <<
"Exception: " << e.what();
127 TLOG_ERROR(name_) << errmsg.str() << TLOG_ENDL;
130 catch (
const boost::exception& e)
132 std::stringstream errmsg;
133 errmsg <<
"Unable to create a Transfer plugin with the FHiCL code \"" << pset.to_string() <<
"\", a new monitor has not been registered" << std::endl;
134 errmsg <<
"Exception: " << boost::diagnostic_information(e);
135 TLOG_ERROR(name_) << errmsg.str() << TLOG_ENDL;
138 catch (
const std::exception& e)
140 std::stringstream errmsg;
141 errmsg <<
"Unable to create a Transfer plugin with the FHiCL code \"" << pset.to_string() <<
"\", a new monitor has not been registered" << std::endl;
142 errmsg <<
"Exception: " << e.what();
143 TLOG_ERROR(name_) << errmsg.str() << TLOG_ENDL;
148 std::stringstream errmsg;
149 errmsg <<
"Unable to create a Transfer plugin with the FHiCL code \"" << pset.to_string() <<
"\", a new monitor has not been registered";
150 TLOG_ERROR(name_) << errmsg.str() << TLOG_ENDL;
159 TLOG_DEBUG(name_) <<
"DispatcherCore::unregister_monitor called with argument \"" << label <<
"\"" << TLOG_ENDL;
160 std::lock_guard<std::mutex> lock(dispatcher_transfers_mutex_);
164 if (registered_monitors_.count(label) == 0)
166 std::stringstream errmsg;
167 errmsg <<
"Warning in DispatcherCore::unregister_monitor: unable to find requested transfer plugin with "
168 <<
"label \"" << label <<
"\"";
169 TLOG_WARNING(name_) << errmsg.str() << TLOG_ENDL;
173 registered_monitors_.erase(label);
174 if (event_store_ptr_ !=
nullptr)
176 if(broadcast_mode_) {
177 std::set<pid_t> pids;
178 pids.insert(registered_monitor_pids_[label]);
179 event_store_ptr_->ShutdownArtProcesses(pids);
180 registered_monitor_pids_.erase(label);
184 event_store_ptr_->ReconfigureArt(generate_filter_fhicl_());
190 std::stringstream errmsg;
191 errmsg <<
"Unable to unregister transfer plugin with label \"" << label <<
"\"";
198 fhicl::ParameterSet artdaq::DispatcherCore::merge_parameter_sets_(fhicl::ParameterSet skel,std::string label, fhicl::ParameterSet pset)
200 fhicl::ParameterSet generated_pset = skel;
201 fhicl::ParameterSet generated_outputs;
202 fhicl::ParameterSet generated_physics;
203 fhicl::ParameterSet generated_physics_analyzers;
204 fhicl::ParameterSet generated_physics_producers;
205 fhicl::ParameterSet generated_physics_filters;
207 TLOG_DEBUG(name_) <<
"merge_parameter_sets_: Generating fhicl for monitor " << label << TLOG_ENDL;
211 auto path = pset.get<std::vector<std::string>>(
"path");
214 auto outputs = pset.get<fhicl::ParameterSet>(
"outputs");
215 if (outputs.get_pset_names().size() > 1 || outputs.get_pset_names().size() == 0)
219 auto output_name = outputs.get_pset_names()[0];
220 auto output_pset = outputs.get<fhicl::ParameterSet>(output_name);
221 generated_outputs.put(label + output_name, output_pset);
222 bool outputInPath =
false;
223 for (
size_t ii = 0; ii < path.size(); ++ii)
225 if (path[ii] == output_name)
227 path[ii] = label + output_name;
233 path.push_back(label + output_name);
237 auto physics_pset = pset.get<fhicl::ParameterSet>(
"physics");
238 if (physics_pset.has_key(
"analyzers"))
240 auto analyzers = physics_pset.get<fhicl::ParameterSet>(
"analyzers");
241 for (
auto key : analyzers.get_pset_names())
243 if (generated_physics_analyzers.has_key(key) && analyzers.get<fhicl::ParameterSet>(key) == generated_physics_analyzers.get<fhicl::ParameterSet>(key))
248 else if (generated_physics_analyzers.has_key(key))
251 auto newkey = label + key;
252 generated_physics_analyzers.put<fhicl::ParameterSet>(newkey, analyzers.get<fhicl::ParameterSet>(key));
253 for (
size_t ii = 0; ii < path.size(); ++ii)
263 generated_physics_analyzers.put<fhicl::ParameterSet>(key, analyzers.get<fhicl::ParameterSet>(key));
267 if (physics_pset.has_key(
"producers"))
269 auto producers = physics_pset.get<fhicl::ParameterSet>(
"producers");
270 for (
auto key : producers.get_pset_names())
272 if (generated_physics_producers.has_key(key) && producers.get<fhicl::ParameterSet>(key) == generated_physics_producers.get<fhicl::ParameterSet>(key))
277 else if (generated_physics_producers.has_key(key))
280 auto newkey = label + key;
281 generated_physics_producers.put<fhicl::ParameterSet>(newkey, producers.get<fhicl::ParameterSet>(key));
282 for (
size_t ii = 0; ii < path.size(); ++ii)
292 generated_physics_producers.put<fhicl::ParameterSet>(key, producers.get<fhicl::ParameterSet>(key));
296 if (physics_pset.has_key(
"filters"))
298 auto filters = physics_pset.get<fhicl::ParameterSet>(
"filters");
299 for (
auto key : filters.get_pset_names())
301 if (generated_physics_filters.has_key(key) && filters.get<fhicl::ParameterSet>(key) == generated_physics_filters.get<fhicl::ParameterSet>(key))
306 else if (generated_physics_filters.has_key(key))
309 auto newkey = label + key;
310 generated_physics_filters.put<fhicl::ParameterSet>(newkey, filters.get<fhicl::ParameterSet>(key));
311 for (
size_t ii = 0; ii < path.size(); ++ii)
321 generated_physics_filters.put<fhicl::ParameterSet>(key, filters.get<fhicl::ParameterSet>(key));
325 generated_physics.put<std::vector<std::string>>(label, path);
327 catch (cet::exception& e)
330 TLOG_ERROR(name_) <<
"merge_parameter_sets_: Error processing input fhicl: " << e.what() << TLOG_ENDL;
333 TLOG_DEBUG(name_) <<
"merge_parameter_sets_: Building final ParameterSet" << TLOG_ENDL;
334 generated_pset.put(
"outputs", generated_outputs);
336 generated_physics.put(
"analyzers", generated_physics_analyzers);
337 generated_physics.put(
"producers", generated_physics_producers);
338 generated_physics.put(
"filters", generated_physics_filters);
340 generated_pset.put(
"physics", generated_physics);
342 return generated_pset;
345 fhicl::ParameterSet artdaq::DispatcherCore::generate_filter_fhicl_()
347 TLOG_DEBUG(name_) <<
"generate_filter_fhicl_ BEGIN" << TLOG_ENDL;
348 fhicl::ParameterSet generated_pset = pset_;
350 for (
auto& monitor : registered_monitors_)
352 auto label = monitor.first;
353 auto pset = monitor.second;
354 generated_pset = merge_parameter_sets_(generated_pset, label, pset);
358 TLOG_DEBUG(name_) <<
"generate_filter_fhicl_ returning ParameterSet: " << generated_pset.to_string() << TLOG_ENDL;
359 return generated_pset;
DataReceiverCore implements the state machine for the DataReceiver artdaq application. DataReceiverCore receives Fragment objects from the DataReceiverManager, and sends them to the EventStore.
std::string unregister_monitor(std::string const &label)
Delete the TransferInterface having the given unique label.
std::string register_monitor(fhicl::ParameterSet const &pset)
Create a new TransferInterface instance using the given configuration.
DispatcherCore(int rank, std::string name)
DispatcherCore Constructor.
bool initialize(fhicl::ParameterSet const &pset) override
Processes the initialize request.