NumericAddressedBackend.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 "async/DomainImpl.h"
#include "CountedRecursiveMutex.h"
#include "DeviceBackendImpl.h"
#include "NumericAddressedRegisterCatalogue.h"
 
#include <boost/pointer_cast.hpp>
 
#include <mutex>
#include <string>
 
namespace ChimeraTK {
 
  class NumericAddressedLowLevelTransferElement;
  class TriggeredPollDistributor;
 
  class NumericAddressedBackend : public DeviceBackendImpl {
   public:
    explicit NumericAddressedBackend(const std::string& mapFileName = "",
        std::unique_ptr<NumericAddressedRegisterCatalogue> registerMapPointer =
            std::make_unique<NumericAddressedRegisterCatalogue>(),
        const std::string& dataConsistencyKeyDescriptor = "");
 
    ~NumericAddressedBackend() override = default;
 
    virtual void read(uint64_t bar, uint64_t address, int32_t* data, size_t sizeInBytes);
 
    virtual void write(uint64_t bar, uint64_t address, int32_t const* data, size_t sizeInBytes);
 
    [[deprecated]] virtual void read([[maybe_unused]] uint8_t bar, [[maybe_unused]] uint32_t address,
        [[maybe_unused]] int32_t* data, [[maybe_unused]] size_t sizeInBytes);
 
    [[deprecated]] virtual void write([[maybe_unused]] uint8_t bar, [[maybe_unused]] uint32_t address,
        [[maybe_unused]] int32_t const* data, [[maybe_unused]] size_t sizeInBytes);
 
    virtual bool barIndexValid(uint64_t bar);
 
    virtual bool canMergeRequests() const { return true; }
 
    virtual size_t minimumTransferAlignment([[maybe_unused]] uint64_t bar) const { return 1; }
 
    RegisterCatalogue getRegisterCatalogue() const override;
 
    MetadataCatalogue getMetadataCatalogue() const override;
 
    NumericAddressedRegisterInfo getRegisterInfo(const RegisterPath& registerPathName);
 
    void activateAsyncRead() noexcept override;
 
    void close() final;
 
    virtual void closeImpl() {}
 
    virtual std::future<void> activateSubscription(
        uint32_t interruptNumber, boost::shared_ptr<async::DomainImpl<std::nullptr_t>> asyncDomain);
 
    void setExceptionImpl() noexcept override;
 
    template<typename BackendSpecificUserType>
    std::pair<BackendSpecificUserType, VersionNumber> getAsyncDomainInitialValue(size_t asyncDomainId);
 
   protected:
    /*
     * Register catalogue. A reference is used here which is filled from _registerMapPointer in the constructor to allow
     * backend implementations to provide their own type based on the NumericAddressedRegisterCatalogue.
     */
    std::unique_ptr<NumericAddressedRegisterCatalogue> _registerMapPointer;
    NumericAddressedRegisterCatalogue& _registerMap;
 
    MetadataCatalogue _metadataCatalogue;
 
    std::mutex _unalignedAccess;
 
    friend NumericAddressedLowLevelTransferElement;
    friend TriggeredPollDistributor;
 
    template<class UserType>
    friend class NumericAddressedBackendMuxedRegisterAccessor;
 
   private:
    template<typename UserType>
    boost::shared_ptr<NDRegisterAccessor<UserType>> getRegisterAccessor_impl(
        const RegisterPath& registerPathName, size_t numberOfWords, size_t wordOffsetInRegister, AccessModeFlags flags);
 
    // internal helper function to get the a synchronous accessor, which is also needed by the asynchronous version
    // internally, but is not given out
    template<typename UserType>
    boost::shared_ptr<NDRegisterAccessor<UserType>> getSyncRegisterAccessor(
        const RegisterPath& registerPathName, size_t numberOfWords, size_t wordOffsetInRegister, AccessModeFlags flags);
 
    std::atomic_bool _asyncIsActive{false};
 
    std::unordered_map<std::string, std::shared_ptr<detail::CountedRecursiveMutex>> _doubleBufferMutexMap;
  };
 
  /********************************************************************************************************************/
 
  template<typename BackendSpecificUserType>
  std::pair<BackendSpecificUserType, VersionNumber> NumericAddressedBackend::getAsyncDomainInitialValue(
      [[maybe_unused]] size_t asyncDomainId) {
    static_assert(std::is_same<BackendSpecificUserType, std::nullptr_t>::value,
        "NumericAddressedBackend only supports async::Domain<nullptr_t>.");
    return {nullptr, VersionNumber{nullptr}};
  }
 
} // namespace ChimeraTK