DummyBackend.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 "DummyBackendBase.h"
#include "Exception.h"
 
#include <boost/function.hpp>
 
#include <list>
#include <map>
#include <mutex>
#include <set>
#include <vector>
 
namespace ChimeraTK {
 
  // forward declarations
  template<typename T>
  class DummyRegisterAccessor;
 
  template<typename T>
  class DummyMultiplexedRegisterAccessor;
 
  class DummyRegisterRawAccessor;
 
  class DummyBackend : public DummyBackendBase {
   public:
    explicit DummyBackend(const std::string& mapFileName, const std::string& dataConsistencyKeyDescriptor = "");
    ~DummyBackend() override = default;
 
    void open() override;
 
    void closeImpl() override;
 
    using DummyBackendBase::read;  // use the 32 bit version from the base class
    using DummyBackendBase::write; // use the 32 bit version from the base class
    void read(uint64_t bar, uint64_t address, int32_t* data, size_t sizeInBytes) override;
    void write(uint64_t bar, uint64_t address, int32_t const* data, size_t sizeInBytes) override;
 
    std::string readDeviceInfo() override;
 
    static boost::shared_ptr<DeviceBackend> createInstance(
        std::string address, std::map<std::string, std::string> parameters);
 
    DummyRegisterRawAccessor getRawAccessor(const std::string& module, const std::string& register_name);
 
    VersionNumber triggerInterrupt(uint32_t interruptNumber) override;
 
   protected:
    struct AddressRange {
      const uint64_t offset;
      const uint32_t sizeInBytes;
      const uint64_t bar;
 
      AddressRange(uint64_t bar_, uint64_t address, size_t sizeInBytes_)
      : offset(address), sizeInBytes(sizeInBytes_), bar(bar_) {}
 
      explicit AddressRange(const NumericAddressedRegisterInfo& info)
      : offset(info.address), sizeInBytes(info.nElements * info.elementPitchBits / 8), bar(info.bar) {
        assert(info.elementPitchBits % 8 == 0);
      }
 
      bool operator<(AddressRange const& right) const {
        return (bar == right.bar ? (offset < right.offset) : bar < right.bar);
      }
    };
 
    std::string _mapFile;
 
    std::map<uint64_t, std::vector<int32_t>> _barContents;
    std::set<std::pair<uint64_t, uint64_t>> _readOnlyAddresses; // bar/address combinations which are read only
    std::multimap<AddressRange, boost::function<void(void)>> _writeCallbackFunctions;
    std::mutex mutex;
 
    void resizeBarContents();
 
    void runWriteCallbackFunctionsForAddressRange(AddressRange addressRange);
    std::list<boost::function<void(void)>> findCallbackFunctionsForAddressRange(AddressRange addressRange);
 
    void setReadOnly(uint64_t bar, uint64_t address, size_t sizeInWords);
    void setReadOnly(AddressRange addressRange);
    bool isReadOnly(uint64_t bar, uint64_t address) const;
    void setWriteCallbackFunction(AddressRange addressRange, boost::function<void(void)> const& writeCallbackFunction);
    bool isWriteRangeOverlap(AddressRange firstRange, AddressRange secondRange);
 
    void writeRegisterWithoutCallback(uint64_t bar, uint64_t address, int32_t data);
 
    template<typename T>
    friend class DummyRegisterAccessor;
 
    template<typename T>
    friend class DummyMultiplexedRegisterAccessor;
 
    friend class DummyRegisterRawAccessor;
    friend class SharedDummyBackend;
 
    static std::string convertPathRelativeToDmapToAbs(std::string const& mapfileName);
  };
 
} // namespace ChimeraTK