【连载】嵌入式OS入门笔记-以RTX为案例(四):初探进程

作者: RaymondKwan
上传时间为: 2014-08-16 01:41 AM

进程是一个运行中的程序。在RTX中,一个task就是一个进程。

1.理论

    进程,英文称呼很多Process, Task等等,一般通用操作系统称Process的比较多,各种称呼涵义稍微有不一样。一般而言,进程是对一个运行单元的抽象,主要包括内存(code,data,heap和stack),CPU状态(PC,SP和寄存器值等)与其他OS管理相关的内容。进程是一个运行中的程序。在RTX中,一个task就是一个进程。

    一般我们有一个进程控制块(Process control block,PCB),用于记录进程的相关信息。在RTX上,这个控制块叫做task control block(TCB),是一个结构体,其中的成员记录了关于该task的信息,其定义在rt_TypeDef.h中:

[cpp][/cpp]

view plaincopyprint?

  • typedef struct OS_TCB {
  • /* General part: identical for all implementations. */
  • U8 cb_type; /* Control Block Type */
  • U8 state; /* Task state */
  • U8 prio; /* Execution priority */
  • U8 task_id; /* Task ID value for optimized TCB access */
  • struct OS_TCB *p_lnk; /* Link pointer for ready/sem. wait list */
  • struct OS_TCB *p_rlnk; /* Link pointer for sem./mbx lst backwards */
  • struct OS_TCB *p_dlnk; /* Link pointer for delay list */
  • struct OS_TCB *p_blnk; /* Link pointer for delay list backwards */
  • U16 delta_time; /* Time until time out */
  • U16 interval_time; /* Time interval for periodic waits */
  • U16 events; /* Event flags */
  • U16 waits; /* Wait flags */
  • void **msg; /* Direct message passing when task waits */
  • struct OS_MUCB *p_mlnk; /* Link pointer for mutex owner list */
  • U8 prio_base; /* Base priority */
  • U8 ret_val; /* Return value upon completion of a wait */
  • /* Hardware dependant part: specific for CM processor */
  • U8 ret_upd; /* Updated return value */
  • U16 priv_stack; /* Private stack size, 0= system assigned */
  • U32 tsk_stack; /* Current task Stack pointer (R13) */
  • U32 *stack; /* Pointer to Task Stack memory block */
  • /* Task entry point used for uVision debugger */
  • FUNCP ptask; /* Task entry address */
  • } *P_TCB;
 typedef struct OS_TCB {

/* General part: identical for all implementations.                        */

U8     cb_type;                 /* Control Block Type                      */

U8     state;                   /* Task state                              */

U8     prio;                    /* Execution priority                      */

U8     task_id;                 /* Task ID value for optimized TCB access  */

struct OS_TCB *p_lnk;           /* Link pointer for ready/sem. wait list   */

struct OS_TCB *p_rlnk;          /* Link pointer for sem./mbx lst backwards */

struct OS_TCB *p_dlnk;          /* Link pointer for delay list             */

struct OS_TCB *p_blnk;          /* Link pointer for delay list backwards   */

U16    delta_time;              /* Time until time out                     */

U16    interval_time;           /* Time interval for periodic waits        */

U16    events;                  /* Event flags                             */

U16    waits;                   /* Wait flags                              */

void   **msg;                   /* Direct message passing when task waits  */

struct OS_MUCB *p_mlnk;         /* Link pointer for mutex owner list       */

U8     prio_base;               /* Base priority                           */

U8     ret_val;                 /* Return value upon completion of a wait  *

* Hardware dependant part: specific for CM processor                      */

U8     ret_upd;                 /* Updated return value                    */

U16    priv_stack;              /* Private stack size, 0= system assigned  */

U32    tsk_stack;               /* Current task Stack pointer (R13)        */

U32    *stack;                  /* Pointer to Task Stack memory block      *

* Task entry point used for uVision debugger                              */

FUNCP  ptask;                   /* Task entry address                      */

} *P_TCB;

还是比较一目了然。

