Merge pull request #48421 from smorovic/151x-FEDRawDataBuffer

[DAQ] Phase-2 raw data product

Author: cmsbuild

DataFormats/FEDRawData/interface/RawDataBuffer.h

@@ -0,0 +1,88 @@
+#ifndef DataFormats_FEDRawData_RawDataBuffer_h
+#define DataFormats_FEDRawData_RawDataBuffer_h
+
+/** \class RawDataBuffer
+ *  A product storing raw data for all SourceIDs in a Event, intended
+ *  for persistent storage in ROOT Streamer or root files.
+ *  For Phase-2 source ID is 32-bit, so map is used instead of linear vector
+ *  as in the FEDRawDataCollection.  Legacy mode is added to use it for
+ *  Phase-1 data.
+ *  IMPORTANT: this is not a final format version for Phase-2 and only intended
+ *  for detector development. It will not be frozen until the end of LS3.
+ *  \author S. Morovic
+ */
+
+#include "DataFormats/Common/interface/traits.h"
+#include "FWCore/Utilities/interface/Exception.h"
+
+#include <vector>
+#include <map>
+#include <span>
+
+/*
+ * Phase2 source or FED wrapper pointing to a span of RawDataBuffer data
+ * */
+
+class RawFragmentWrapper {
+private:
+  uint32_t sourceId_;
+  bool valid_;
+  uint32_t size_;
+  std::span<const unsigned char> span_;
+
+public:
+  RawFragmentWrapper() : sourceId_(0), valid_(false) {}
+  RawFragmentWrapper(uint32_t sourceId, std::span<const unsigned char>&& span)
+      : sourceId_(sourceId), valid_(true), span_(span) {}
+  std::span<const unsigned char> const& data() const { return span_; }
+  std::span<const unsigned char> dataHeader(uint32_t expSize) const {
+    if (expSize > span_.size())
+      throw cms::Exception("RawFragmentWrapper") << "Expected trailer too large: " << expSize << " > " << span_.size();
+    return span_.subspan(0, expSize);
+  }
+  std::span<const unsigned char> dataTrailer(uint32_t expSize) const {
+    if (expSize > span_.size())
+      throw cms::Exception("RawFragmentWrapper") << "Expected trailer too large: " << expSize << " > " << span_.size();
+    return span_.subspan(span_.size() - expSize, expSize);
+  }
+  std::span<const unsigned char> payload(uint32_t expSizeHeader, uint32_t expSizeTrailer) const {
+    if (expSizeHeader + expSizeTrailer > span_.size())
+      throw cms::Exception("RawFragmentWrapper")
+          << "Trailer and header too large: " << expSizeHeader << " + " << expSizeTrailer << " > " << span_.size();
+    return span_.subspan(expSizeHeader, span_.size() - expSizeTrailer - expSizeHeader);
+  }
+
+  uint32_t size() const { return span_.size(); }
+  uint32_t sourceId() const { return sourceId_; }
+  bool isValid() const { return valid_; }
+};
+
+/*
+ * Contains metadata vector with source ID or FED ID offsets and size
+ * and data buffer as vector of bytes
+ */
+
+class RawDataBuffer : public edm::DoNotRecordParents {
+public:
+  RawDataBuffer();
+  RawDataBuffer(uint32_t preallocSize);
+
+  unsigned char* addSource(uint32_t sourceId, unsigned char const* buf, uint32_t size);
+  void setPhase1Range() { phase1Range_ = true; }
+
+  const RawFragmentWrapper fragmentData(uint32_t sourceId) const;
+  const RawFragmentWrapper fragmentData(
+      std::map<uint32_t, std::pair<uint32_t, uint32_t>>::const_iterator const& it) const;
+
+  unsigned char getByte(unsigned int pos) const { return data_.at(pos); }
+  std::vector<unsigned char> data() const { return data_; }
+  std::map<uint32_t, std::pair<uint32_t, uint32_t>> const& map() const { return map_; }
+
+private:
+  uint32_t usedSize_ = 0;
+  std::map<uint32_t, std::pair<uint32_t, uint32_t>> map_;  //map of source id fragment offset and size pairs
+  std::vector<unsigned char> data_;                        //raw data byte vector
+  bool phase1Range_ = false;
+};
+
+#endif

