00001
00002 #include "artdaq/DAQdata/Globals.hh"
00003 #include "artdaq/ArtModules/detail/RawEventQueueReader.hh"
00004
00005 #include "art/Framework/IO/Sources/put_product_in_principal.h"
00006 #include "canvas/Persistency/Provenance/FileFormatVersion.h"
00007 #include "canvas/Utilities/Exception.h"
00008 #include "artdaq-core/Data/Fragment.hh"
00009 #include <sys/time.h>
00010 #define TRACE_NAME "RawEventQueueReader"
00011 #include "trace.h"
00012
00013 using std::string;
00014
00015 artdaq::detail::RawEventQueueReader::RawEventQueueReader(fhicl::ParameterSet const& ps,
00016 art::ProductRegistryHelper& help,
00017 art::SourceHelper const& pm) :
00018 pmaker(pm)
00019 , incoming_events(getGlobalQueue())
00020 , waiting_time(ps.get<double>("waiting_time", 86400.0))
00021 , resume_after_timeout(ps.get<bool>("resume_after_timeout", true))
00022 , pretend_module_name(ps.get<std::string>("raw_data_label","daq"))
00023 , unidentified_instance_name("unidentified")
00024 , shutdownMsgReceived(false)
00025 , outputFileCloseNeeded(false)
00026 , bytesRead(0)
00027 , fragment_type_map_(Fragment::MakeSystemTypeMap())
00028 , readNext_calls_(0)
00029 {
00030 help.reconstitutes<Fragments, art::InEvent>(pretend_module_name,
00031 unidentified_instance_name);
00032 for (auto it = fragment_type_map_.begin(); it != fragment_type_map_.end(); ++it)
00033 {
00034 help.reconstitutes<Fragments, art::InEvent>(pretend_module_name, it->second);
00035 }
00036 }
00037
00038 void artdaq::detail::RawEventQueueReader::closeCurrentFile() {}
00039
00040 void artdaq::detail::RawEventQueueReader::readFile(string const&,
00041 art::FileBlock*& fb)
00042 {
00043 fb = new art::FileBlock(art::FileFormatVersion(1, "RawEvent2011"), "nothing");
00044 }
00045
00046 bool artdaq::detail::RawEventQueueReader::readNext(art::RunPrincipal* const & inR,
00047 art::SubRunPrincipal* const & inSR,
00048 art::RunPrincipal*& outR,
00049 art::SubRunPrincipal*& outSR,
00050 art::EventPrincipal*& outE)
00051 {
00052
00053
00054
00055
00056 if (readNext_calls_++ == 0)
00057 {
00058 incoming_events.setReaderIsReady();
00059 TRACE(50, "RawEventQueueReader::readNext after incoming_events.setReaderIsReady()");
00060 }
00061
00062 outR = 0;
00063 outSR = 0;
00064 outE = 0;
00065 RawEvent_ptr popped_event;
00066
00067
00068
00069
00070
00071 bool keep_looping = true;
00072 bool got_event = false;
00073 while (keep_looping)
00074 {
00075 keep_looping = false;
00076 got_event = incoming_events.deqTimedWait(popped_event, waiting_time);
00077 if (!got_event)
00078 {
00079 TLOG_INFO("RawEventQueueReader")
00080 << "InputFailure: Reading timed out in RawEventQueueReader::readNext()" << TLOG_ENDL;
00081 keep_looping = resume_after_timeout;
00082 }
00083 }
00084
00085
00086
00087
00088
00089 if (!got_event || !popped_event)
00090 {
00091 TLOG_DEBUG("RawEventQueueReader") << "Received shutdown message, returning false" << TLOG_ENDL;
00092 shutdownMsgReceived = true;
00093 return false;
00094 }
00095
00096 size_t qsize=incoming_events.size();
00097
00098
00099
00100
00101 art::Timestamp currentTime = time(0);
00102
00103
00104 if (inR == 0 || inR->run() != popped_event->runID())
00105 {
00106 outR = pmaker.makeRunPrincipal(popped_event->runID(),
00107 currentTime);
00108 }
00109
00110 if (popped_event->numFragments() == 1)
00111 {
00112 if (popped_event->releaseProduct(Fragment::EndOfRunFragmentType)->size() == 1)
00113 {
00114 art::EventID const evid(art::EventID::flushEvent());
00115 outR = pmaker.makeRunPrincipal(evid.runID(), currentTime);
00116 outSR = pmaker.makeSubRunPrincipal(evid.subRunID(), currentTime);
00117 outE = pmaker.makeEventPrincipal(evid, currentTime);
00118 return true;
00119 }
00120 else if (popped_event->releaseProduct(Fragment::EndOfSubrunFragmentType)->size() == 1)
00121 {
00122
00123 if (inR == 0 || inR->run() != popped_event->runID())
00124 {
00125 outSR = pmaker.makeSubRunPrincipal(popped_event->runID(),
00126 popped_event->subrunID(),
00127 currentTime);
00128 #ifdef ARTDAQ_ART_EVENTID_HAS_EXPLICIT_RUNID
00129 art::EventID const evid(art::EventID::flushEvent(outR->id(), outSR->id()));
00130 #else
00131 art::EventID const evid(art::EventID::flushEvent(outSR->id()));
00132 #endif
00133 outE = pmaker.makeEventPrincipal(evid, currentTime);
00134 }
00135 else
00136 {
00137
00138
00139
00140
00141 if (inSR != 0 && !inSR->id().isFlush() && inSR->subRun() == popped_event->subrunID())
00142 {
00143 art::EventID const evid(art::EventID::flushEvent(inR->id()));
00144 outSR = pmaker.makeSubRunPrincipal(evid.subRunID(), currentTime);
00145 outE = pmaker.makeEventPrincipal(evid, currentTime);
00146
00147
00148
00149 }
00150 else
00151 {
00152 outSR = pmaker.makeSubRunPrincipal(popped_event->runID(),
00153 popped_event->subrunID(),
00154 currentTime);
00155 #ifdef ARTDAQ_ART_EVENTID_HAS_EXPLICIT_RUNID
00156 art::EventID const evid(art::EventID::flushEvent(inR->id(), outSR->id()));
00157 #else
00158 art::EventID const evid(art::EventID::flushEvent(outSR->id()));
00159 #endif
00160 outE = pmaker.makeEventPrincipal(evid, currentTime);
00161
00162
00163 }
00164 outR = 0;
00165 }
00166
00167 return true;
00168 }
00169 }
00170
00171
00172 art::SubRunID subrun_check(popped_event->runID(), popped_event->subrunID());
00173 if (inSR == 0 || subrun_check != inSR->id())
00174 {
00175 outSR = pmaker.makeSubRunPrincipal(popped_event->runID(),
00176 popped_event->subrunID(),
00177 currentTime);
00178 }
00179 outE = pmaker.makeEventPrincipal(popped_event->runID(),
00180 popped_event->subrunID(),
00181 popped_event->sequenceID(),
00182 currentTime);
00183
00184 std::vector<Fragment::type_t> type_list;
00185 popped_event->fragmentTypes(type_list);
00186
00187 std::map<Fragment::type_t, std::string>::const_iterator iter_end =
00188 fragment_type_map_.end();
00189 for (size_t idx = 0; idx < type_list.size(); ++idx)
00190 {
00191 std::map<Fragment::type_t, std::string>::const_iterator iter =
00192 fragment_type_map_.find(type_list[idx]);
00193 auto product = popped_event->releaseProduct(type_list[idx]);
00194 for (auto &frag : *product)
00195 bytesRead += frag.sizeBytes();
00196 if (iter != iter_end)
00197 {
00198 put_product_in_principal(std::move(product),
00199 *outE,
00200 pretend_module_name,
00201 iter->second);
00202 }
00203 else
00204 {
00205 put_product_in_principal(std::move(product),
00206 *outE,
00207 pretend_module_name,
00208 unidentified_instance_name);
00209 TLOG_WARNING("RawEventQueueReader")
00210 << "UnknownFragmentType: The product instance name mapping for fragment type \""
00211 << ((int)type_list[idx]) << "\" is not known. Fragments of this "
00212 << "type will be stored in the event with an instance name of \""
00213 << unidentified_instance_name << "\"." << TLOG_ENDL;
00214 }
00215 }
00216 TRACE( 10, "readNext: bytesRead=%lu qsize=%zu cap=%zu metricMan=%p", bytesRead, qsize, incoming_events.capacity(), (void*)metricMan );
00217 if (metricMan) {
00218 metricMan->sendMetric( "bytesRead", bytesRead>>20, "MB", 5, false, "", true );
00219 metricMan->sendMetric( "queue%Used", static_cast<unsigned long int>(qsize*100/incoming_events.capacity()), "%", 5, false, "", true );
00220 }
00221
00222 return true;
00223 }