artdaq  v3_08_00
artdaq::SharedMemoryEventManager::Config Struct Reference

Configuration of the SharedMemoryEventManager. May be used for parameter validation More...

#include <artdaq/DAQrate/SharedMemoryEventManager.hh>

Public Attributes

fhicl::Atom< size_t > max_event_size_bytes {fhicl::Name{"max_event_size_bytes"}, fhicl::Comment{"Maximum event size (all Fragments), in bytes"}}
 
fhicl::Atom< size_t > stale_buffer_timeout_usec {fhicl::Name{"stale_buffer_timeout_usec"}, fhicl::Comment{"Maximum amount of time elapsed before a buffer is marked as abandoned. Time is reset each time an operation is performed on the buffer."}, 5000000}
 "stale_buffer_timeout_usec" (Default: event_queue_wait_time * 1, 000, 000) : Maximum amount of time elapsed before a buffer is marked as abandoned.Time is reset each time an operation is performed on the buffer.
 
fhicl::Atom< bool > overwrite_mode {fhicl::Name{"overwrite_mode"}, fhicl::Comment{"Whether buffers are allowed to be overwritten when safe (state == Full or Reading)"}, false}
 "overwite_mode" (Default: false): Whether new data is allowed to overwrite buffers in the "Full" state
 
fhicl::Atom< bool > restart_crashed_art_processes {fhicl::Name{"restart_crashed_art_processes"}, fhicl::Comment{"Whether to automatically restart art processes that fail for any reason"}, true}
 "restart_crashed_art_processes" (Default: true) : Whether to automatically restart art processes that fail for any reason
 
fhicl::Atom< uint32_t > shared_memory_key {fhicl::Name{"shared_memory_key"}, fhicl::Comment{"Key to use for shared memory access"}, 0xBEE70000 + getpid()}
 "shared_memory_key" (Default 0xBEE70000 + PID) : Key to use for shared memory access
 
fhicl::Atom< size_t > buffer_count {fhicl::Name{"buffer_count"}, fhicl::Comment{"Number of events in the Shared Memory (incomplete + pending art)"}}
 "buffer_count" REQUIRED: Number of events in the Shared Memory(incomplete + pending art)
 
fhicl::Atom< size_t > max_fragment_size_bytes {fhicl::Name{"max_fragment_size_bytes"}, fhicl::Comment{" Maximum Fragment size, in bytes"}}
 
fhicl::Atom< size_t > event_queue_wait_time {fhicl::Name{"event_queue_wait_time"}, fhicl::Comment{"Amount of time (in seconds) an event can exist in shared memory before being released to art. Used as input to default parameter of \"stale_buffer_timeout_usec\"."}, 5}
 "event_queue_wait_time" (Default: 5) : Amount of time(in seconds) an event can exist in shared memory before being released to art.Used as input to default parameter of "stale_buffer_timeout_usec".
 
fhicl::Atom< bool > broadcast_mode {fhicl::Name{"broadcast_mode"}, fhicl::Comment{"When true, buffers are not marked Empty when read, but return to Full state. Buffers are overwritten in order received."}, false}
 "broadcast_mode" (Default: false) : When true, buffers are not marked Empty when read, but return to Full state.Buffers are overwritten in order received.
 
fhicl::Atom< size_t > art_analyzer_count {fhicl::Name{"art_analyzer_count"}, fhicl::Comment{"Number of art procceses to start"}, 1}
 "art_analyzer_count" (Default: 1) : Number of art procceses to start
 
fhicl::Atom< size_t > expected_fragments_per_event {fhicl::Name{"expected_fragments_per_event"}, fhicl::Comment{"Number of Fragments to expect per event"}}
 "expected_fragments_per_event" (REQUIRED) : Number of Fragments to expect per event
 
fhicl::Atom< int > maximum_oversize_fragment_count {fhicl::Name{"maximum_oversize_fragment_count"}, fhicl::Comment{"Maximum number of over-size Fragments to drop before throwing an exception. Default is 1, which means to throw an exception if any over-size Fragments are dropped. Set to 0 to disable."}, 1}
 "maximum_oversize_fragment_count" (Default: 1): Maximum number of over-size Fragments to drop before throwing an exception. Default is 1, which means to throw an exception if any over-size Fragments are dropped. Set to 0 to disable.
 
fhicl::Atom< bool > update_run_ids_on_new_fragment {fhicl::Name{"update_run_ids_on_new_fragment"}, fhicl::Comment{"Whether the run and subrun ID of an event should be updated whenever a Fragment is added."}, true}
 "update_run_ids_on_new_fragment" (Default: true) : Whether the run and subrun ID of an event should be updated whenever a Fragment is added.
 
fhicl::Atom< bool > use_sequence_id_for_event_number {fhicl::Name{"use_sequence_id_for_event_number"}, fhicl::Comment{"Whether to use the artdaq Sequence ID (true) or the Timestamp (false) for art Event numbers"}, true}
 "use_sequence_id_for_event_number" (Default: true): Whether to use the artdaq Sequence ID (true) or the Timestamp (false) for art Event numbers
 
fhicl::Atom< size_t > max_subrun_lookup_table_size {fhicl::Name{"max_subrun_lookup_table_size"}, fhicl::Comment{"The maximum number of entries to store in the sequence ID-SubRun ID lookup table"}, 100}
 "max_subrun_lookup_table_size" (Default: 100): The maximum number of entries to store in the sequence ID-SubRun ID lookup table
 
fhicl::Atom< size_t > max_event_list_length {fhicl::Name{"max_event_list_length"}, fhicl::Comment{" The maximum number of entries to store in the released events list"}, 100}
 "max_event_list_length" (Default: 100): The maximum number of entries to store in the released events list
 
