1 #ifndef artdaq_Application_CommandableFragmentGenerator_hh
2 #define artdaq_Application_CommandableFragmentGenerator_hh
6 #include <netinet/in.h>
8 #include <sys/socket.h>
12 #include <condition_variable>
20 #include "fhiclcpp/fwd.h"
21 #include "fhiclcpp/ParameterSet.h"
22 #include "artdaq-core/Data/Fragment.hh"
23 #include "artdaq-core/Generators/FragmentGenerator.hh"
24 #include "artdaq-utilities/Plugins/MetricManager.hh"
25 #include "artdaq/DAQrate/detail/RequestMessage.hh"
26 #include "artdaq/DAQdata/Globals.hh"
142 bool getNext(FragmentPtrs& output)
override final;
163 bool sendEmptyFragment(FragmentPtrs& frags,
size_t sequenceId, std::string desc);
227 return fragment_ids_;
292 std::string
ReportCmd(std::string
const& which =
"");
300 return instance_name_for_metrics_;
407 instance_name_for_metrics_ = name;
430 std::string request_addr_;
433 struct sockaddr_in si_data_;
435 std::map<Fragment::sequence_id_t, Fragment::timestamp_t> requests_;
436 std::atomic<bool> request_stop_requested_;
437 std::chrono::steady_clock::time_point request_stop_timeout_;
438 std::atomic<bool> request_received_;
439 size_t end_of_run_timeout_ms_;
440 std::mutex request_mutex_;
441 std::thread requestThread_;
444 Fragment::timestamp_t windowOffset_;
445 Fragment::timestamp_t windowWidth_;
446 Fragment::timestamp_t staleTimeout_;
447 Fragment::type_t expectedType_;
448 size_t maxFragmentCount_;
450 std::chrono::steady_clock::time_point last_window_send_time_;
451 size_t missing_request_window_timeout_us_;
452 size_t window_close_timeout_us_;
455 size_t sleep_on_no_data_us_;
456 std::atomic<bool> data_thread_running_;
457 std::thread dataThread_;
459 std::condition_variable requestCondition_;
460 std::condition_variable dataCondition_;
461 std::atomic<int> dataBufferDepthFragments_;
462 std::atomic<size_t> dataBufferDepthBytes_;
463 int maxDataBufferDepthFragments_;
464 size_t maxDataBufferDepthBytes_;
466 bool useMonitoringThread_;
467 std::thread monitoringThread_;
468 int64_t monitoringInterval_;
469 std::chrono::steady_clock::time_point lastMonitoringCall_;
472 FragmentPtrs dataBuffer_;
473 FragmentPtrs newDataBuffer_;
474 std::mutex dataBufferMutex_;
476 std::vector<artdaq::Fragment::fragment_id_t> fragment_ids_;
481 int run_number_, subrun_number_;
496 std::atomic<bool> should_stop_, exception_, force_stop_;
497 std::string latest_exception_report_;
498 std::atomic<size_t> ev_counter_;
501 std::string instance_name_for_metrics_;
506 int sleep_on_stop_us_;
512 virtual bool getNext_(FragmentPtrs& output) = 0;
518 virtual bool checkHWStatus_();
530 virtual void start() = 0;
534 virtual void stopNoMutex() = 0;
540 virtual void stop() = 0;
544 virtual void pauseNoMutex();
549 virtual void pause();
555 virtual void resume();
565 virtual std::string report();
567 virtual std::string reportSpecific(std::string
const&);
int fragment_id() const
Get the current Fragment ID, if there is only one.
int subrun_number() const
Get the current Subrun number.
virtual ~CommandableFragmentGenerator()
CommandableFragmentGenerator Destructor.
RequestMode
The RequestMode enumeration contains the possible ways which CommandableFragmentGenerator responds to...
bool exception() const
Get the current value of the exception flag.
void metricsReportingInstanceName(std::string const &name)
Sets the name for metrics reporting.
std::mutex mutex_
Mutex used to ensure that multiple transition commands do not run at the same time.
bool sendEmptyFragment(FragmentPtrs &frags, size_t sequenceId, std::string desc)
Send an EmptyFragmentType Fragment.
void getMonitoringDataLoop()
This function regularly calls checkHWStatus_(), and sets the isHardwareOK flag accordingly.
void startDataThread()
Function that launches the data thread (getDataLoop())
std::string ReportCmd(std::string const &which="")
Get a report about a user-specified run-time quantity.
bool dataBufferIsTooLarge()
Test the configured constraints on the data buffer.
void StopCmd(uint64_t timeout, uint64_t timestamp)
Stop the CommandableFragmentGenerator.
uint64_t timeout() const
Timeout of last command.
void StartCmd(int run, uint64_t timeout, uint64_t timestamp)
Start the CommandableFragmentGenerator.
bool check_stop()
Routine used by applyRequests to make sure that all outstanding requests have been fulfilled before r...
void ResumeCmd(uint64_t timeout, uint64_t timestamp)
Resume the CommandableFragmentGenerator.
CommandableFragmentGenerator()
CommandableFragmentGenerator default constructor.
bool getNext(FragmentPtrs &output) overridefinal
getNext calls either applyRequests or getNext_ to get any data that is ready to be sent to the EventB...
size_t ev_counter_inc(size_t step=1, bool force=false)
Increment the event counter, if the current RequestMode allows it.
std::vector< Fragment::fragment_id_t > fragmentIDs() override
Get the list of Fragment IDs handled by this CommandableFragmentGenerator.
void PauseCmd(uint64_t timeout, uint64_t timestamp)
Pause the CommandableFragmentGenerator.
void getDataLoop()
When separate_data_thread is set to true, this loop repeatedly calls getNext_ and adds returned Fragm...
virtual std::string metricsReportingInstanceName() const
Get the name used when reporting metrics.
bool should_stop() const
Get the current value of the should_stop flag.
void startRequestReceiverThread()
Function that launches the data request receiver thread (receiveRequestsLoop())
CommandableFragmentGenerator is a FragmentGenerator-derived abstract class that defines the interface...
void startMonitoringThread()
Function that launches the monitoring thread (getMonitoringDataLoop())
size_t ev_counter() const
Get the current value of the event counter.
void checkDataBuffer()
Perform data buffer pruning operations. If the RequestMode is Single, removes all but the latest Frag...
int board_id() const
Gets the current board_id.
std::string printMode_()
Return the string representation of the current RequestMode.
void sendEmptyFragments(FragmentPtrs &frags)
This function is for Buffered and Single request modes, as they can only respond to one data request ...
void set_exception(bool exception)
Control the exception flag.
void getDataBufferStats()
Calculate the size of the dataBuffer and report appropriate metrics.
uint64_t timestamp() const
Timestamp of last command.
bool applyRequests(FragmentPtrs &output)
See if any requests have been received, and add the corresponding data Fragment objects to the output...
void receiveRequestsLoop()
This function receives data request packets, adding new requests to the request list.
void setupRequestListener()
Opens the socket used to listen for data requests.
int run_number() const
Get the current Run number.