Orocos Activity&ExecutionEngine 解析

Orocos 每一个TaskContext 类表示一个完整的模块，该模块有configure,start,stop,clean,setPeriod等等方法来控制这个模块的运行。如果使用了该模块的 setActivity 方法，该模块将置于一个单独的线程中运行，根据自己的周期频率执行各个函数，读写dataport等。

setActivity 方法如下：

bool TaskContext::setActivity(ActivityInterface* new_act)  // Activity 继承于 ActivityInterface{    if (this->isRunning())        return false;    if ( new_act == 0) {#if defined(ORO_ACT_DEFAULT_SEQUENTIAL)        new_act = new SequentialActivity();#elseif defined(ORO_ACT_DEFAULT_ACTIVITY)        new_act = new Activity();  // 在这new了一个新的Activity,即创建了一个新的线程用于执行该模块。#endif    }    new_act->stop();    if(our_act){        our_act->stop();    }    new_act->run( this->engine() );  // 这个模块所有需要运行的资源都是通过这个 ExecutionEngine 来执行的。    our_act = ActivityInterface::shared_ptr( new_act );    our_act->start();    return true;}

所以说，ExecutionEngine 是通过 Activity 来执行的，而 TaskContext 中的资源又是通过 ExecutionEngine 来执行的。归根到底是通过 Activity 来执行的 :)

其中每一个 Activity 类都表示一个线程：

class Activity : public base::ActivityInterface, public os::Thread

其中 os::Thread 类根据编译时所选择的平台可以是 gnulinux, xenomai, win32等线程的实现:

#ifdef OROPKG_OS_GNULINUX #include "gnulinux/fosi.h"#endif#ifdef OROPKG_OS_LXRT #include "lxrt/fosi.h"#endif#ifdef OROPKG_OS_XENOMAI #include "xenomai/fosi.h"#endif#ifdef OROPKG_OS_ECOS #include "ecos/fosi.h"#endif#ifdef OROPKG_OS_MACOSX  #include "macosx/fosi.h"#endif#ifdef OROPKG_OS_WIN32  #include "win32/fosi.h"#endif

Thread 类结构如下：

class Thread: public ThreadInterface{    friend void* thread_function(void* t);  // 传入Activity的this指针(其中又保存了一个ExecutionEngine的指针)，thread_function中实现一个while(1){...}来运行各种Hook，从而驱动顶层的 TaskContext 的运转。public:    Thread(int scheduler, int priority, double period, unsigned cpu_affinity,           const std::string & name);  // 根据条件构造相应的线程    virtual ~Thread();    bool setPeriod(Seconds s);  // 执行周期，也可以为非周期性的    ...private:    Thread(const Thread&);  // noncopiable    ...}

最关键的就是 thread_function 这个函数了，实现了线程的周期性执行，step执行等：

void *thread_function(void* t){    /**     * This is one time initialisation     */    Thread* task = static_cast<os::Thread*> (t);    Logger::In in(task->getName());    task->configure();    // signal to setup() that we're created.    rtos_sem_signal(&(task->sem));    // This lock forces setup(), which holds the lock, to continue.    { MutexLock lock(task->breaker); }#ifdef OROPKG_OS_THREAD_SCOPE    // order thread scope toggle bit on thread number    unsigned int bit = task->threadNumber();#endif    SCOPE_OFF    int overruns = 0, cur_sched = task->msched_type;    NANO_TIME cur_period = task->period;    while (!task->prepareForExit)    {        TRY(            /**             * The real task starts here.             */            while (1)            {                if (!task->active || (task->active && task->period == 0) || !task->running )                {                    // consider this the 'configuration or waiting for command state'                    if (task->period != 0) {                        overruns = 0;                        // drop out of periodic mode:                        rtos_task_set_period(task->getTask(), 0);                    }                    rtos_sem_wait(&(task->sem)); // wait for command.                    task->configure();           // check for reconfigure                    if (task->prepareForExit)    // check for exit                    {                        break; // break while(1) {}                    }                    // end of configuration                }                // This is the running state. Only enter if a task is running                if ( task->running )                {                    if (task->period != 0) // periodic                    {                        MutexLock lock(task->breaker);                        while(task->running && !task->prepareForExit )                        {                            TRY                            (                                SCOPE_ON                                task->step(); // one cycle                                SCOPE_OFF                            )                            CATCH_ALL                            (                                SCOPE_OFF                                throw;                            )                            // Check changes in period                            if ( cur_period != task->period) {                                // reconfigure period before going to sleep                                rtos_task_set_period(task->getTask(), task->period);                                cur_period = task->period;                                if (cur_period == 0)                                    break; // break while(task->running) if no longer periodic                            }                            // Check changes in scheduler                            if ( cur_sched != task->msched_type) {                                rtos_task_set_scheduler(task->getTask(), task->msched_type);                                cur_sched = task->msched_type;                            }                            // rtos_task_wait_period will return immediately if                            // the task is not periodic (ie period == 0)                            // return non-zero to indicate overrun.                            if (rtos_task_wait_period(task->getTask()) != 0)                            {                                ++overruns;                                if (overruns == task->maxOverRun)                                    break; // break while(task->running)                            }                            else if (overruns != 0)                                --overruns;                        } // while(task->running)                        if (overruns == task->maxOverRun || task->prepareForExit)                            break; // break while(1) {}                    }                    else // non periodic:                    TRY                    (                        // this mutex guarantees that stop() waits                        // until loop() returns.                        MutexLock lock(task->breaker);                        task->inloop = true;                        SCOPE_ON                        task->loop();                        SCOPE_OFF                        task->inloop = false;                    ) CATCH_ALL                    (                        SCOPE_OFF                        task->inloop = false;                        throw;                    )                }            } // while(1)            if (overruns == task->maxOverRun)            {                task->emergencyStop();                Logger::In in(rtos_task_get_name(task->getTask()));                log(Critical) << rtos_task_get_name(task->getTask())                        << " got too many periodic overruns in step() ("                        << overruns << " times), stopped Thread !"                        << endlog();                log()   << " See Thread::setMaxOverrun() for info."                        << endlog();            }        )CATCH(std::exception const& e,            SCOPE_OFF            task->emergencyStop();            Logger::In in(rtos_task_get_name(task->getTask()));            log(Critical) << rtos_task_get_name(task->getTask())                    << " caught a C++ exception, stopped thread !"                    << endlog();            log(Critical) << "exception was: "                       << e.what() << endlog();        ) CATCH_ALL        (            SCOPE_OFF            task->emergencyStop();            Logger::In in(rtos_task_get_name(task->getTask()));            log(Critical) << rtos_task_get_name(task->getTask())                    << " caught an unknown C++ exception, stopped thread !"                    << endlog();        )    } // while (!prepareForExit)    return 0;}void Thread::emergencyStop(){    // set state to not running    this->running = false;    this->inloop  = false;    this->active  = false;    // execute finalize in current mode, even if hard.    this->finalize();}