fhicl::Atom< bool > send_init_fragments {fhicl::Name{"send_init_fragments"}, fhicl::Comment{"Whether Init Fragments are expected to be sent to art. If true, a Warning message is printed when an Init Fragment is requested but none are available."}, true}
 "send_init_fragments" (Default: true): Whether Init Fragments are expected to be sent to art. If true, a Warning message is printed when an Init Fragment is requested but none are available.
 
fhicl::Atom< int > incomplete_event_report_interval_ms {fhicl::Name{"incomplete_event_report_interval_ms"}, fhicl::Comment{"Interval at which an incomplete event report should be written"}, -1}
 "incomplete_event_report_interval_ms" (Default: -1): Interval at which an incomplete event report should be written
 
fhicl::Atom< int > fragment_broadcast_timeout_ms {fhicl::Name{"fragment_broadcast_timeout_ms"}, fhicl::Comment{"Amount of time broadcast fragments should live in the broadcast shared memory segment"}, 3000}
 
fhicl::Atom< double > minimum_art_lifetime_s {fhicl::Name{"minimum_art_lifetime_s"}, fhicl::Comment{"Amount of time that an art process should run to not be considered \"DOA\""}, 2.0}
 "minimum_art_lifetime_s" (Default: 2 seconds): Amount of time that an art process should run to not be considered "DOA"
 
fhicl::Atom< size_t > expected_art_event_processing_time_us {fhicl::Name{"expected_art_event_processing_time_us"}, fhicl::Comment{"During shutdown, SMEM will wait for this amount of time while it is checking that the art threads are done reading buffers."}, 100000}
 
fhicl::Atom< uint32_t > broadcast_shared_memory_key {fhicl::Name{"broadcast_shared_memory_key"}, fhicl::Comment{""}, 0xCEE70000 + getpid()}
 "broadcast_shared_memory_key" (Default: 0xCEE7000 + PID): Key to use for broadcast shared memory access
 
fhicl::Atom< size_t > broadcast_buffer_count {fhicl::Name{"broadcast_buffer_count"}, fhicl::Comment{"Buffers in the broadcast shared memory segment"}, 10}
 "broadcast_buffer_count" (Default: 10): Buffers in the broadcast shared memory segment
 
fhicl::Atom< size_t > broadcast_buffer_size {fhicl::Name{"broadcast_buffer_size"}, fhicl::Comment{"Size of the buffers in the broadcast shared memory segment"}, 0x100000}
 "broadcast_buffer_size" (Default: 0x100000): Size of the buffers in the broadcast shared memory segment
 
fhicl::Atom< bool > use_art {fhicl::Name{"use_art"}, fhicl::Comment{"Whether to start and manage art threads (Sets art_analyzer count to 0 and overwrite_mode to true when false)"}, true}
 "use_art" (Default: true): Whether to start and manage art threads (Sets art_analyzer count to 0 and overwrite_mode to true when false)
 
fhicl::Atom< bool > manual_art {fhicl::Name{"manual_art"}, fhicl::Comment{"Prints the startup command line for the art process so that the user may (for example) run it in GDB or valgrind"}, false}
 "manual_art" (Default: false): Prints the startup command line for the art process so that the user may (for example) run it in GDB or valgrind
 
fhicl::TableFragment
< artdaq::RequestSender::Config
requestSenderConfig
 Configuration of the RequestSender. See artdaq::RequestSender::Config.
 

Detailed Description

Configuration of the SharedMemoryEventManager. May be used for parameter validation

Definition at line 101 of file SharedMemoryEventManager.hh.

Member Data Documentation

fhicl::Atom<size_t> artdaq::SharedMemoryEventManager::Config::expected_art_event_processing_time_us {fhicl::Name{"expected_art_event_processing_time_us"}, fhicl::Comment{"During shutdown, SMEM will wait for this amount of time while it is checking that the art threads are done reading buffers."}, 100000}

"expected_art_event_processing_time_us" (Default: 100000 us): During shutdown, SMEM will wait for this amount of time while it is checking that the art threads are done reading buffers. (TUNING: Should be slightly longer than the mean art processing time, but not so long that the Stop transition times out)

Definition at line 148 of file SharedMemoryEventManager.hh.

fhicl::Atom<int> artdaq::SharedMemoryEventManager::Config::fragment_broadcast_timeout_ms {fhicl::Name{"fragment_broadcast_timeout_ms"}, fhicl::Comment{"Amount of time broadcast fragments should live in the broadcast shared memory segment"}, 3000}

"fragment_broadcast_timeout_ms" (Default: 3000): Amount of time broadcast fragments should live in the broadcast shared memory segment A "Broadcast shared memory segment" is used for all system-level fragments, such as Init, Start/End Run, Start/End Subrun and EndOfData

Definition at line 143 of file SharedMemoryEventManager.hh.

fhicl::Atom<size_t> artdaq::SharedMemoryEventManager::Config::max_event_size_bytes {fhicl::Name{"max_event_size_bytes"}, fhicl::Comment{"Maximum event size (all Fragments), in bytes"}}

"max_event_size_bytes" REQUIRED: Maximum event size(all Fragments), in bytes Either max_fragment_size_bytes or max_event_size_bytes must be specified

Definition at line 105 of file SharedMemoryEventManager.hh.

fhicl::Atom<size_t> artdaq::SharedMemoryEventManager::Config::max_fragment_size_bytes {fhicl::Name{"max_fragment_size_bytes"}, fhicl::Comment{" Maximum Fragment size, in bytes"}}

"max_fragment_size_bytes" REQURIED: Maximum Fragment size, in bytes Either max_fragment_size_bytes or max_event_size_bytes must be specified

Definition at line 118 of file SharedMemoryEventManager.hh.


The documentation for this struct was generated from the following file: