ExceptionDummyBackend.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"
#include "NDRegisterAccessorDecorator.h"
 
#include <utility>
 
namespace ChimeraTK {
 
  template<typename UserType>
  struct ExceptionDummyPushDecorator;
 
  struct ExceptionDummyPushDecoratorBase;
 
  struct ExceptionDummyPollDecoratorBase;
  template<typename UserType>
  struct ExceptionDummyPollDecorator;
 
  /********************************************************************************************************************/
 
  class ExceptionDummy : public ChimeraTK::DummyBackend {
   public:
    explicit ExceptionDummy(std::string const& mapFileName);
 
    DEFINE_VIRTUAL_FUNCTION_OVERRIDE_VTABLE(DummyBackendBase, getRegisterAccessor_impl,
        boost::shared_ptr<NDRegisterAccessor<T>>(const RegisterPath&, size_t, size_t, AccessModeFlags));
 
    static boost::shared_ptr<DeviceBackend> createInstance(
        std::string address, std::map<std::string, std::string> parameters);
 
    void open() override;
 
    void closeImpl() override;
 
    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;
 
    void triggerPush(RegisterPath path, VersionNumber v = {});
 
    size_t getWriteOrder(const RegisterPath& path);
 
    size_t getWriteCount(const RegisterPath& path);
 
    void activateAsyncRead() noexcept override;
 
    void setExceptionImpl() noexcept override;
 
    bool asyncReadActivated();
 
    std::mutex _pushDecoratorsMutex;
    std::map<RegisterPath, std::list<boost::weak_ptr<ExceptionDummyPushDecoratorBase>>> _pushDecorators;
    std::map<RegisterPath, VersionNumber> _pushVersions;
    bool _activateNewPushAccessors{false};
 
    std::mutex _registerValiditiesMutex;
    std::map<RegisterPath, DataValidity> _registerValidities;
    void setValidity(RegisterPath path, DataValidity val) {
      path.setAltSeparator(".");
      std::unique_lock<std::mutex> lk(_registerValiditiesMutex);
      _registerValidities[path] = val;
    }
    DataValidity getValidity(RegisterPath path) {
      path.setAltSeparator(".");
      std::unique_lock<std::mutex> lk(_registerValiditiesMutex);
      // simply return default enum value 0 = DataValidity::ok unless path is explicity found in map
      return _registerValidities[path];
    }
 
    std::map<std::pair<uint64_t, uint64_t>, std::atomic<size_t>> _writeOrderMap;
 
    std::atomic<size_t> _writeOrderCounter{0};
 
    std::map<std::pair<uint64_t, uint64_t>, std::atomic<size_t>> _writeCounterMap;
 
   private:
    template<typename UserType>
    boost::shared_ptr<NDRegisterAccessor<UserType>> getRegisterAccessor_impl(
        const RegisterPath& registerPathName, size_t numberOfWords, size_t wordOffsetInRegister, AccessModeFlags flags);
  };
 
  /********************************************************************************************************************/
 
  struct ExceptionDummyPushDecoratorBase {
    virtual ~ExceptionDummyPushDecoratorBase() = default;
    virtual void trigger() = 0;
    bool _isActive{false};
    bool _hasException{false};
  };
 
  /********************************************************************************************************************/
 
  template<typename UserType>
  struct ExceptionDummyPushDecorator : NDRegisterAccessorDecorator<UserType>, ExceptionDummyPushDecoratorBase {
    ExceptionDummyPushDecorator(const boost::shared_ptr<ChimeraTK::NDRegisterAccessor<UserType>>& target,
        boost::shared_ptr<ExceptionDummy> backend)
    : NDRegisterAccessorDecorator<UserType>(target), _backend(std::move(backend)) {
      assert(_target->isReadable());
 
      this->_accessModeFlags = _target->getAccessModeFlags();
      this->_accessModeFlags.add(AccessMode::wait_for_new_data);
 
      _readQueue =
          _myReadQueue.template then<void>([&](Buffer current) { this->_current = current; }, std::launch::deferred);
 
      _path = _target->getName();
      _path.setAltSeparator(".");
      _path /= "PUSH_READ";
    }
 
