00001 #ifndef mu2e_artdaq_core_Overlays_mu2eFragmentWriter_hh
00002 #define mu2e_artdaq_core_Overlays_mu2eFragmentWriter_hh
00003
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00016
00017 #include "artdaq-core/Data/Fragment.hh"
00018 #include "mu2e-artdaq-core/Overlays/mu2eFragment.hh"
00019
00020 #include <iostream>
00021
00022 #include "tracemf.h"
00023
00024 namespace mu2e {
00025 class mu2eFragmentWriter;
00026 }
00027
00028 class mu2e::mu2eFragmentWriter : public mu2e::mu2eFragment
00029 {
00030 public:
00031 mu2eFragmentWriter(artdaq::Fragment &f);
00032
00033
00034
00035
00036 Header::data_t *dataBegin();
00037 Header::data_t *dataAt(size_t index);
00038 Header::data_t *dataEnd();
00039 Header::data_t *dataAtBytes(size_t offset);
00040
00041
00042
00043
00044 Header *header_()
00045 {
00046 assert(artdaq_Fragment_.dataSize() >= words_to_frag_words_(Header::size_words));
00047 return reinterpret_cast<Header *>(&*artdaq_Fragment_.dataBegin());
00048 }
00049
00050 void set_hdr_fragment_type(Header::data_t type) { header_()->fragment_type = type; }
00051
00052 void addSpace(size_t bytes);
00053 void endSubEvt(size_t bytes);
00054
00055 private:
00056
00057 artdaq::Fragment &artdaq_Fragment_;
00058 static size_t words_to_frag_words_(size_t nWords);
00059 };
00060
00061
00062
00063
00064
00065 mu2e::mu2eFragmentWriter::mu2eFragmentWriter(artdaq::Fragment &f)
00066 : mu2eFragment(f), artdaq_Fragment_(f)
00067 {
00068
00069
00070
00071
00072
00073 TLOG_ARB(TLVL_DEBUG, "mu2eFragmentWriter") << "mu2eFragmentWriter Constructor";
00074
00075 assert(sizeof(Metadata::data_t) == sizeof(Header::data_t));
00076
00077 if (artdaq_Fragment_.size() !=
00078 artdaq::detail::RawFragmentHeader::num_words() + words_to_frag_words_(Metadata::size_words)) {
00079 std::cerr << "artdaq_Fragment size: " << artdaq_Fragment_.size() << std::endl;
00080 std::cerr << "Expected size: "
00081 << artdaq::detail::RawFragmentHeader::num_words() + words_to_frag_words_(Metadata::size_words)
00082 << std::endl;
00083
00084 throw cet::exception(
00085 "mu2eFragmentWriter: Raw artdaq::Fragment object size suggests it does not consist of its own header + the "
00086 "mu2eFragment::Metadata object");
00087 }
00088
00089
00090 artdaq_Fragment_.resize(words_to_frag_words_(Header::size_words));
00091 header_()->block_count = 0;
00092 memset((void *)&(header_()->index[0]), 0, sizeof(size_t) * mu2e::BLOCK_COUNT_MAX);
00093 }
00094
00095 inline mu2e::mu2eFragmentWriter::Header::data_t *mu2e::mu2eFragmentWriter::dataBegin()
00096 {
00097 assert(artdaq_Fragment_.dataSize() >= words_to_frag_words_(Header::size_words));
00098 return reinterpret_cast<Header::data_t *>(header_() + 1);
00099 }
00100
00101 inline mu2e::mu2eFragmentWriter::Header::data_t *mu2e::mu2eFragmentWriter::dataAt(size_t index)
00102 {
00103 if (index == 0) return dataBegin();
00104 auto block = header_()->index[index - 1] / sizeof(Header::data_t);
00105 return reinterpret_cast<Header::data_t *>(dataBegin() + block);
00106 }
00107
00108 inline mu2e::mu2eFragmentWriter::Header::data_t *mu2e::mu2eFragmentWriter::dataEnd()
00109 {
00110 return dataAt(hdr_block_count());
00111 }
00112
00113 inline mu2e::mu2eFragmentWriter::Header::data_t *mu2e::mu2eFragmentWriter::dataAtBytes(size_t offset)
00114 {
00115 return dataBegin() + (offset / sizeof(Header::data_t));
00116 }
00117
00118 inline size_t mu2e::mu2eFragmentWriter::words_to_frag_words_(size_t nWords)
00119 {
00120 size_t mod = nWords % words_per_frag_word_();
00121 return mod ? nWords / words_per_frag_word_() + 1 : nWords / words_per_frag_word_();
00122 }
00123
00124 void mu2e::mu2eFragmentWriter::addSpace(size_t bytes)
00125 {
00126 TLOG_ARB(10, "mu2eFragmentWriter") << "addSpace: START bytes=" << bytes;
00127 auto currSize = sizeof(artdaq::Fragment::value_type) * artdaq_Fragment_.size();
00128 TLOG_ARB(10, "mu2eFragmentWriter") << "addSpace: Resizing fragment: additional bytes requested: " << bytes
00129 << ", size of fragment: " << currSize;
00130 artdaq_Fragment_.resizeBytes(bytes + currSize);
00131 }
00132
00133 void mu2e::mu2eFragmentWriter::endSubEvt(size_t bytes)
00134 {
00135 TLOG_ARB(11, "mu2eFragmentWriter") << "endSubEvt START bytes=" << bytes;
00136 header_()->index[hdr_block_count()] = blockOffset(hdr_block_count()) + bytes;
00137 header_()->block_count++;
00138 TLOG_ARB(11, "mu2eFragmentWriter") << "endSubEvt END";
00139 }
00140
00141 #endif