DataBlockBase.h

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
//
// file DataBlockBase.h base class for RAW data format data blocks
//
// Artur.Furs
// afurs@cern.ch
// DataBlockWrapper - wrapper for raw data structures
// There should be three static fields in raw data structs, which defines its "signature":
//  payloadSize - actual payload size per one raw data struct element (can be larger than GBTword size!)
//  payloadPerGBTword - maximum payload per one GBT word
//  MaxNelements - maximum number of elements per data block(for header it should be equal to 1)
//  MinNelements - minimum number of elements per data block(for header it should be equal to 1)
 
// Also it requares several methods:
//   print() - for printing raw data structs
//   getIntRec() - for InteractionRecord extraction, should be in Header struct
 
// DataBlockBase - base class for making composition of raw data structures, uses CRTP(static polyporphism)
// usage:
//   class DataBlockOfYourModule: public DataBlockBase< DataBlockOfYourModule, RawHeaderStruct, RawDataStruct ...>
//   define "deserialization" method with deserialization logic for current DataBlock
//   define "sanityCheck" method for checking if the DataBlock is correct
// Warning! Classes should be simple, without refs and pointers!
// TODO:
//   need to use references on the DataBlock fileds, with fast access
//   traites for classes and structs
//
 
#ifndef ALICEO2_FIT_DATABLOCKBASE_H_
#define ALICEO2_FIT_DATABLOCKBASE_H_
#include <iostream>
#include <vector>
#include <Rtypes.h>
#include "CommonDataFormat/InteractionRecord.h"
#include "DataFormatsFIT/RawDataMetric.h"
#include "Headers/RAWDataHeader.h"
#include <gsl/span>
#include <boost/mpl/inherit.hpp>
#include <boost/mpl/vector.hpp>
#include <Framework/Logger.h>
#include <vector>
#include <tuple>
#include <array>
#include <iostream>
#include <cassert>
#include <type_traits>
namespace o2
{
namespace fit
{
 
static constexpr size_t SIZE_WORD = 16;
static constexpr size_t SIZE_WORD_GBT = 10;                                                   // should be changed to gloabal variable
static constexpr size_t SIZE_MAX_PAGE = 8192;                                                 // should be changed to gloabal variable
static constexpr size_t SIZE_MAX_PAYLOAD = SIZE_MAX_PAGE - sizeof(o2::header::RAWDataHeader); // should be changed to gloabal variable
 
template <bool isPadded = true>
struct DataBlockConfig {
  constexpr static bool sIsPadded = isPadded;
  typedef DataBlockConfig<!sIsPadded> InvertedPadding_t;
};
 
template <typename T>
struct DataBlockHelper {
  template <typename, typename = void>
  struct CheckTypeMaxNelem : std::false_type {
  };
  template <typename U>
  struct CheckTypeMaxNelem<U, std::enable_if_t<std::is_same<decltype(U::MaxNelements), const std::size_t>::value>> : std::true_type {
  };
 
  template <typename, typename = void>
  struct CheckTypeMinNelem : std::false_type {
  };
  template <typename U>
  struct CheckTypeMinNelem<U, std::enable_if_t<std::is_same<decltype(U::MinNelements), const std::size_t>::value>> : std::true_type {
  };
 
  template <typename, typename = void>
  struct CheckTypePayloadSize : std::false_type {
  };
  template <typename U>
  struct CheckTypePayloadSize<U, std::enable_if_t<std::is_same<decltype(U::PayloadSize), const std::size_t>::value>> : std::true_type {
  };
 
  template <typename, typename = void>
  struct CheckTypePayloadPerGBTword : std::false_type {
  };
  template <typename U>
  struct CheckTypePayloadPerGBTword<U, std::enable_if_t<std::is_same<decltype(U::PayloadPerGBTword), const std::size_t>::value>> : std::true_type {
  };
 
  template <typename, typename = void>
  struct CheckMaxElemSize : std::false_type {
  };
  template <typename U>
  struct CheckMaxElemSize<U, std::enable_if_t<((T::MaxNelements * T::PayloadSize <= SIZE_MAX_PAYLOAD) && (T::MaxNelements * T::PayloadPerGBTword <= SIZE_MAX_PAYLOAD))>> : std::true_type {
  };
 
  template <typename, typename = void>
  struct CheckNelemRange : std::false_type {
  };
  template <typename U>
  struct CheckNelemRange<U, std::enable_if_t<(T::MaxNelements >= T::MinNelements)>> : std::true_type {
  };
 