DataFormats/FEDRawData/interface/SLinkRocketHeaders.h

@@ -0,0 +1,210 @@
+#ifndef DataFormats_FEDRawData_SLinkRocketHeaders_h
+#define DataFormats_FEDRawData_SLinkRocketHeaders_h
+
+#include "FWCore/Utilities/interface/Exception.h"
+
+//#include <memory>
+#include <span>
+
+/*
+ * DTH Orbit header, event fragment trailer and SlinkRocket Header and Trailer accompanying
+ * slink payload. Format that is sent is is low-endian for multi-byte fields
+ *
+ * Version 1 DTH and Version 3 SLinkRocket
+ *
+ * */
+
+constexpr uint32_t SLR_MAX_EVENT_LEN = (1 << 20) - 1;
+constexpr uint32_t SLR_WORD_NUM_BYTES_SHIFT = 4;
+
+//SLinkExpress classes
+
+//begin and end event markers
+constexpr uint8_t SLR_BOE = 0x55;
+constexpr uint8_t SLR_EOE = 0xaa;
+
+//minimal SLinkRocket version overlay
+class SLinkRocketHeader_version {
+public:
+  SLinkRocketHeader_version() {}
+  uint8_t version() const { return version_; }
+  bool verifyMarker() const { return boe_ == SLR_BOE; }
+
+private:
+  uint32_t source_id_;
+  uint16_t l1a_types_;
+  uint8_t phys_type_;
+  uint8_t emu_status_ : 2, res1_ : 6;
+  uint64_t event_id_ : 44, res2_ : 8, version_ : 4, boe_ : 8;
+};
+
+class SLinkRocketHeader_v3 {
+public:
+  SLinkRocketHeader_v3(uint32_t source_id, uint16_t l1a_types, uint8_t l1a_phys, uint8_t emu_status, uint64_t event_id)
+      : source_id_(source_id),
+        l1a_types_(l1a_types),
+        phys_type_(l1a_phys),
+        emu_status_(emu_status),
+        event_id_(event_id) {}
+
+  uint32_t sourceID() const { return source_id_; }
+  uint16_t l1aTypes() const { return l1a_types_; }
+  uint8_t l1aPhysType() const { return phys_type_; }
+  uint8_t emuStatus() const { return emu_status_; }
+  uint64_t globalEventID() const { return event_id_; }
+  uint8_t version() const { return version_; }
+  bool verifyMarker() const { return boe_ == SLR_BOE; }
+
+private:
+  uint32_t source_id_;
+  uint16_t l1a_types_;
+  uint8_t phys_type_;
+  uint8_t emu_status_ : 2, res1_ : 6;
+  uint64_t event_id_ : 44, res2_ : 8, version_ : 4 = 3, boe_ : 8 = SLR_BOE;
+};
+
+class SLinkRocketTrailer_v3 {
+public:
+  SLinkRocketTrailer_v3(
+      uint16_t status, uint16_t crc, uint32_t orbit_id, uint16_t bx_id, uint32_t evtlen_word_count, uint16_t daq_crc)
+      : crc_(crc), orbit_id_(orbit_id), bx_id_(bx_id), event_length_wcount_(evtlen_word_count), daq_crc_(daq_crc) {
+    status_.all_ = status;
+  }
+
+  uint16_t status() const { return status_.all_; }
+  uint16_t crc() const { return crc_; }
+  uint32_t orbitID() const { return orbit_id_; }
+  uint16_t bxID() const { return bx_id_; }
+  uint32_t eventLenBytes() const { return uint32_t(event_length_wcount_) << SLR_WORD_NUM_BYTES_SHIFT; }
+  uint16_t daqCRC() const { return daq_crc_; }
+  bool verifyMarker() const { return eoe_ == SLR_EOE; }
+
+private:
+  union {
+    struct {
+      uint16_t fed_crc_error_ : 1, /* FED CRC error was detected by DTH and corrected */
+          slink_crc_error_ : 1, /* Set when the slink receviver finds a mistmatch between calculated crc and daq_crc. It should never happen */
+          source_id_error_ : 1, /* SOURCE_ID is not expected */
+          sync_lost_error_ : 1, /* Sync lost detected by DTH */
+          fragment_cut_ : 1,    /* Fragment was cut */
+          res_ : 11;
+    } bits_;
+    uint16_t all_;
+  } status_;
+  uint16_t crc_; /* CRC filled by the FED */
+  uint32_t orbit_id_;
+  uint32_t bx_id_ : 12,
+      event_length_wcount_ : 20; /* Length is encoded in multiples of 128 bits (16 bytes). I.e needs to be shifter by 4 */
+  uint32_t reserved_ : 8, daq_crc_ : 16, /* CRC filled by the slink sender */
+      eoe_ : 8 = SLR_EOE;
+};
+
+/*
+ * version-independent header view parent class
+ * */
+
+class SLinkRocketHeaderView {
+public:
+  virtual ~SLinkRocketHeaderView() = default;
+  virtual uint32_t sourceID() const = 0;
+  virtual uint16_t l1aTypes() const = 0;
+  virtual uint8_t l1aPhysType() const = 0;
+  virtual uint8_t emuStatus() const = 0;
+  virtual uint64_t globalEventID() const = 0;
+  virtual uint8_t version() const = 0;
+  virtual bool verifyMarker() const = 0;
+};
+
+/*
+ * header v3 view abstraction
+ * */
+
+class SLinkRocketHeaderView_v3 : public SLinkRocketHeaderView {
+public:
+  SLinkRocketHeaderView_v3(const void* header) : header_(static_cast<const SLinkRocketHeader_v3*>(header)) {}
+
+  uint32_t sourceID() const override { return header_->sourceID(); }
+  uint16_t l1aTypes() const override { return header_->l1aTypes(); }
+  uint8_t l1aPhysType() const override { return header_->l1aPhysType(); }
+  uint8_t emuStatus() const override { return header_->emuStatus(); }
+  uint64_t globalEventID() const override { return header_->globalEventID(); }
+  uint8_t version() const override { return header_->version(); }
+  bool verifyMarker() const override { return header_->verifyMarker(); }
+
+private:
+  const SLinkRocketHeader_v3* header_;
+};
+
+static inline std::unique_ptr<SLinkRocketHeaderView> makeSLinkRocketHeaderView(const void* buf) {
+  auto version = static_cast<const SLinkRocketHeader_version*>(buf)->version();
+  if (version == 3)
+    return std::unique_ptr<SLinkRocketHeaderView>(
+        static_cast<SLinkRocketHeaderView*>(new SLinkRocketHeaderView_v3(buf)));
+  throw cms::Exception("SLinkRocketHeaderView::makeView")
+      << "unknown SLinkRocketHeader version: " << (unsigned int)version;
+}
+
+static inline std::unique_ptr<SLinkRocketHeaderView> makeSLinkRocketHeaderView(std::span<const unsigned char> const& s) {
+  if (s.size() < sizeof(SLinkRocketHeader_version))
+    throw cms::Exception("SLinkRocketHeaderView::makeView")
+        << "size is smaller than SLink header version fields: " << s.size();
+  auto version = static_cast<const SLinkRocketHeader_version*>(static_cast<const void*>(&s[0]))->version();
+  if (version == 3 && s.size() != sizeof(SLinkRocketHeader_v3))
+    throw cms::Exception("SLinkRocketHeaderView::makeView") << "SLinkRocketHeader v3 size mismatch: got " << s.size()
+                                                            << " expected:" << sizeof(SLinkRocketHeader_v3) << " bytes";
+
+  return makeSLinkRocketHeaderView(static_cast<const void*>(&s[0]));
+}
+
+/*
+ * version-independent trailer view parent class
+ * */
+
+class SLinkRocketTrailerView {
+public:
+  virtual ~SLinkRocketTrailerView() = default;
+  virtual uint16_t status() const = 0;
+  virtual uint16_t crc() const = 0;
+  virtual uint32_t orbitID() const = 0;
+  virtual uint16_t bxID() const = 0;
+  virtual uint32_t eventLenBytes() const = 0;
+  virtual uint16_t daqCRC() const = 0;
+  virtual bool verifyMarker() const = 0;
+};
+
+/*
+ * trailer v3 view abstraction
+ * */
+
+class SLinkRocketTrailerView_v3 : public SLinkRocketTrailerView {
+public:
+  SLinkRocketTrailerView_v3(const void* trailer) : trailer_(static_cast<const SLinkRocketTrailer_v3*>(trailer)) {}
+  uint16_t status() const override { return trailer_->status(); }
+  uint16_t crc() const override { return trailer_->crc(); }
+  uint32_t orbitID() const override { return trailer_->orbitID(); }
+  uint16_t bxID() const override { return trailer_->bxID(); }
+  uint32_t eventLenBytes() const override { return trailer_->eventLenBytes(); }
+  uint16_t daqCRC() const override { return trailer_->daqCRC(); }
+  bool verifyMarker() const override { return trailer_->verifyMarker(); }
+
+private:
+  const SLinkRocketTrailer_v3* trailer_;
+};
+
+static inline std::unique_ptr<SLinkRocketTrailerView> makeSLinkRocketTrailerView(const void* buf, uint8_t version) {
+  if (version == 3)
+    return std::unique_ptr<SLinkRocketTrailerView>(
+        static_cast<SLinkRocketTrailerView*>(new SLinkRocketTrailerView_v3(buf)));
+  throw cms::Exception("SLinkRocketTrailerView::makeView")
+      << "unknown SLinkRocketHeader version: " << (unsigned int)version;
+}
+
+static inline std::unique_ptr<SLinkRocketTrailerView> makeSLinkRocketTrailerView(
+    std::span<const unsigned char> const& s, uint8_t version) {
+  if (version == 3 && s.size() < sizeof(SLinkRocketTrailer_v3))
+    throw cms::Exception("SLinkRocketTrailerView::makeView")
+        << "SLinkRocketTrailer v3 size mismatch: got " << s.size() << " expected " << sizeof(SLinkRocketTrailer_v3)
+        << " bytes";
+  return makeSLinkRocketTrailerView(static_cast<const void*>(&s[0]), version);
+}
+#endif

