PeriodicExecutionContext.h

Go to the documentation of this file.

// -*- C++ -*-
#ifndef RTC_PERIODICEXECUTIONCONTEXT2_H
#define RTC_PERIODICEXECUTIONCONTEXT2_H
 
#include <coil/Task.h>
#include <condition_variable>
#include <coil/Affinity.h>
 
#include <rtm/ExecutionContextBase.h>
 
#include <vector>
#include <iostream>
 
#define NUM_OF_LIFECYCLESTATE 4
 
namespace RTC_exp
{
  class PeriodicExecutionContext
    : public virtual POA_RTC::ExecutionContextService,
      public virtual PortableServer::RefCountServantBase,
      public RTC::ExecutionContextBase,
      public coil::Task
  {
  public:
    PeriodicExecutionContext();
 
    ~PeriodicExecutionContext() override;
 
     void init(coil::Properties& props) override;
 
    int open(void *args) override;
 
    int svc() override;
 
    int close(unsigned long flags) override;
 
    //============================================================
    // ExecutionContext
    //============================================================
    CORBA::Boolean is_running() override;
 
    RTC::ReturnCode_t start() override;
 
    RTC::ReturnCode_t stop() override;
 
    CORBA::Double get_rate() override;
 
    RTC::ReturnCode_t  set_rate(CORBA::Double rate) override;
 
    RTC::ReturnCode_t
    activate_component(RTC::LightweightRTObject_ptr comp) override;
 
    RTC::ReturnCode_t
    deactivate_component(RTC::LightweightRTObject_ptr comp) override;
 
    RTC::ReturnCode_t
    reset_component(RTC::LightweightRTObject_ptr comp) override;
 
    RTC::LifeCycleState
    get_component_state(RTC::LightweightRTObject_ptr comp) override;
 
    RTC::ExecutionKind get_kind() override;
 
    RTC::ReturnCode_t add_component(RTC::LightweightRTObject_ptr comp) override;
 
    RTC::ReturnCode_t
    remove_component(RTC::LightweightRTObject_ptr comp) override;
 
    RTC::ExecutionContextProfile* get_profile() override;
 
  protected:
    template <class T>
    void getProperty(coil::Properties& prop, const char* key, T& value)
    {
      if (prop.findNode(key) != nullptr)
        {
          T tmp;
          if (coil::stringTo(tmp, prop[key].c_str()))
            {
              value = tmp;
            }
        }
    }
    RTC::ReturnCode_t onStarted() override;
    RTC::ReturnCode_t onStopping() override;
    // template virtual functions adding/removing component
     RTC::ReturnCode_t
     onAddedComponent(RTC::LightweightRTObject_ptr rtobj) override;
    RTC::ReturnCode_t
    onRemovedComponent(RTC::LightweightRTObject_ptr rtobj) override;
 
    RTC::ReturnCode_t
    onWaitingActivated(RTC_impl::RTObjectStateMachine* comp, long int count) override;
    RTC::ReturnCode_t
    onActivated(RTC_impl::RTObjectStateMachine* comp, long int count) override;
    RTC::ReturnCode_t
    onWaitingDeactivated(RTC_impl::RTObjectStateMachine* comp, long int count) override;
    RTC::ReturnCode_t
    onDeactivated(RTC_impl::RTObjectStateMachine* comp, long int count) override;
    RTC::ReturnCode_t
    onWaitingReset(RTC_impl::RTObjectStateMachine* comp, long int count) override;
    RTC::ReturnCode_t
    onReset(RTC_impl::RTObjectStateMachine* comp, long int count) override;
 
    virtual void setCpuAffinity(coil::Properties& props);
 
    bool threadRunning()
    {
      std::lock_guard<std::mutex> guard(m_svcmutex);
      return m_svc;
    }
  protected:
    RTC::Logger rtclog{"periodic_ec"};
 
    bool m_svc{false};
    std::mutex m_svcmutex;
 
    struct WorkerThreadCtrl
    {
      WorkerThreadCtrl() {}
      std::mutex mutex_;
      std::condition_variable cond_;
      bool running_{false};
    };
 
    WorkerThreadCtrl m_workerthread;
 
    bool m_nowait{false};
 
    coil::CpuMask m_cpu;
 
  };  // class PeriodicExecutionContext
} // namespace RTC_exp
 
 
extern "C"
{
  void PeriodicExecutionContextInit(RTC::Manager* manager);
}
 
#endif  // RTC_PERIODICEXECUTIONCONTEXT_H