NumericAddressedRegisterCatalogue.cc

Go to the documentation of this file.

// SPDX-FileCopyrightText: Deutsches Elektronen-Synchrotron DESY, MSK, ChimeraTK Project <chimeratk-support@desy.de>
// SPDX-License-Identifier: LGPL-3.0-or-later
 
#include "NumericAddressedRegisterCatalogue.h"
 
#include "async/DataConsistencyRealmStore.h"
#include "Exception.h"
#include "MapFileParser.h"
#include "NumericAddress.h"
#include "predicates.h"
 
#include <algorithm>
#include <cmath>
#include <stdexcept>
#include <utility>
 
namespace ChimeraTK {
 
  /********************************************************************************************************************/
 
  NumericAddressedRegisterInfo::NumericAddressedRegisterInfo(RegisterPath const& pathName_, uint32_t nElements_,
      uint64_t address_, uint32_t nBytes_, uint64_t bar_, uint32_t width_, int32_t nFractionalBits_, bool signedFlag_,
      Access dataAccess_, Type dataType_, std::vector<size_t> interruptId_,
      std::optional<DoubleBufferInfo> doubleBufferInfo_, bool isBitRange_)
  : pathName(pathName_), nElements(nElements_), elementPitchBits(nElements_ > 0 ? nBytes_ / nElements_ * 8 : 0),
    bar(bar_), address(address_), registerAccess(dataAccess_), interruptId(std::move(interruptId_)),
    doubleBuffer(std::move(doubleBufferInfo_)), isBitRange(isBitRange_),
    channels({{0, dataType_, width_, nFractionalBits_, signedFlag_,
        nElements_ > 0 ? ChimeraTK::DataType("int" + std::to_string(elementPitchBits)) :
                         ChimeraTK::DataType(ChimeraTK::DataType::Void)}}) {
    assert(channels.size() == 1);
 
    // make sure . and / is treated as similar as possible
    pathName.setAltSeparator(".");
 
    // consistency checks
    if(nBytes_ > 0 && nElements_ > 0) {
      if(nBytes_ % nElements_ != 0) {
        // nBytes_ must be divisible by nElements_
        throw logic_error("Number of bytes is not a multiple of number of elements for register " + pathName +
            ". Check your map file!");
      }
    }
 
    computeDataDescriptor();
  }
 
  /********************************************************************************************************************/
 
  NumericAddressedRegisterInfo::NumericAddressedRegisterInfo(RegisterPath const& pathName_, uint64_t bar_,
      uint64_t address_, uint32_t nElements_, uint32_t elementPitchBits_, std::vector<ChannelInfo> channelInfo_,
      Access dataAccess_, std::vector<size_t> interruptId_, std::optional<DoubleBufferInfo> doubleBufferInfo_)
  : pathName(pathName_), nElements(nElements_), elementPitchBits(elementPitchBits_), bar(bar_), address(address_),
    registerAccess(dataAccess_), interruptId(std::move(interruptId_)), doubleBuffer(std::move(doubleBufferInfo_)),
    channels(std::move(channelInfo_)) {
    assert(!channels.empty());
 
    // make sure . and / is treated as similar as possible
    pathName.setAltSeparator(".");
 
    computeDataDescriptor();
  }
 
  /********************************************************************************************************************/
 