  static constexpr bool check()
  {
    static_assert(CheckTypeMaxNelem<T>::value, "Error! MaxNelements type should be \"static constexpr std::size_t\"!");
    static_assert(CheckTypeMinNelem<T>::value, "Error! MinNelements type should be \"static constexpr std::size_t\"!");
    static_assert(CheckTypePayloadSize<T>::value, "Error! PayloadSize type should be \"static constexpr std::size_t\"!");
    static_assert(CheckTypePayloadPerGBTword<T>::value, "Error! PayloadPerGBTword type should be \"static constexpr std::size_t\"!");
    static_assert(CheckMaxElemSize<T>::value, "Error! Check maximum number of elements, they are larger than payload size!");
    static_assert(CheckNelemRange<T>::value, "Error! Check range for number of elements, max should be bigger or equal to min!");
    return CheckTypeMaxNelem<T>::value && CheckTypeMinNelem<T>::value && CheckTypePayloadSize<T>::value && CheckTypePayloadPerGBTword<T>::value && CheckMaxElemSize<T>::value && CheckNelemRange<T>::value;
  }
};
 
template <typename ConfigType, typename T, typename = typename std::enable_if_t<DataBlockHelper<T>::check()>>
struct DataBlockWrapper {
  DataBlockWrapper() = default;
  DataBlockWrapper(const DataBlockWrapper&) = default;
  typedef T Data_t;
  typedef ConfigType Config_t;
  constexpr static bool sIsPadded = Config_t::sIsPadded;
  static constexpr std::size_t getWordSize()
  {
    if constexpr (sIsPadded) {
      return SIZE_WORD;
    } else {
      return SIZE_WORD_GBT;
    }
  }
 
  constexpr static std::size_t sSizeWord = getWordSize();
  void serialize(std::vector<char>& vecBytes, size_t nWords, size_t& destPos) const
  {
    const auto nBytesToWrite = nWords * sSizeWord;
    if ((vecBytes.size() - destPos) < nBytesToWrite || nWords < MinNwords || nWords > MaxNwords) {
      LOG(info) << "Warning! Incorrect serialisation procedure!";
      return;
    } else if (nWords == 0) {
      // nothing to do
      return;
    }
    const uint8_t* srcAddress = (uint8_t*)mData;
    gsl::span<char> serializedBytes(vecBytes);
    if constexpr (sIsPadded) { // in case of padding one need to use byte map
      int nSteps = std::get<kNSTEPS>(sReadingLookupTable[nWords]);
      for (int iStep = 0; iStep < nSteps; iStep++) {
        memcpy(serializedBytes.data() + std::get<kSRCBYTEPOS>(sByteLookupTable[iStep]) + destPos, srcAddress + std::get<kDESTBYTEPOS>(sByteLookupTable[iStep]), std::get<kNBYTES>(sByteLookupTable[iStep]));
      }
    } else { // no need in byte map
      memcpy(serializedBytes.data() + destPos, srcAddress, nBytesToWrite);
    }
    destPos += nBytesToWrite;
  }
 
  void deserialize(const gsl::span<const uint8_t> inputBytes, size_t nWords, size_t& srcPos)
  {
    mNelements = 0;
    const auto nBytesToRead = nWords * sSizeWord;
    if ((inputBytes.size() - srcPos) < nBytesToRead || nWords < MinNwords || nWords > MaxNwords) {
      // in case of bad fields responsible for deserialization logic, byte position will be pushed to the end of binary sequence
      LOG(error) << "Incomplete payload! |N GBT words " << nWords << " |bytes to read " << nBytesToRead << " |src pos " << srcPos << " |payload size " << inputBytes.size() << " |";
      srcPos = inputBytes.size();
      RawDataMetric::setStatusBit(mStatusBits, RawDataMetric::EStatusBits::kIncompletePayload);
      mIsIncorrect = true;
      return;
    }
    uint8_t* destAddress = (uint8_t*)mData;
    mNelements = std::get<kNELEMENTS>(sReadingLookupTable[nWords]);
    if constexpr (sIsPadded) { // in case of padding one need to use byte map
      int nSteps = std::get<kNSTEPS>(sReadingLookupTable[nWords]);
      for (int iStep = 0; iStep < nSteps; iStep++) {
        memcpy(destAddress + std::get<kDESTBYTEPOS>(sByteLookupTable[iStep]), inputBytes.data() + std::get<kSRCBYTEPOS>(sByteLookupTable[iStep]) + srcPos, std::get<kNBYTES>(sByteLookupTable[iStep]));
      }
    } else { // no need in byte map
      memcpy(destAddress, inputBytes.data() + srcPos, nBytesToRead);
    }
    srcPos += nBytesToRead;
  }
 
