DeviceManager.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 "ApplicationModule.h"
#include "RecoveryHelper.h"
#include "StatusWithMessage.h"
#include "VoidAccessor.h"
 
#include <ChimeraTK/Device.h>
 
#include <boost/thread/latch.hpp>
 
#include <barrier>
#include <memory>
 
namespace ChimeraTK {
 
  /********************************************************************************************************************/
 
  class DeviceManager : public ApplicationModule {
   public:
    DeviceManager(Application* application, const std::string& deviceAliasOrCDD);
 
    // Move constructor/assignment is not used since DeviceManagers are stored as shared_ptr only.
    DeviceManager(DeviceManager&& other) = delete;
    DeviceManager& operator=(DeviceManager&& other) = delete;
 
    void reportException(const std::string& errMsg);
 
    void prepare() override;
 
    void mainLoop() override;
 
    void mainLoopImpl();
 
    DataValidity getDataValidity() const override { return DataValidity::ok; }
 
    void incrementDataFaultCounter() override;
 
    void decrementDataFaultCounter() override;
 
    void addInitialisationHandler(std::function<void(ChimeraTK::Device&)> initialisationHandler);
 
    VoidOutput deviceBecameFunctional{this, "deviceBecameFunctional", ""};
 
    void addRecoveryAccessor(boost::shared_ptr<RecoveryHelper> recoveryAccessor);
 
    uint64_t writeOrder();
 
    boost::shared_lock<boost::shared_mutex> getRecoverySharedLock();
 
    void waitForInitialValues();
 
    std::list<EntityOwner*> getInputModulesRecursively(std::list<EntityOwner*> startList) override;
 
    size_t getCircularNetworkHash() const override;
 
    const std::string& getDeviceAliasOrURI() const { return _deviceAliasOrCDD; }
 
    std::vector<VariableNetworkNode> getNodesList() const;
 
    [[nodiscard]] Device& getDevice() { return _device; }
 
    void terminate() override;
 
   protected:
    VersionNumber getExceptionVersionNumber();
 
    Device _device;
 
    std::string _deviceAliasOrCDD;
 
    Application* _owner{nullptr};
 
    StatusWithMessage _deviceError{this, "status", "Error status of the device"};
 
    cppext::future_queue<std::string> _errorQueue{5};
 
    boost::shared_mutex _errorMutex;
 
    VersionNumber _exceptionVersionNumber;
 
    bool _deviceHasError{true};
 
    std::list<boost::shared_ptr<RecoveryHelper>> _recoveryHelpers;
 
    /* The list of initialisation handler callback functions */
    std::list<std::function<void(ChimeraTK::Device&)>> _initialisationHandlers;
 
    boost::shared_mutex _recoveryMutex;
 
    bool _isHoldingInitialValueLatch{true};
    boost::latch _initialValueLatch{1};
 
    std::atomic<int64_t> _synchronousTransferCounter{0};
    std::atomic<uint64_t> _writeOrderCounter{0};
 
    std::list<RegisterPath> _writeRegisterPaths;
    std::list<RegisterPath> _readRegisterPaths;
 
    friend struct detail::CircularDependencyDetector;
 
    template<typename UserType>
    friend class ExceptionHandlingDecorator;
 
    struct RecoveryGroup {
      enum class RecoveryStage { NO_ERROR, DETECTION, OPEN, INIT_HANDLERS, RECOVERY_ACCESSORS, CLEAR_ERROR };
      static constexpr const char* stageToString(RecoveryStage stage) {
        switch(stage) {
          case RecoveryStage::NO_ERROR:
            return "RecoveryStage::NO_ERROR";
          case RecoveryStage::DETECTION:
            return "RecoveryStage::DETECTION";
          case RecoveryStage::OPEN:
            return "RecoveryStage::OPEN";
          case RecoveryStage::INIT_HANDLERS:
            return "RecoveryStage::INIT_HANDLERS";
          case RecoveryStage::RECOVERY_ACCESSORS:
            return "RecoveryStage::RECOVERY_ACCESSORS";
          case RecoveryStage::CLEAR_ERROR:
            return "RecoveryStage::CLEAR_ERROR";
        }
        throw ChimeraTK::logic_error("Unknown recovery stage, cannot convert to string.");
      }
 
      std::set<DeviceBackend::BackendID> recoveryBackendIDs; 
      Application* app{nullptr}; 
 
      std::barrier<> recoveryBarrier{1};
 
      std::atomic<RecoveryStage> errorAtStage{RecoveryStage::NO_ERROR};
 
      std::atomic<bool> shutdown{false};
 
      static std::mutex globalDeviceOpenMutex;
 
      std::mutex _initHandlerOpenCloseMutex;
 
      // Wait at the barrier for a stage to complete.
      // Returns 'true' if the stage was completed successfully.
      bool waitForRecoveryStage(RecoveryStage stage);
 
      void setErrorAtStage(RecoveryStage stage);
 
      // contains a barrier to wait that all threads have seen the change.
      void resetErrorAtStage();
    };
    std::shared_ptr<RecoveryGroup> _recoveryGroup;
 
    std::string stageToString(RecoveryGroup::RecoveryStage stage);
  };
 
  /********************************************************************************************************************/
 
} // namespace ChimeraTK