  void NumericAddressedRegisterInfo::computeDataDescriptor() {
    // Determine DataDescriptor. If there are multiple channels, use the "biggest" data type.
    Type dataType = Type::VOID;
    uint32_t width = 0;
    int32_t nFractionalBits = 0;
    bool signedFlag = false;
    for(auto& c : channels) {
      if(int(c.dataType) > int(dataType)) dataType = c.dataType;
      if(c.width + c.nFractionalBits + c.signedFlag > width + nFractionalBits + signedFlag) {
        width = c.width;
        nFractionalBits = c.nFractionalBits;
        signedFlag = c.signedFlag;
      }
    }
 
    // set raw data type from the channel's stored raw type (its size defines the element size for the
    // transport layer; for a strided channel slice this may differ from elementPitchBits, the stride)
    DataType rawDataInfo{DataType::none};
    if(channels.size() == 1) {
      if(elementPitchBits == 0) {
        rawDataInfo = DataType::Void;
      }
      else if(dataType != Type::ASCII && dataType != Type::VOID) {
        rawDataInfo = channels.front().getRawType();
      }
    }
 
    // set "cooked" data type
    if(dataType == Type::IEEE754) {
      if(width == 32) {
        // Largest possible number +- 3e38, smallest possible number 1e-45
        // However, the actual precision is only 23+1 bit, which is < 1e9 relevant
        // digits. Hence, we don't have to add the 3e38 and the 1e45, but just add
        // the leading 0. comma and sign to the largest 45 digits
        dataDescriptor = DataDescriptor(DataDescriptor::FundamentalType::numeric, // fundamentalType
            false,                                                                // isIntegral
            true,                                                                 // isSigned
            3 + 45,                                                               // nDigits
            45,                                                                   // nFractionalDigits
            rawDataInfo); // we have integer in the transport layer, or none if multiplexed
      }
      else if(width == 64) {
        // smallest possible 5e-324, largest 2e308
        dataDescriptor = DataDescriptor(DataDescriptor::FundamentalType::numeric, // fundamentalType
            false,                                                                // isIntegral
            true,                                                                 // isSigned
            3 + 325,                                                              // nDigits
            325,                                                                  // nFractionalDigits
            rawDataInfo);
      }
      else {
        throw logic_error("Wrong data width for data type IEEE754 for register " + pathName + ". Check your map file!");
      }
    }
    else if(dataType == Type::FIXED_POINT) {
      if(width > 1) { // numeric type
 
        if(nFractionalBits > 0) {
          auto nDigits = static_cast<size_t>(
              std::ceil(std::log10(std::pow(2, width))) + (signedFlag ? 1 : 0) + (nFractionalBits != 0 ? 1 : 0));
          size_t nFractionalDigits = std::ceil(std::log10(std::pow(2, nFractionalBits)));
 
          dataDescriptor = DataDescriptor(DataDescriptor::FundamentalType::numeric, // fundamentalType
              false,                                                                // isIntegral
              signedFlag,                                                           // isSigned
              nDigits, nFractionalDigits, rawDataInfo);
        }
        else {
          auto nDigits =
              static_cast<size_t>(std::ceil(std::log10(std::pow(2, width + nFractionalBits))) + (signedFlag ? 1 : 0));
 
          dataDescriptor = DataDescriptor(DataDescriptor::FundamentalType::numeric, // fundamentalType
              true,                                                                 // isIntegral
              signedFlag,                                                           // isSigned
              nDigits, 0, rawDataInfo);
        }
      }
      else if(width == 1) { // boolean
        dataDescriptor = DataDescriptor(DataDescriptor::FundamentalType::boolean, true, false, 1, 0, rawDataInfo);
      }
      else { // width == 0 -> nodata
        dataDescriptor = DataDescriptor(DataDescriptor::FundamentalType::nodata, false, false, 0, 0, rawDataInfo);
      }
    }
    else if(dataType == Type::ASCII) {
      dataDescriptor = DataDescriptor(DataDescriptor::FundamentalType::string, false, false, 0, 0, rawDataInfo);
    }
    else if(dataType == Type::VOID) {
      dataDescriptor = DataDescriptor(DataDescriptor::FundamentalType::nodata, false, false, 0, 0, rawDataInfo);
    }
  }
 
  /********************************************************************************************************************/
 
  bool NumericAddressedRegisterInfo::operator==(const ChimeraTK::NumericAddressedRegisterInfo& rhs) const {
    return (address == rhs.address) && (bar == rhs.bar) && (nElements == rhs.nElements) && (channels == rhs.channels) &&
        (pathName == rhs.pathName) && (elementPitchBits == rhs.elementPitchBits) &&
        (registerAccess == rhs.registerAccess) && (getNumberOfDimensions() == rhs.getNumberOfDimensions()) &&
        (interruptId == rhs.interruptId);
  }
 
  /********************************************************************************************************************/
 
