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 public:
00030 mu2eFragmentWriter(artdaq::Fragment &f);
00031
00032
00033
00034
00035 Header::data_t *dataBegin();
00036 Header::data_t *dataAt(size_t index);
00037 Header::data_t *dataEnd();
00038 Header::data_t *dataAtBytes(size_t offset);
00039
00040
00041
00042
00043 Header *header_() {
00044 assert(artdaq_Fragment_.dataSize() >= words_to_frag_words_(Header::size_words));
00045 return reinterpret_cast<Header *>(&*artdaq_Fragment_.dataBegin());
00046 }
00047
00048 void set_hdr_fragment_type(Header::data_t type) { header_()->fragment_type = type; }
00049
00050 void addSpace(size_t bytes);
00051 void endSubEvt(size_t bytes);
00052
00053 private:
00054
00055 artdaq::Fragment &artdaq_Fragment_;
00056 static size_t words_to_frag_words_(size_t nWords);
00057 };
00058
00059
00060
00061
00062
00063 mu2e::mu2eFragmentWriter::mu2eFragmentWriter(artdaq::Fragment &f) : mu2eFragment(f), artdaq_Fragment_(f) {
00064
00065
00066
00067
00068
00069 TLOG_ARB(TLVL_DEBUG, "mu2eFragmentWriter") << "mu2eFragmentWriter Constructor";
00070
00071 assert(sizeof(Metadata::data_t) == sizeof(Header::data_t));
00072
00073 if (artdaq_Fragment_.size() !=
00074 artdaq::detail::RawFragmentHeader::num_words() + words_to_frag_words_(Metadata::size_words)) {
00075 std::cerr << "artdaq_Fragment size: " << artdaq_Fragment_.size() << std::endl;
00076 std::cerr << "Expected size: "
00077 << artdaq::detail::RawFragmentHeader::num_words() + words_to_frag_words_(Metadata::size_words)
00078 << std::endl;
00079
00080 throw cet::exception(
00081 "mu2eFragmentWriter: Raw artdaq::Fragment object size suggests it does not consist of its own header + the "
00082 "mu2eFragment::Metadata object");
00083 }
00084
00085
00086 artdaq_Fragment_.resize(words_to_frag_words_(Header::size_words));
00087 header_()->block_count = 0;
00088 memset((void *)&(header_()->index[0]), 0, sizeof(size_t) * mu2e::BLOCK_COUNT_MAX);
00089 }
00090
00091 inline mu2e::mu2eFragmentWriter::Header::data_t *mu2e::mu2eFragmentWriter::dataBegin() {
00092 assert(artdaq_Fragment_.dataSize() >= words_to_frag_words_(Header::size_words));
00093 return reinterpret_cast<Header::data_t *>(header_() + 1);
00094 }
00095
00096 inline mu2e::mu2eFragmentWriter::Header::data_t *mu2e::mu2eFragmentWriter::dataAt(size_t index) {
00097 if (index == 0) return dataBegin();
00098 auto block = header_()->index[index - 1] / sizeof(Header::data_t);
00099 return reinterpret_cast<Header::data_t *>(dataBegin() + block);
00100 }
00101
00102 inline mu2e::mu2eFragmentWriter::Header::data_t *mu2e::mu2eFragmentWriter::dataEnd() {
00103 return dataAt(hdr_block_count());
00104 }
00105
00106 inline mu2e::mu2eFragmentWriter::Header::data_t *mu2e::mu2eFragmentWriter::dataAtBytes(size_t offset) {
00107 return dataBegin() + (offset / sizeof(Header::data_t));
00108 }
00109
00110 inline size_t mu2e::mu2eFragmentWriter::words_to_frag_words_(size_t nWords) {
00111 size_t mod = nWords % words_per_frag_word_();
00112 return mod ? nWords / words_per_frag_word_() + 1 : nWords / words_per_frag_word_();
00113 }
00114
00115 void mu2e::mu2eFragmentWriter::addSpace(size_t bytes) {
00116 TLOG_ARB(10, "mu2eFragmentWriter") << "addSpace: START bytes=" << bytes;
00117 auto currSize = sizeof(artdaq::Fragment::value_type) * artdaq_Fragment_.size();
00118 TLOG_ARB(10, "mu2eFragmentWriter") << "addSpace: Resizing fragment: additional bytes requested: " << bytes
00119 << ", size of fragment: " << currSize;
00120 artdaq_Fragment_.resizeBytes(bytes + currSize);
00121 }
00122
00123 void mu2e::mu2eFragmentWriter::endSubEvt(size_t bytes) {
00124 TLOG_ARB(11, "mu2eFragmentWriter") << "endSubEvt START bytes=" << bytes;
00125 header_()->index[hdr_block_count()] = blockOffset(hdr_block_count()) + bytes;
00126 header_()->block_count++;
00127 TLOG_ARB(11, "mu2eFragmentWriter") << "endSubEvt END";
00128 }
00129
00130 #endif