一个进程会有它自己的周期,会处在不同的进程状态(state,见上面的state成员),不同的状态有不同的意味,不同的状态间可以相互转换。

在RTX中,task的状态是在rt_Task.h中定义的,一共有10种:

[cpp][/cpp]

view plaincopyprint?

  • /* Values for 'state' */
  • #define INACTIVE 0
  • #define READY 1
  • #define RUNNING 2
  • #define WAIT_DLY 3
  • #define WAIT_ITV 4
  • #define WAIT_OR 5
  • #define WAIT_AND 6
  • #define WAIT_SEM 7
  • #define WAIT_MBX 8
  • #define WAIT_MUT 9

/* Values for 'state'   */

#define INACTIVE        0

#define READY           1

#define RUNNING         2

#define WAIT_DLY        3

#define WAIT_ITV        4

#define WAIT_OR         5

#define WAIT_AND        6

#define WAIT_SEM        7

#define WAIT_MBX        8

#define WAIT_MUT        9

    简单说来,可以分为4大类,inactive(进程被清理),ready(就绪),running(执行)和waiting(等待)。状态3至9都可以归为等待状态,区别在于他们等待的东西不同,从等待状态触发到就绪状态的条件不同。

    进程的创建和消灭都是主要都牵涉到内存分配,排程器的安排,TCB的处理等等,需要具体的OS具体的分析,我们这里贴一下RTX进程创建的源代码:

[cpp][/cpp]

view plaincopyprint?

  • OS_TID rt_tsk_create (FUNCP task, U32 prio_stksz, void *stk, void *argv) {
  • /* Start a new task declared with "task". */
  • P_TCB task_context;
  • U32 i;
  • /* Priority 0 is reserved for idle task! */
  • if ((prio_stksz & 0xFF) == 0) {
  • prio_stksz += 1;
  • }
  • task_context = rt_alloc_box (mp_tcb);
  • if (task_context == NULL) {
  • return (0);
  • }
  • /* If "size != 0" use a private user provided stack. */
  • task_context->stack = stk;
  • task_context->priv_stack = prio_stksz >> 8;
  • /* Pass parameter 'argv' to 'rt_init_context' */
  • task_context->msg = argv;
  • /* For 'size == 0' system allocates the user stack from the memory pool. */
  • rt_init_context (task_context, prio_stksz & 0xFF, task);
  • /* Find a free entry in 'os_active_TCB' table. */
  • i = rt_get_TID ();
  • os_active_TCB[i-1] = task_context;
  • task_context->task_id = i;
  • DBG_TASK_NOTIFY(task_context, __TRUE);
  • rt_dispatch (task_context);
  • os_tsk.run->ret_val = i;
  • return ((OS_TID)i);
  • }
 OS_TID rt_tsk_create (FUNCP task, U32 prio_stksz, void *stk, void *argv) {

/* Start a new task declared with "task". */

P_TCB task_context;

U32 i;

/* Priority 0 is reserved for idle task! */

if ((prio_stksz & 0xFF) == 0) {

prio_stksz += 1;

}

task_context = rt_alloc_box (mp_tcb);

if (task_context == NULL) {

return (0);

}

/* If "size != 0" use a private user provided stack. */

task_context->stack      = stk;

task_context->priv_stack = prio_stksz >> 8;

/* Pass parameter 'argv' to 'rt_init_context' */

task_context->msg = argv;

/* For 'size == 0' system allocates the user stack from the memory pool. */

rt_init_context (task_context, prio_stksz & 0xFF, task);

/* Find a free entry in 'os_active_TCB' table. */

i = rt_get_TID ();

os_active_TCB[i-1] = task_context;

task_context->task_id = i;

DBG_TASK_NOTIFY(task_context, __TRUE);

rt_dispatch (task_context);

os_tsk.run->ret_val = i;

return ((OS_TID)i);

}

基本就是填TCB,分配内存空间,确定优先级和排程相关设置,这里就不深入分析。消灭进程的源代码也是类似的。

2.进程相关的基本操作

之前讲到,进程在RTX里的基本形式是:

[cpp][/cpp]

view plaincopyprint?

  • __task void task(void){
  • for(;;){
  • //...
  • }
  • }

 

 OS_TID taskID1;

OS_TID taskID2;

__task void init (void) {

    //Necessary Initialization

    //...

    //Create a task

    taskID1 = os_tsk_create(task1, 0);

    taskID2 = os_tsk_create(task2, 0);

        os_tsk_delete_self (); // Delete the init(self) task

}

int main(void)

{

    //Necessary Initialization

    //...

        os_sys_init(init);

}

    进程相关操作就是RTX提供的围绕这样一个task的一些基本操作,例如创建,消灭等等。

    从应用角度来说,了解以下进程基本操作就足够了:

1.创建

最主要的是这个:

os_tsk_create(task_name,priority);

把函数名填入,和进程的优先度,优先度后面的笔记会介绍。

如果留心看源代码,其实源代码的create操作要求一共4个参数(FUNCP task, U32 prio_stksz, void *stk, void *argv)。我们最基本的这个创建函数并没有接受后两个参数。如果实在有需要,有以下另外三个相关的操作:

os_tsk_create_ex(task_name,priority,para);

这个是用于传递一个初始参数para给相关进程的。例如你有一个LED_On的进程,而你有4个LED,你只有在创建进程时才能决定,你点亮的是哪个LED,那么就可以用这个操作,通过传递参数来决定具体要亮哪个LED。

os_tsk_create_user(task_name,priority,&stack,sizeof(stack));

这个是用来给进程创建自定义stack的。需要传递stack的地址和大小。

os_tsk_create_user_ex(task_name,priority,&stack,sizeof(stack),para);

这个明显就是上面两个的结合。

以上这些创建操作,返回类型都是OS_TID,进程ID,实际值从0到255。 所以可以先声明一个该类型的值,然后创建进程时让其返回该值。

2.消灭

os_tsk_delete(taskID);

填入你要消灭的进程的进程ID,TID。

如果要消灭进程本身,用:

os_tsk_delete_self();

注意,RTX的消灭进程并不清理互斥锁或者信号灯的占有的。所以在消灭一个进程前,确定进程释放了所有资源。内存资源会被这两个操作释放,所以不用担心。

3.杂项

如果想要知道当前进程的ID,使用以下操作:

os_get_TID();

还有一个非常重要的:

os_sys_init(first_task);

这个操作初始化整个RTX,如果不在main中执行这一操作,一切都是空谈。该操作会创建第一个进程,也就是first_task。

一般而言,进程可以创造别的进程,也可以消灭别的进程。但进程只能够消灭本身,而不能创造本身。所以就需要有一个操作去创建第一个进程,然后别的进程可由这个第一个进程去创造。

3.一个完整的例子

一下是一个从初始化,到创建第一个进程,到第一个进程创建别的进程,最后消灭自己的一个例子:

[cpp][/cpp]

view plaincopyprint?

  • OS_TID taskID1;
  • OS_TID taskID2;
  • __task void init (void) {
  • //Necessary Initialization
  • //...
  • //Create a task
  • taskID1 = os_tsk_create(task1, 0);
  • taskID2 = os_tsk_create(task2, 0);
  • os_tsk_delete_self (); // Delete the init(self) task
  • }
  • int main(void)
  • {
  • //Necessary Initialization
  • //...
  • os_sys_init(init);
  • }
 OS_TID taskID1;

OS_TID taskID2;

__task void init (void) {

    //Necessary Initialization

    //...

    //Create a task

    taskID1 = os_tsk_create(task1, 0);

    taskID2 = os_tsk_create(task2, 0);

        os_tsk_delete_self (); // Delete the init(self) task

}

int main(void)

{

    //Necessary Initialization

    //...

        os_sys_init(init);

}

    这个简单的例子足够应付最基本使用RTX的需求了。

关于RTX的排程,优先度,内存分配和一些OS原语,在后面的笔记会记录。

全部评论 ()

创建讨论帖子

登录 后参与评论
系统提示