  static constexpr int MaxNwords = Data_t::PayloadSize * Data_t::MaxNelements / Data_t::PayloadPerGBTword + (Data_t::PayloadSize * Data_t::MaxNelements % Data_t::PayloadPerGBTword > 0); // calculating max GBT words per block
  static constexpr int MaxNbytes = SIZE_WORD * MaxNwords;
 
  static constexpr int MinNwords = Data_t::PayloadSize * Data_t::MinNelements / Data_t::PayloadPerGBTword + (Data_t::PayloadSize * Data_t::MinNelements % Data_t::PayloadPerGBTword > 0); // calculating min GBT words per block
  static constexpr int MinNbytes = SIZE_WORD * MinNwords;
 
  // get number of byte reading steps
  static constexpr size_t getNsteps()
  {
    int count = 0;
    size_t payloadFull = Data_t::MaxNelements * Data_t::PayloadSize;
    size_t payloadInWord = Data_t::PayloadPerGBTword;
    size_t payloadPerElem = Data_t::PayloadSize;
    while (payloadFull > 0) {
      if (payloadPerElem < payloadInWord) {
        count++;
        payloadFull -= payloadPerElem;
        payloadInWord -= payloadPerElem;
        payloadPerElem = 0;
      } else {
        count++;
        payloadFull -= payloadInWord;
        payloadPerElem -= payloadInWord;
        payloadInWord = 0;
      }
      if (payloadInWord == 0) {
        payloadInWord = Data_t::PayloadPerGBTword;
      }
      if (payloadPerElem == 0) {
        payloadPerElem = Data_t::PayloadSize;
      }
    }
    return count;
  }
  // enumerator for tuple access:
  //[Index] is index of step to read bytes
  // kNBYTES - number of bytes to read from source and to write into destination
  // kSRCBYTEPOS - Byte position in the source(binary raw data sequence)
  // kDESTBYTEPOS - Byte position to write at destionation(memory allocation of T-element array)
  // kELEMENTINDEX - element index at current step
  // kWORDINDEX - word index at current step
  //
  enum AccessByteLUT { kNBYTES,
                       kSRCBYTEPOS,
                       kDESTBYTEPOS,
                       kELEMENTINDEX,
                       kWORDINDEX };
  static constexpr std::array<std::tuple<size_t, size_t, size_t, int, int>, getNsteps()> GetByteLookupTable()
  {
    std::array<std::tuple<size_t, size_t, size_t, int, int>, getNsteps()> seqBytes{};
    int count = 0;
    int countElement = 0;
    int countWord = 0;
    size_t destBytePosPerElem = 0;
    size_t srcBytePos = 0;
    size_t payloadFull = Data_t::MaxNelements * Data_t::PayloadSize;
 
    size_t bytesInWord = SIZE_WORD;
    size_t payloadInWord = Data_t::PayloadPerGBTword;
 
    size_t payloadPerElem = Data_t::PayloadSize;
 
    uint64_t indexElem = 0;
    uint64_t indexLastElem = Data_t::MaxNelements - 1;
 
    while (payloadFull > 0) {
      if (payloadPerElem < payloadInWord) { // new element
        std::get<kNBYTES>(seqBytes[count]) = payloadPerElem;
        std::get<kSRCBYTEPOS>(seqBytes[count]) = srcBytePos;
        std::get<kDESTBYTEPOS>(seqBytes[count]) = destBytePosPerElem;
        std::get<kELEMENTINDEX>(seqBytes[count]) = countElement;
        std::get<kWORDINDEX>(seqBytes[count]) = countWord;
        srcBytePos += payloadPerElem;
        count++;
        payloadFull -= payloadPerElem;
        payloadInWord -= payloadPerElem;
        bytesInWord -= payloadPerElem;
        payloadPerElem = 0;
 
      } else {
        std::get<kNBYTES>(seqBytes[count]) = payloadInWord;
        std::get<kSRCBYTEPOS>(seqBytes[count]) = srcBytePos;
        std::get<kDESTBYTEPOS>(seqBytes[count]) = destBytePosPerElem;
        std::get<kELEMENTINDEX>(seqBytes[count]) = countElement;
        std::get<kWORDINDEX>(seqBytes[count]) = countWord;
        srcBytePos += bytesInWord;
        count++;
        destBytePosPerElem += payloadInWord;
 
        payloadFull -= payloadInWord;
        payloadPerElem -= payloadInWord;
        payloadInWord = 0;
        bytesInWord = 0;
      }
 
      if (payloadInWord == 0) {
        payloadInWord = Data_t::PayloadPerGBTword;
      }
      if (payloadPerElem == 0) {
        payloadPerElem = Data_t::PayloadSize;
        countElement++;
        destBytePosPerElem = countElement * sizeof(T);
      }
      if (bytesInWord == 0) {
        bytesInWord = SIZE_WORD;
        countWord++;
      }
    }
    return seqBytes;
  }
  static constexpr std::array<std::tuple<size_t, size_t, size_t, int, int>, getNsteps()> sByteLookupTable = GetByteLookupTable();
 