DataFormats/FEDRawData/interface/SourceIDNumbering.h

@@ -0,0 +1,24 @@
+#ifndef DataFormats_FEDRawData_SourceIdNumbering_h
+#define DataFormats_FEDRawData_SourceIdNumbering_h
+
+/** \class SourceIDNumbering
+ *
+ *  This placeholdeer class will hold the fed numbering scheme for the CMS Source IDs
+ *  for Phase-2 readout.  *  No two sources should have the same id. Each subdetector
+ *  will have a reserved range. Gaps between ranges might give flexibility to the
+ *  numbering. Total available range is unsigned 32-bit.
+ *
+ *  \author S. Morovic - UCSD
+ */
+
+class SourceIdNumbering {
+public:
+  enum {
+    //dummy range definition for testing. This is not stable and will possible be reassigned
+    MinDummySourceID = 0xfffffff0,
+    MaxDummySourceID = 0xfffffffe,
+    MAXSourceID = 0xffffffff
+  };
+};
+
+#endif  // SourceIdNumbering_H

DataFormats/FEDRawData/src/RawDataBuffer.cc

@@ -0,0 +1,63 @@
+/** \file
+ *  implementation of DaqRawDataBuffer
+ *
+ *  \author N. Amapane - S. Argiro'
+ */
+
+#include <DataFormats/FEDRawData/interface/RawDataBuffer.h>
+#include <DataFormats/FEDRawData/interface/FEDNumbering.h>
+#include <DataFormats/FEDRawData/interface/SourceIDNumbering.h>
+
+RawDataBuffer::RawDataBuffer() {}
+RawDataBuffer::RawDataBuffer(uint32_t preallocSize) : usedSize_(0), data_(preallocSize) {}
+
+unsigned char* RawDataBuffer::addSource(uint32_t sourceId, unsigned char const* buf, uint32_t size) {
+  auto maxSize = data_.size();
+  if ((uint64_t)usedSize_ + (uint64_t)size > maxSize)
+    throw cms::Exception("RawDataBuffer") << "RawDataBuffer size overflow adding ID " << sourceId << ": " << usedSize_
+                                          << " + " << size << " > " << maxSize;
+
+  if (phase1Range_) {
+    if (sourceId > FEDNumbering::lastFEDId())
+      throw cms::Exception("RawDataBuffer") << "FED ID " << sourceId << " out of range";
+  } else {
+    if (size % 16)
+      throw cms::Exception("RawDataBuffer")
+          << "source " << sourceId << " data not multiple of 16 bytes (" << size << ")";
+    if (size < 32)
+      throw cms::Exception("RawDataBuffer") << "source " << sourceId << " data is too small: " << size << " bytes";
+  }
+
+  void* targetAddr = (void*)(&data_[usedSize_]);
+  //allow also buffer preparation without copy if source pointer is null
+  if (buf != nullptr)
+    memcpy(targetAddr, (void*)buf, size);
+  auto usedSize = usedSize_;
+  map_.emplace(sourceId, std::make_pair(usedSize, size));
+  usedSize_ += size;
+  return (unsigned char*)targetAddr;
+}
+
+const RawFragmentWrapper RawDataBuffer::fragmentData(uint32_t sourceId) const {
+  if (phase1Range_ && sourceId > FEDNumbering::lastFEDId())
+    throw cms::Exception("RawDataBuffer") << "can not fetch out of range FED ID " << sourceId;
+  auto it = map_.find(sourceId);
+  if (it == map_.end()) {
+    return RawFragmentWrapper();
+  }
+  const auto& desc = it->second;
+  std::span<const unsigned char>&& byte_span{reinterpret_cast<const unsigned char*>(this->data_.data() + desc.first),
+                                             desc.second};
+  return RawFragmentWrapper(sourceId, std::move(byte_span));
+}
+
+const RawFragmentWrapper RawDataBuffer::fragmentData(
+    std::map<uint32_t, std::pair<uint32_t, uint32_t>>::const_iterator const& it) const {
+  if (it == map_.end()) {
+    return RawFragmentWrapper();
+  }
+  const auto& desc = it->second;
+  std::span<const unsigned char>&& byte_span{reinterpret_cast<const unsigned char*>(this->data_.data() + desc.first),
+                                             desc.second};
+  return RawFragmentWrapper(it->first, std::move(byte_span));
+}

DataFormats/FEDRawData/src/classes.h

@@ -1,6 +1,7 @@
 #include <vector>
 #include <DataFormats/FEDRawData/interface/FEDRawData.h>
 #include <DataFormats/FEDRawData/interface/FEDRawDataCollection.h>
+#include <DataFormats/FEDRawData/interface/RawDataBuffer.h>
 #include <DataFormats/FEDRawData/interface/FEDHeader.h>
 #include <DataFormats/FEDRawData/interface/FEDTrailer.h>
 #include <DataFormats/FEDRawData/src/fed_header.h>