DummyRegisterAccessor.h

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
#pragma once
 
#include "DummyBackend.h"
#include "NumericAddressedBackendMuxedRegisterAccessor.h" // for the prefixes to the register names
 
namespace ChimeraTK {
 
  namespace proxies {
    /******************************************************************************************************************/
    template<typename T>
    class DummyRegisterElement {
     public:
      DummyRegisterElement(FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT>* _fpc, int _nbytes, int32_t* _buffer)
      : fpcptr(_fpc), nbytes(_nbytes), buffer(_buffer) {}
 
      // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
      inline operator T() const { return fpcptr->template scalarToCooked<T>(*buffer); }
 
      inline DummyRegisterElement<T>& operator=(T rhs) {
        int32_t raw = fpcptr->toRaw(rhs);
        memcpy(buffer, &raw, nbytes);
        return *this;
      }
 
      inline DummyRegisterElement<T> operator++() {
        T cooked = fpcptr->template scalarToCooked<T>(*buffer);
        return operator=(cooked + 1);
      }
 
      inline DummyRegisterElement<T> operator--() {
        T cooked = fpcptr->template scalarToCooked<T>(*buffer);
        return operator=(cooked - 1);
      }
 
      inline T operator++(int) {
        T cooked = fpcptr->template scalarToCooked<T>(*buffer);
        operator=(cooked + 1);
        return cooked;
      }
 
      inline T operator--(int) {
        T cooked = fpcptr->template scalarToCooked<T>(*buffer);
        operator=(cooked - 1);
        return cooked;
      }
 
     protected:
      DummyRegisterElement() : fpcptr(nullptr), nbytes(0), buffer(nullptr) {}
 
      FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT>* fpcptr;
 
      int nbytes;
 
      int32_t* buffer;
    };
 
    /******************************************************************************************************************/
    template<typename T>
    class DummyRegisterSequence {
     public:
      DummyRegisterSequence(
          FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT>* _fpc, int _nbytes, int _pitch, int32_t* _buffer)
      : fpcptr(_fpc), nbytes(_nbytes), pitch(_pitch), buffer(_buffer) {}
 
      inline DummyRegisterElement<T> operator[](unsigned int sample) {
        // todo: Probably ranges are the correct tool in cpp22. In cpp17 this is not available yet. We turn off the
        // warning not to use reinterpret_cast for the time being
        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
        auto* basePtr = reinterpret_cast<std::byte*>(buffer);
        auto* startAddress = basePtr + static_cast<size_t>(pitch) * sample;
        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
        return DummyRegisterElement<T>(fpcptr, nbytes, reinterpret_cast<int32_t*>(startAddress));
      }
 
      void operator=(const DummyRegisterSequence& rightHandSide) const = delete;
 
     protected:
      FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT>* fpcptr;
 
      int nbytes;
 
      int pitch;
 
      int32_t* buffer;
    };
  } // namespace proxies
 
  /********************************************************************************************************************/
  template<typename T>
  class DummyRegisterAccessor : public proxies::DummyRegisterElement<T> {
   public:
    DummyRegisterAccessor(DummyBackend* dev, std::string const& module, std::string const& name)
    : _dev(dev), _path(module + "/" + name), fpc(module + "/" + name) {
      registerInfo = _dev->_registerMap.getBackendRegister(_path);
      fpc = FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT>(module + "/" + name, registerInfo.channels.front().width,
          registerInfo.channels.front().nFractionalBits, registerInfo.channels.front().signedFlag);
      // initialise the base DummyRegisterElement
      proxies::DummyRegisterElement<T>::fpcptr = &fpc;
      proxies::DummyRegisterElement<T>::nbytes = sizeof(int32_t);
      proxies::DummyRegisterElement<T>::buffer = getElement(0);
    }
    // declare that we want the default copy constructor. Needed because we have a custom = operator
    DummyRegisterAccessor(const DummyRegisterAccessor&) = default;
 
    void operator=(const DummyRegisterAccessor& rightHandSide) const = delete;
 
    inline proxies::DummyRegisterElement<T> operator[](unsigned int index) { return getProxy(index); }
 
    unsigned int getNumberOfElements() { return registerInfo.nElements; }
 
    using proxies::DummyRegisterElement<T>::operator=;
 
    [[nodiscard]] DummyBackend& getBackend() const { return *_dev; }
 
    [[nodiscard]] const RegisterPath& getRegisterPath() const { return _path; }
 
    void setWriteCallback(const std::function<void()>& writeCallback) {
      assert(registerInfo.elementPitchBits % 8 == 0);
      _dev->setWriteCallbackFunction(
          {static_cast<uint8_t>(registerInfo.bar), static_cast<uint32_t>(registerInfo.address),
              registerInfo.nElements * registerInfo.elementPitchBits / 8},
          writeCallback);
    }
 
    const NumericAddressedRegisterInfo& getRegisterInfo() { return registerInfo; }
 
    std::unique_lock<std::mutex> getBufferLock() { return std::unique_lock<std::mutex>(_dev->mutex); }
 
   protected:
    DummyBackend* _dev;
 
