DummyBackendBase.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/AsyncNDRegisterAccessor.h"
#include "DummyInterruptTriggerAccessor.h"
#include "NumericAddressedBackend.h"
#include "NumericAddressedBackendMuxedRegisterAccessor.h"
#include "NumericAddressedBackendRegisterAccessor.h"
 
#include <sstream>
 
// macro to avoid code duplication
#define TRY_REGISTER_ACCESS(COMMAND)                                                                                   \
  try {                                                                                                                \
    COMMAND                                                                                                            \
  }                                                                                                                    \
  catch(std::out_of_range & outOfRangeException) {                                                                     \
    std::stringstream errorMessage;                                                                                    \
    errorMessage << "Invalid address offset " << address << " in bar " << bar << "."                                   \
                 << "Caught out_of_range exception: " << outOfRangeException.what();                                   \
    std::cout << errorMessage.str() << std::endl;                                                                      \
    throw ChimeraTK::logic_error(errorMessage.str());                                                                  \
  }
 
namespace ChimeraTK {
  class DummyBackendBase : public NumericAddressedBackend {
   public:
    explicit DummyBackendBase(std::string const& mapFileName, const std::string& dataConsistencyKeyDescriptor = "");
 
    ~DummyBackendBase() override = default;
 
    size_t minimumTransferAlignment([[maybe_unused]] uint64_t bar) const override;
 
    // Declare that we are going to override getRegisterAccessor_impl
    DEFINE_VIRTUAL_FUNCTION_OVERRIDE_VTABLE(NumericAddressedBackend, getRegisterAccessor_impl,
        boost::shared_ptr<NDRegisterAccessor<T>>(const RegisterPath&, size_t, size_t, AccessModeFlags));
 
    virtual VersionNumber triggerInterrupt(uint32_t interruptNumber) = 0;
 
    void read([[maybe_unused]] uint8_t bar, [[maybe_unused]] uint32_t address, [[maybe_unused]] int32_t* data,
        [[maybe_unused]] size_t sizeInBytes) final {
      throw;
    }
 
    void write([[maybe_unused]] uint8_t bar, [[maybe_unused]] uint32_t address, [[maybe_unused]] int32_t const* data,
        [[maybe_unused]] size_t sizeInBytes) final {
      throw;
    }
 
    bool barIndexValid([[maybe_unused]] uint64_t bar) override;
 
    std::map<uint64_t, size_t> getBarSizesInBytesFromRegisterMapping() const;
 
    static void checkSizeIsMultipleOfWordSize(size_t sizeInBytes);
 
    std::atomic<bool> throwExceptionOpen{false};
    std::atomic<bool> throwExceptionRead{false};
    std::atomic<bool> throwExceptionWrite{false};
    std::atomic<size_t> throwExceptionCounter{0};
 
    template<typename UserType>
    boost::shared_ptr<NDRegisterAccessor<UserType>> getRegisterAccessor_impl(
        const RegisterPath& registerPathName, size_t numberOfWords, size_t wordOffsetInRegister, AccessModeFlags flags);
 
    template<typename T, typename... Args>
    static boost::shared_ptr<DeviceBackend> returnInstance(
        [[maybe_unused]] const std::string& instanceId, Args&&... arguments) {
      return boost::make_shared<T>(std::forward<Args>(arguments)...);
    }
 
    // Helper function to get x from DUMMY_INTERRUPT_x.
    // The first element of the returned pair is "true" if an according interrupt is in the catalogue. If the
    // registerPathName is not DUMMY_INTERRUPT_x or the interrupt is not in the catalogue, the first element is
    // "false", and the second/ parameter is invalid.
    std::pair<bool, int> extractControllerInterrupt(const RegisterPath& registerPathName) const;
 
  }; // class DummyBackendBase
 
} // namespace ChimeraTK