    ~ExceptionDummyPushDecorator() override {
      std::unique_lock<std::mutex> lk(_backend->_pushDecoratorsMutex);
      try {
        auto& list = _backend->_pushDecorators.at(_path);
        for(auto it = list.begin(); it != list.end(); ++it) {
          if(it->lock().get() == nullptr) { // weak_ptr is already not lockable any more
            list.erase(it);
            return;
          }
        }
      }
      catch(std::exception& e) {
        // The exception that could show up here is coming from >_pushDecorators.at().
        // It might be std::out_of_range if the _path is not in, or an exception from the string comparison inside of
        // std::map::at(). Both should not be possible be due to the code logic. The code will run into an assertion in
        // debug mode. Let's hope the what() string gives us valuable information.
        std::cout << "~ExceptionDummyPushDecorator(): Unexpected  exception: " << e.what() << std::endl;
      }
      std::cout << "~ExceptionDummyPushDecorator(): Could not unlist instance!" << std::endl;
      assert(false);
    }
 
    void interrupt() override { this->interrupt_impl(this->_myReadQueue); }
 
    void setExceptionBackend(boost::shared_ptr<DeviceBackend> exceptionBackend) override {
      // do not set it for the target, since we read from the target in trigger(), but that is the wrong place to
      // call setException(). So we don't call it on our base class NDRegisterAccessorDecorator but on the
      // TransferElement itself.
      // Turn off the linter warning. This is intentional.
      // NOLINTNEXTLINE(bugprone-parent-virtual-call)
      TransferElement::setExceptionBackend(exceptionBackend);
    }
 
    struct Buffer {
      std::vector<std::vector<UserType>> _data;
      VersionNumber _version;
      DataValidity _validity = {DataValidity::faulty};
    };
    Buffer _current;
 
    cppext::future_queue<Buffer> _myReadQueue{3};
 
    void trigger() override {
      try {
        _hasException = false;
        _target->read();
        Buffer b;
        b._data = _target->accessChannels();
        b._version = _backend->_pushVersions[_path];
        b._validity = _target->dataValidity();
        _myReadQueue.push_overwrite(b);
      }
      // fixme: clang tidy says something else is escaping, don't know what
      catch(ChimeraTK::runtime_error&) {
        _isActive = false;
        if(!_hasException) _myReadQueue.push_overwrite_exception(std::current_exception());
        _hasException = true;
      }
    }
 
    void doPreRead(TransferType) override {
      // do not delegate read transfers to the target
      if(!_backend->isOpen()) {
        throw ChimeraTK::logic_error("Cannot read from closed device.");
      }
    }
 
    void doPostRead(TransferType, bool updateDataBuffer) override {
      // do not delegate read transfers to the target
      if(updateDataBuffer) {
        // do not update meta data if updateDataBuffer == false, since this is the equivalent to a backend
        // implementation, not a decorator
        _versionNumber = _current._version;
        _dataValidity = _current._validity;
        buffer_2D = _current._data;
      }
    }
 
    boost::shared_ptr<ExceptionDummy> _backend;
    RegisterPath _path;
    using NDRegisterAccessorDecorator<UserType>::_target;
    using TransferElement::_readQueue;
    using TransferElement::_versionNumber;
    using TransferElement::_dataValidity;
    using NDRegisterAccessor<UserType>::buffer_2D;
  };
 
  /********************************************************************************************************************/
 
  // non-template base class for UserType-agnostic insertion into std::map
  struct ExceptionDummyPollDecoratorBase {
    virtual ~ExceptionDummyPollDecoratorBase() = default;
  };
 
  template<typename UserType>
  struct ExceptionDummyPollDecorator : NDRegisterAccessorDecorator<UserType>, ExceptionDummyPollDecoratorBase {
    ExceptionDummyPollDecorator(const boost::shared_ptr<ChimeraTK::NDRegisterAccessor<UserType>>& target,
        boost::shared_ptr<ExceptionDummy> backend)
    : NDRegisterAccessorDecorator<UserType>(target), _backend(std::move(backend)) {
      assert(_target->isReadable());
 
      _path = _target->getName();
      _path.setAltSeparator(".");
    }
 
    void doPostRead(TransferType type, bool updateDataBuffer) override {
      NDRegisterAccessorDecorator<UserType, UserType>::doPostRead(type, updateDataBuffer);
      // overwriting is only allowed for faulty.
      if(_backend->getValidity(_path) == DataValidity::faulty) this->_dataValidity = DataValidity::faulty;
    }
 
    boost::shared_ptr<ExceptionDummy> _backend;
    RegisterPath _path;
    using NDRegisterAccessorDecorator<UserType>::_target;
    using TransferElement::_readQueue;
    using TransferElement::_versionNumber;
    using TransferElement::_dataValidity;
  };
 
  /********************************************************************************************************************/
} // namespace ChimeraTK