  // enumerator for tuple access:
  //[Index] is word index position, i.e. "Index" number of words will be deserialized
  // kNELEMENTS - number of T elements will be fully deserialized in "Index+1" words
  // kNSTEPS - number of steps for reading "Index" words
  // kISPARTED - if one T-element is parted at current word,i.e. current word contains partially deserialized T element at the end of the word
  enum AccessReadingLUT { kNELEMENTS,
                          kNSTEPS,
                          kISPARTED };
  static constexpr std::array<std::tuple<unsigned int, unsigned int, bool>, MaxNwords + 1> GetReadingLookupTable()
  {
    std::array<std::tuple<unsigned int, unsigned int, bool>, MaxNwords + 1> readingScheme{};
    size_t payloadPerElem = Data_t::PayloadSize;
    std::get<kNSTEPS>(readingScheme[0]) = 0;
    std::get<kNELEMENTS>(readingScheme[0]) = 0;
    std::get<kISPARTED>(readingScheme[0]) = false;
    int countWord = 1;
    for (int iStep = 0; iStep < getNsteps(); iStep++) {
      if (countWord - 1 < std::get<kWORDINDEX>((GetByteLookupTable())[iStep])) { // new word
        std::get<kNSTEPS>(readingScheme[countWord]) = iStep;
        std::get<kNELEMENTS>(readingScheme[countWord]) = std::get<kELEMENTINDEX>((GetByteLookupTable())[iStep]);
        if (payloadPerElem > 0) {
          std::get<kISPARTED>(readingScheme[countWord]) = true;
        } else {
          std::get<kISPARTED>(readingScheme[countWord]) = false;
        }
        countWord++;
      }
      if (payloadPerElem == 0) {
        payloadPerElem = Data_t::PayloadSize;
      }
      payloadPerElem -= std::get<kNBYTES>((GetByteLookupTable())[iStep]);
    }
    // Last step checking
    std::get<kNSTEPS>(readingScheme[countWord]) = getNsteps();
    if (payloadPerElem > 0) {
      std::get<kISPARTED>(readingScheme[countWord]) = true;
      std::get<kNELEMENTS>(readingScheme[countWord]) = std::get<kELEMENTINDEX>((GetByteLookupTable())[getNsteps() - 1]);
    } else {
      std::get<kISPARTED>(readingScheme[countWord]) = false;
      std::get<kNELEMENTS>(readingScheme[countWord]) = std::get<kELEMENTINDEX>((GetByteLookupTable())[getNsteps() - 1]) + 1;
    }
    return readingScheme;
  }
  static constexpr std::array<std::tuple<unsigned int, unsigned int, bool>, MaxNwords + 1> sReadingLookupTable = GetReadingLookupTable();
  //
  // Printing LookupTables
  static void printLUT()
  {
    LOG(info) << "-------------------------------------------";
    LOG(info) << "kNELEMENTS|kNSTEPS|kISPARTED";
    for (int i = 0; i < MaxNwords + 1; i++) {
      LOG(info) << std::get<kNELEMENTS>(sReadingLookupTable[i]) << "|"
                << std::get<kNSTEPS>(sReadingLookupTable[i]) << "|"
                << std::get<kISPARTED>(sReadingLookupTable[i]);
    }
    LOG(info) << "-------------------------------------------";
    LOG(info) << "kELEMENTINDEX|kWORDINDEX|kNBYTES|kSRCBYTEPOS|kDESTBYTEPOS";
    for (int i = 0; i < getNsteps(); i++) {
      LOG(info) << std::get<kELEMENTINDEX>(sByteLookupTable[i]) << "|"
                << std::get<kWORDINDEX>(sByteLookupTable[i]) << "|"
                << std::get<kNBYTES>(sByteLookupTable[i]) << "|"
                << std::get<kSRCBYTEPOS>(sByteLookupTable[i]) << "|"
                << std::get<kDESTBYTEPOS>(sByteLookupTable[i]);
    }
  }
  void print() const
  {
    assert(mNelements <= Data_t::MaxNelements);
    for (int i = 0; i < mNelements; i++) {
      LOG(info) << "Printing element number: " << i;
      mData[i].print();
    }
  }
  Data_t mData[Data_t::MaxNelements];
  unsigned int mNelements;                        // number of deserialized elements;
  typename RawDataMetric::Status_t mStatusBits{}; // Contains status bits
  bool mIsIncorrect;
};
 
// CRTP(static polymorphism) + Composition over multiple inheritance(Header + multiple data structures)
template <template <typename...> class DataBlock, typename ConfigType, class Header, class... DataStructures>
class DataBlockBase : public boost::mpl::inherit<DataBlockWrapper<ConfigType, Header>, DataBlockWrapper<ConfigType, DataStructures>...>::type
{
  //  typedef boost::mpl::vector<DataStructures...> DataBlockTypes;
  typedef DataBlockBase<DataBlock, ConfigType, Header, DataStructures...> TemplateHeader;
  typedef typename boost::mpl::inherit<DataBlockWrapper<ConfigType, Header>, DataBlockWrapper<ConfigType, DataStructures>...>::type DataBlockDerivedBase;
 
