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