  bool NumericAddressedRegisterInfo::operator!=(const ChimeraTK::NumericAddressedRegisterInfo& rhs) const {
    return !operator==(rhs);
  }
 
  /********************************************************************************************************************/
 
  std::vector<size_t> NumericAddressedRegisterInfo::getQualifiedAsyncId() const {
    return interruptId;
  }
 
  /********************************************************************************************************************/
 
  bool NumericAddressedRegisterInfo::ChannelInfo::operator==(const ChannelInfo& rhs) const {
    return bitOffset == rhs.bitOffset && dataType == rhs.dataType && width == rhs.width &&
        nFractionalBits == rhs.nFractionalBits && signedFlag == rhs.signedFlag && rawType == rhs.rawType;
  }
 
  /********************************************************************************************************************/
 
  DataType NumericAddressedRegisterInfo::ChannelInfo::getRawType() const {
    return rawType;
  }
 
  /********************************************************************************************************************/
 
  bool NumericAddressedRegisterInfo::ChannelInfo::operator!=(const ChannelInfo& rhs) const {
    return !operator==(rhs);
  }
 
  /********************************************************************************************************************/
  /********************************************************************************************************************/
 
  NumericAddressedRegisterInfo NumericAddressedRegisterCatalogue::getBackendRegister(
      const RegisterPath& registerPathName) const {
    auto path = registerPathName;
    path.setAltSeparator(".");
 
    if(path.startsWith(numeric_address::BAR())) {
      // special treatment for numeric addresses
      auto components = path.getComponents();
      if(components.size() != 3) {
        throw ChimeraTK::logic_error("Illegal numeric address: '" + (path) + "'");
      }
      auto bar = std::stoi(components[1]);
      // Scan the second entry, starting with the signed/unsigned indicator and the bit width
      // We use the fact that stoi stops at the first non-numeric character, so it will stop at a * if it comes after
      // the u/s entry, or the other way around.
      bool signedFlag = true;
      size_t bitWidth = 32;
      size_t pos = components[2].find_first_of("uU");
      if(pos != std::string::npos) {
        signedFlag = false;
        bitWidth = std::stoi(components[2].substr(pos + 1));
      }
      else {
        pos = components[2].find_first_of("sS");
        if(pos != std::string::npos) {
          signedFlag = true;
          bitWidth = std::stoi(components[2].substr(pos + 1));
        }
      }
      if(bitWidth != 8 && bitWidth != 16 && bitWidth != 32 && bitWidth != 64) {
        throw ChimeraTK::logic_error("Illegal numeric address: '" + (path) + "'");
      }
      auto bytesPerElement = bitWidth / 8;
 
      // now scan for the number of bytes
      pos = components[2].find_first_of('*');
      auto address = std::stoi(components[2].substr(0, pos));
      size_t nBytes;
      if(pos != std::string::npos) {
        nBytes = std::stoi(components[2].substr(pos + 1));
      }
      else {
        nBytes = bytesPerElement;
      }
      auto nElements = nBytes / bytesPerElement;
      if(nBytes == 0 || nBytes % bytesPerElement != 0) {
        throw ChimeraTK::logic_error("Illegal numeric address: '" + (path) + "'");
      }
      return NumericAddressedRegisterInfo(
          path, nElements, address, nBytes, bar, bitWidth, /* fracBits */ 0, signedFlag);
    }
    if(path.startsWith("!")) {
      auto canonicalInterrupt = _canonicalInterrupts.find(path);
      if(canonicalInterrupt == _canonicalInterrupts.end()) {
        throw ChimeraTK::logic_error("Illegal canonical interrupt path: '" + (path) + "'");
      }
      return NumericAddressedRegisterInfo(path, 0, 0, 0, 0, 0, 0, false,
          NumericAddressedRegisterInfo::Access::INTERRUPT, NumericAddressedRegisterInfo::Type::VOID,
          canonicalInterrupt->second);
    }
    return BackendRegisterCatalogue::getBackendRegister(path);
  }
 
  /********************************************************************************************************************/
 