 public:
  typedef DataBlock<ConfigType, Header, DataStructures...> DataBlock_t;
  typedef DataBlockWrapper<ConfigType, Header> DataBlockWrapperHeader_t;
  typedef ConfigType Config_t;
  constexpr static bool sIsPadded = Config_t::sIsPadded;
  DataBlockBase() = default;
  DataBlockBase(const DataBlockBase&) = default;
  // typedef DataBlock<typename Padded::Inverted,Header,DataStructures...> DataBlockInverted_t;
  typedef DataBlock<typename Config_t::InvertedPadding_t, Header, DataStructures...> DataBlockInvertedPadding_t;
  constexpr static std::size_t sHeaderSize = sizeof(Header);
  bool isOnlyHeader() const
  {
    return sHeaderSize == mSize;
  }
  static void printLUT()
  {
    DataBlockWrapperHeader_t::printLUT();
    (static_cast<void>(DataBlockWrapper<Config_t, DataStructures>::printLUT()), ...);
  }
 
  void print() const
  {
    LOG(info) << "HEADER";
    DataBlockWrapperHeader_t::print();
    LOG(info) << "DATA";
    (static_cast<void>(DataBlockWrapper<Config_t, DataStructures>::print()), ...);
  }
 
  InteractionRecord getInteractionRecord() const
  {
    return DataBlockWrapperHeader_t::mData[0].getIntRec();
  }
 
  void setInteractionRecord(const InteractionRecord& intRec)
  {
    DataBlockWrapperHeader_t::mData[0].setIntRec(intRec);
  }
  //
  // use this for block decoding
  void decodeBlock(gsl::span<const uint8_t> payload, size_t srcPos)
  {
    mSize = 0;
    size_t bytePos = srcPos;
    static_cast<DataBlock_t*>(this)->deserialize(payload, bytePos);
    mSize = bytePos - srcPos;
    // checking sanity and updating
    update();
  }
 
  bool isCorrect() const { return mIsCorrect; }
 
  void update()
  {
    mIsCorrect = true;
    checkDeserialization(mIsCorrect, DataBlockWrapperHeader_t::mIsIncorrect);                          // checking deserialization status for header
    (checkDeserialization(mIsCorrect, DataBlockWrapper<Config_t, DataStructures>::mIsIncorrect), ...); // checking deserialization status for sub-block
    mergeStatusBits(mStatusBitsAll, DataBlockWrapperHeader_t::mStatusBits);                            // checking deserialization status for header
    (mergeStatusBits(mStatusBitsAll, DataBlockWrapper<Config_t, DataStructures>::mStatusBits), ...);   // checking deserialization status for sub-block
    static_cast<DataBlock_t*>(this)->sanityCheck(mIsCorrect, mStatusBitsAll);
  }
 
  size_t mSize{0}; // deserialized size
  bool mIsCorrect{false};
  typename RawDataMetric::Status_t mStatusBitsAll{};
 
 protected:
  // check if there are sub blocks with zero number of elements
  void isNonZeroBlockSizes(bool& flag, unsigned int nElements) { flag &= (bool)nElements; }
  void checkDeserialization(bool& flag, bool isIncorrect) { flag &= !(isIncorrect); }
  void mergeStatusBits(uint8_t& statusBitsResult, uint8_t statusBits) { statusBitsResult |= statusBits; }
};
 
} // namespace fit
} // namespace o2
#endif