NumericAddressedLowLevelTransferElement.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 "NumericAddressedBackend.h"
#include "ReadCoordinator.h"
#include "TransferElement.h"
 
namespace ChimeraTK {
 
  template<typename UserType, bool isRaw>
  class NumericAddressedBackendRegisterAccessor;
 
  class NumericAddressedBackendASCIIAccessor;
 
  /********************************************************************************************************************/
  class NumericAddressedLowLevelTransferElement : public TransferElement {
   public:
    NumericAddressedLowLevelTransferElement(
        const boost::shared_ptr<NumericAddressedBackend>& dev, size_t bar, size_t startAddress, size_t numberOfBytes)
    : TransferElement("", {AccessMode::raw}), _dev(dev), _bar(bar),
      _unalignedAccess(_dev->_unalignedAccess, std::defer_lock) {
      if(!dev->barIndexValid(bar)) {
        std::stringstream errorMessage;
        errorMessage << "Invalid bar number: " << bar << std::endl;
        throw ChimeraTK::logic_error(errorMessage.str());
      }
      setAddress(startAddress, numberOfBytes);
    }
 
    ~NumericAddressedLowLevelTransferElement() override = default;
 
    void doReadTransferSynchronously() override {
      // There is nothing we can do about reinterpet_casting with the C-style interface
      // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
      _dev->read(_bar, _startAddress, reinterpret_cast<int32_t*>(rawDataBuffer.data()), _numberOfBytes);
    }
 
    bool doWriteTransfer(ChimeraTK::VersionNumber) override {
      // There is nothing we can do about reinterpet_casting with the C-style interface
      // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
      _dev->write(_bar, _startAddress, reinterpret_cast<int32_t*>(rawDataBuffer.data()), _numberOfBytes);
      return false;
    }
 
    void doPostRead(TransferType, bool hasNewData) override {
      if(hasNewData) {
        // it is acceptable to create a new version number only in doPostRead because the LowLevelTransferElement never
        // has wait_for_new_data.
        _versionNumber = {};
 
        // Run the read coordinator once for this read (the base class calls doPostRead at most once per read)
        _readCoordinator.run(rawDataBuffer);
      }
    }
 
    void doPreWrite(TransferType, VersionNumber) override {
      if(_isUnaligned) {
        _unalignedAccess.lock();
        // There is nothing we can do about reinterpet_casting with the C-style interface
        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
        _dev->read(_bar, _startAddress, reinterpret_cast<int32_t*>(rawDataBuffer.data()), _numberOfBytes);
      }
    }
 
    void doPostWrite(TransferType, VersionNumber) override {
      if(_unalignedAccess.owns_lock()) {
        _unalignedAccess.unlock();
      }
    }
 
    bool isMergeable(const boost::shared_ptr<TransferElement const>& other) const {
      if(!_dev->canMergeRequests()) return false;
 
      // accessor type, device and bar must be the same
      auto rhsCasted = boost::dynamic_pointer_cast<const NumericAddressedLowLevelTransferElement>(other);
      if(!rhsCasted) return false;
      if(_dev != rhsCasted->_dev) return false;
      if(_bar != rhsCasted->_bar) return false;
 
      // only allow adjacent and overlapping address areas to be merged
      if(_startAddress + _numberOfBytes < rhsCasted->_startAddress) return false;
      if(_startAddress > rhsCasted->_startAddress + rhsCasted->_numberOfBytes) return false;
      return true;
    }
 
    bool mayReplaceOther(const boost::shared_ptr<TransferElement const>&) const override {
      return false; // never used, since isMergeable() is used instead
    }
 
    const std::type_info& getValueType() const override {
      // This implementation is for int32_t only (as all numerically addressed
      // backends under the hood.
      return typeid(int32_t);
    }
 
    bool isReadOnly() const override { return false; }
 
    bool isReadable() const override { return true; }
 
    bool isWriteable() const override { return true; }
 
    uint8_t* begin(size_t addressInBar) { return rawDataBuffer.data() + (addressInBar - _startAddress); }
 
    void changeAddress(size_t startAddress, size_t numberOfWords) {
      setAddress(startAddress, numberOfWords);
      isShared = true;
    }
 
    boost::shared_ptr<TransferElement> makeCopyRegisterDecorator() override { // LCOV_EXCL_LINE
      throw ChimeraTK::logic_error("NumericAddressedLowLevelTransferElement::makeCopyRegisterDecorator() "
                                   "is not implemented"); // LCOV_EXCL_LINE
    } // LCOV_EXCL_LINE
 
   protected:
    void setAddress(size_t startAddress, size_t numberOfBytes) {
      // change address
      _startAddress = startAddress;
      _numberOfBytes = numberOfBytes;
 
      // make sure access is properly aligned
      _isUnaligned = false;
      auto alignment = _dev->minimumTransferAlignment(_bar);
      auto start_padding = _startAddress % alignment;
      assert(_startAddress >= start_padding);
      if(start_padding > 0) _isUnaligned = true;
      _startAddress -= start_padding;
      _numberOfBytes += start_padding;
      auto end_padding = alignment - _numberOfBytes % alignment;
      if(end_padding != alignment) {
        _isUnaligned = true;
        _numberOfBytes += end_padding;
      }
 
      // Allocated the buffer
      rawDataBuffer.resize(_numberOfBytes);
 
      // update the name
      _name = "NALLTE:" + std::to_string(_startAddress) + "+" + std::to_string(_numberOfBytes);
    }
 
    boost::shared_ptr<NumericAddressedBackend> _dev;
 
    uint64_t _bar;
 
    uint64_t _startAddress{};
 
    size_t _numberOfBytes{};
 
    bool isShared{false};
 
    bool _isUnaligned{false};
 
    std::unique_lock<std::mutex> _unalignedAccess;
 
    std::vector<uint8_t> rawDataBuffer;
 
    detail::ReadCoordinator _readCoordinator;
 
    std::vector<boost::shared_ptr<TransferElement>> getHardwareAccessingElements() override {
      return {boost::enable_shared_from_this<TransferElement>::shared_from_this()};
    }
 
    std::list<boost::shared_ptr<TransferElement>> getInternalElements() override { return {}; }
 
    void replaceTransferElement(boost::shared_ptr<TransferElement> /*newElement*/) override {} // LCOV_EXCL_LINE
 
    template<typename UserType, bool isRaw>
    friend class NumericAddressedBackendRegisterAccessor;
 
    friend class NumericAddressedBackendASCIIAccessor;
  };
 
} // namespace ChimeraTK