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"
 
namespace ChimeraTK {
 
  namespace proxies {
 
    /******************************************************************************************************************/
 
    template<typename UserType>
    class RawConverterCapsule {
     public:
      virtual ~RawConverterCapsule() = default;
      virtual UserType toCooked(std::byte* raw) = 0;
      virtual void toRaw(UserType cooked, std::byte* raw) = 0;
      static std::shared_ptr<RawConverterCapsule<UserType>> makeCapsule(
          const ChimeraTK::NumericAddressedRegisterInfo& info, size_t channelIndex);
    };
 
    /******************************************************************************************************************/
    template<typename T>
    class DummyRegisterElement {
     public:
      DummyRegisterElement(std::shared_ptr<RawConverterCapsule<T>>& rc, int nbytes, std::byte* buffer)
      : _rc(rc), _nbytes(nbytes), _buffer(buffer) {}
 
      // NOLINTNEXTLINE(google-explicit-constructor, hicpp-explicit-conversions)
      operator T() const { return _rc->toCooked(_buffer); }
 
      DummyRegisterElement<T>& operator=(T rhs) {
        _rc->toRaw(rhs, _buffer);
        return *this;
      }
 
      DummyRegisterElement<T> operator++() {
        T cooked = _rc->toCooked(_buffer);
        return operator=(cooked + 1);
      }
 
      DummyRegisterElement<T> operator--() {
        T cooked = _rc->toCooked(_buffer);
 
        return operator=(cooked - 1);
      }
 
      T operator++(int) {
        T cooked = _rc->toCooked(_buffer);
 
        operator=(cooked + 1);
        return cooked;
      }
 
      T operator--(int) {
        T cooked = _rc->toCooked(_buffer);
 
        operator=(cooked - 1);
        return cooked;
      }
 
     protected:
      std::shared_ptr<RawConverterCapsule<T>>& _rc;
 
      int _nbytes;
 
      std::byte* _buffer;
    };
 
    /******************************************************************************************************************/
    template<typename T>
    class DummyRegisterSequence {
     public:
      DummyRegisterSequence(
          std::shared_ptr<proxies::RawConverterCapsule<T>>& rc, int nbytes, int pitch, int32_t* buffer)
      : _rc(rc), _nbytes(nbytes), _pitch(pitch), _buffer(buffer) {}
 
      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* startPtr = basePtr + static_cast<size_t>(_pitch) * sample;
        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
        return DummyRegisterElement<T>(_rc, _nbytes, startPtr);
      }
 
      void operator=(const DummyRegisterSequence& rightHandSide) const = delete;
 
     protected:
      std::shared_ptr<proxies::RawConverterCapsule<T>>& _rc;
 
      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)
    : proxies::DummyRegisterElement<T>(_rc, 0, nullptr), _dev(dev), _path(module + "/" + name),
      _registerInfo(_dev->_registerMap.getBackendRegister(_path)),
      _rc(proxies::RawConverterCapsule<T>::makeCapsule(_registerInfo, 0)) {
      // initialise the base DummyRegisterElement
      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;
 
    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;
 
    RegisterPath _path;
 
    NumericAddressedRegisterInfo _registerInfo;
 
    std::shared_ptr<proxies::RawConverterCapsule<T>> _rc;
 
    std::byte* getElement(unsigned int index) {
      // elements are strided by elementPitchBits (which equals the element size for ordinary contiguous
      // registers, i.e. elementPitchBits / 32 == 1); a channel slice of a 2D register has a larger pitch
      // FIXME: this is currently limited to pitches divisible by 32 bits, because the dummy uses 32 bit words as an
      // internal representation.
      if((_registerInfo.address % sizeof(int32_t)) != 0 ||
          (_registerInfo.elementPitchBits % (8 * sizeof(int32_t))) != 0) {
        throw ChimeraTK::logic_error("DummyRegisterAccessor: elementPitchBits/address must be 32-bit aligned for "
                                     "strided element access. Register: " +
            _path);
      }
      const auto strideWords = _registerInfo.elementPitchBits / (8 * sizeof(int32_t));
      auto* ptr =
          &(_dev->_barContents[_registerInfo.bar][_registerInfo.address / sizeof(int32_t) + index * strideWords]);
      // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
      return reinterpret_cast<std::byte*>(ptr);
    }
 
    proxies::DummyRegisterElement<T> getProxy(int index) {
      return proxies::DummyRegisterElement<T>(_rc, 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
      size_t ci = 0;
      for(auto& c : _registerInfo.channels) {
        // create fixed point converter for sequence
        _rc.emplace_back(proxies::RawConverterCapsule<T>::makeCapsule(_registerInfo, ci));
        // 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
        ++ci;
      }
 
      if(_rc.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 _rc.size(); }
 
    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>(_rc[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<std::shared_ptr<proxies::RawConverterCapsule<T>>> _rc;
 
    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