    NumericAddressedRegisterInfo registerInfo;
 
    RegisterPath _path;
 
    FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT> fpc;
 
    inline int32_t* getElement(unsigned int index) {
      return &(_dev->_barContents[registerInfo.bar][registerInfo.address / sizeof(int32_t) + index]);
    }
 
    inline proxies::DummyRegisterElement<T> getProxy(int index) {
      return proxies::DummyRegisterElement<T>(&fpc, sizeof(int32_t), getElement(index));
    }
  };
 
  /********************************************************************************************************************/
  template<typename T>
  class DummyMultiplexedRegisterAccessor {
   public:
    DummyMultiplexedRegisterAccessor(DummyBackend* dev, std::string const& module, std::string const& name)
    : _dev(dev), _path(module + "/" + name) {
      registerInfo = _dev->_registerMap.getBackendRegister(module + "." + name);
 
      // create fixed point converters for each channel
      for(auto& c : registerInfo.channels) {
        // create fixed point converter for sequence
        fpc.emplace_back(registerInfo.pathName, c.width, c.nFractionalBits, c.signedFlag);
        // store offsets and number of bytes per word
        assert(c.bitOffset % 8 == 0);
        offsets.push_back(registerInfo.address + c.bitOffset / 8);
        nbytes.push_back((c.width - 1) / 8 + 1); // width/8 rounded up
      }
 
      if(fpc.empty()) {
        throw ChimeraTK::logic_error("No sequences found for name \"" + name + "\".");
      }
 
      // cache some information
      nElements = registerInfo.nElements;
      assert(registerInfo.elementPitchBits % 8 == 0);
      pitch = registerInfo.elementPitchBits / 8;
    }
 
    void operator=(const DummyMultiplexedRegisterAccessor& rightHandSide) const = delete;
 
    // declare that we want the default copy constructor. Needed because we have a custom = operator
    DummyMultiplexedRegisterAccessor(const DummyMultiplexedRegisterAccessor&) = default;
 
    unsigned int getNumberOfElements() { return nElements; }
 
    unsigned int getNumberOfSequences() { return fpc.size(); }
 
    inline proxies::DummyRegisterSequence<T> operator[](unsigned int sequence) {
      // todo: Probably ranges are the correct tool in cpp22. In cpp17 this is not available yet. We turn off the
      // warning not to use reinterpret_cast for the time being
      // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
      auto* basePtr = reinterpret_cast<std::byte*>(_dev->_barContents[registerInfo.bar].data());
      // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
      auto* seq = reinterpret_cast<int32_t*>(basePtr + offsets[sequence]);
      return proxies::DummyRegisterSequence<T>(&(fpc[sequence]), nbytes[sequence], pitch, seq);
    }
 
    [[nodiscard]] DummyBackend& getBackend() const { return *_dev; }
 
    [[nodiscard]] const RegisterPath& getRegisterPath() const { return _path; }
 
    [[nodiscard]] const NumericAddressedRegisterInfo& getRegisterInfo() { return registerInfo; }
 
   protected:
    DummyBackend* _dev;
 
    NumericAddressedRegisterInfo registerInfo;
 
    RegisterPath _path;
 
    std::vector<FixedPointConverter<DEPRECATED_FIXEDPOINT_DEFAULT>> fpc;
 
    std::vector<uint32_t> offsets;
 
    std::vector<uint32_t> nbytes;
 
    int pitch = {0};
 
    unsigned int nElements;
  };
 
  class DummyRegisterRawAccessor {
   public:
    // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
    operator int32_t&() { return *buffer; }
 
    DummyRegisterRawAccessor(
        boost::shared_ptr<DeviceBackend> const& backend, std::string const& module, std::string const& name)
    : _backend(boost::dynamic_pointer_cast<DummyBackend>(backend)) {
      assert(_backend);
      registerInfo = _backend->_registerMap.getBackendRegister(module + "." + name);
      buffer = &(_backend->_barContents[registerInfo.bar][registerInfo.address / sizeof(int32_t)]);
    }
 
    // declare that we want the default copy constructor. Needed because we have a custom = operator
    // The default copy/move constructor is fine. It will copy the raw pointer to the buffer,
    // together with the shared pointer which holds the corresponding backend with the
    // memory. So it is a consistent copy because the shared pointer is pointing to the
    // same backend instance.
    DummyRegisterRawAccessor(const DummyRegisterRawAccessor&) = default;
 
    void operator=(const DummyRegisterRawAccessor& rightHandSide) const = delete;
 
    DummyRegisterRawAccessor& operator=(int32_t rhs) {
      buffer[0] = rhs;
      return *this;
    }
 
    int32_t& operator[](unsigned int index) { return buffer[index]; }
 
    [[nodiscard]] unsigned int getNumberOfElements() const { return registerInfo.nElements; }
 
    std::unique_lock<std::mutex> getBufferLock() { return std::unique_lock<std::mutex>(_backend->mutex); }
 
   protected:
    boost::shared_ptr<DummyBackend> _backend;
 
    NumericAddressedRegisterInfo registerInfo;
 
    int32_t* buffer;
  };
 
} // namespace ChimeraTK