  [[nodiscard]] bool NumericAddressedRegisterCatalogue::hasRegister(const RegisterPath& registerPathName) const {
    if(registerPathName.startsWith(numeric_address::BAR())) {
      return true;
    }
    if(_canonicalInterrupts.find(registerPathName) != _canonicalInterrupts.end()) {
      return true;
    }
    return BackendRegisterCatalogue::hasRegister(registerPathName);
  }
 
  /********************************************************************************************************************/
 
  const std::set<std::vector<size_t>>& NumericAddressedRegisterCatalogue::getListOfInterrupts() const {
    return _listOfInterrupts;
  }
 
  /********************************************************************************************************************/
 
  void NumericAddressedRegisterCatalogue::addRegister(const NumericAddressedRegisterInfo& registerInfo) {
    if(registerInfo.registerAccess == NumericAddressedRegisterInfo::Access::INTERRUPT) {
      _listOfInterrupts.insert(registerInfo.interruptId);
      RegisterPath canonicalName = "!" + std::to_string(registerInfo.interruptId.front());
      std::vector<size_t> canonicalID = {registerInfo.interruptId.front()};
      _canonicalInterrupts[canonicalName] = canonicalID;
      for(auto subId = ++registerInfo.interruptId.begin(); subId != registerInfo.interruptId.end(); ++subId) {
        canonicalName += ":" + std::to_string(*subId);
        canonicalID.push_back(*subId);
        _canonicalInterrupts[canonicalName] = canonicalID;
      }
    }
    BackendRegisterCatalogue<NumericAddressedRegisterInfo>::addRegister(registerInfo);
  }
 
  /********************************************************************************************************************/
 
  std::unique_ptr<BackendRegisterCatalogueBase> NumericAddressedRegisterCatalogue::clone() const {
    std::unique_ptr<BackendRegisterCatalogueBase> c = std::make_unique<NumericAddressedRegisterCatalogue>();
    auto* casted_c = dynamic_cast<NumericAddressedRegisterCatalogue*>(c.get());
    fillFromThis(casted_c);
    return c;
  }
 
  /********************************************************************************************************************/
 
  void NumericAddressedRegisterCatalogue::fillFromThis(NumericAddressedRegisterCatalogue* target) const {
    BackendRegisterCatalogue<NumericAddressedRegisterInfo>::fillFromThis(target);
    target->_listOfInterrupts = _listOfInterrupts;
    target->_canonicalInterrupts = _canonicalInterrupts;
    target->_dataConsistencyRealms = _dataConsistencyRealms;
  }
 
  /********************************************************************************************************************/
 
  void NumericAddressedRegisterCatalogue::addDataConsistencyRealm(
      const RegisterPath& registerPath, const std::string& realmName) {
    _dataConsistencyRealms[registerPath] = realmName;
  }
 
  /********************************************************************************************************************/
 
  std::shared_ptr<async::DataConsistencyRealm> NumericAddressedRegisterCatalogue::getDataConsistencyRealm(
      const std::vector<size_t>& qualifiedAsyncDomainId) const {
    if(qualifiedAsyncDomainId.empty()) {
      return {};
    }
 
    // iterate _dataConsistencyRealms and check if the registerPath matches the qualifiedAsyncDomainId
    for(auto const& [registerPath, realmName] : _dataConsistencyRealms) {
      if(getBackendRegister(registerPath).getQualifiedAsyncId() == qualifiedAsyncDomainId) {
        auto& store = async::DataConsistencyRealmStore::getInstance();
        return store.getRealm(realmName);
      }
    }
    return {};
  }
 
  /********************************************************************************************************************/
 
  RegisterPath NumericAddressedRegisterCatalogue::getDataConsistencyKeyRegisterPath(
      const std::vector<size_t>& qualifiedAsyncDomainId) const {
    if(qualifiedAsyncDomainId.empty()) {
      return {};
    }
 
    // iterate _dataConsistencyRealms and check if the registerPath matches the qualifiedAsyncDomainId
    for(auto const& [registerPath, realmName] : _dataConsistencyRealms) {
      if(getBackendRegister(registerPath).getQualifiedAsyncId() == qualifiedAsyncDomainId) {
        return registerPath;
      }
    }
    return {};
  }
 
  /********************************************************************************************************************/
 
} // namespace ChimeraTK