RT-thread内核之对象管理系统

一、数据结构

1、对象控制块：在include/rtdef.h中定义

/**
 * Base structure of Kernel object
 */
struct rt_object
{
    char       name[RT_NAME_MAX]; /*对象名称，RT_NAME_MAX在rtconfig.h中定义 */
    rt_uint8_t type; /*内核对象类型*/                                  
    rt_uint8_t flag; /*内核对象标志*/

#ifdef RT_USING_MODULE
    void      *module_id; /*应用模块ID  */
#endif
    rt_list_t  list; /*内核对象链表节点 */
};
typedef struct rt_object *rt_object_t; 

这里需要注意地是,上述内核对象控制块包含了一rt_list_t类型的成员list,这个是一链表节点,便于将此内核对象加入到一链表中,其结构如下定义:

struct rt_list_node
{
    struct rt_list_node *next;  /*指向下一节点  */
    struct rt_list_node *prev;  /*指向前一节点  */
};
typedef struct rt_list_node rt_list_t; 
可以看出每个内核对象链表节点的结构体都包括的下一内核对象节点和前一内核对象节点                

/**
 *  The object type can be one of the follows with specific
 *  macros enabled:
 *  - Thread
 *  - Semaphore
 *  - Mutex
 *  - Event
 *  - MailBox
 *  - MessageQueue
 *  - MemHeap
 *  - MemPool
 *  - Device
 *  - Timer
 *  - Module
 *  - Unknown
 *  - Static
 */
enum rt_object_class_type
{
    RT_Object_Class_Thread = 0,   /*线程*/
#ifdef RT_USING_SEMAPHORE
    RT_Object_Class_Semaphore,  /*信号量*/
#endif
#ifdef RT_USING_MUTEX
    RT_Object_Class_Mutex,  /*互斥锁 */
#endif
#ifdef RT_USING_EVENT
    RT_Object_Class_Event,   /*事件*/
#endif
#ifdef RT_USING_MAILBOX
    RT_Object_Class_MailBox,   /*邮箱 */
#endif
#ifdef RT_USING_MESSAGEQUEUE
    RT_Object_Class_MessageQueue,   /*消息队列 */
#endif
#ifdef RT_USING_MEMHEAP
    RT_Object_Class_MemHeap,  /*内存堆 */
#endif
#ifdef RT_USING_MEMPOOL
    RT_Object_Class_MemPool,  /*内存池 */
#endif
#ifdef RT_USING_DEVICE
    RT_Object_Class_Device,  /*设备驱动 */
#endif
    RT_Object_Class_Timer,  /*定时器 */
#ifdef RT_USING_MODULE
    RT_Object_Class_Module,  /*模块 */
#endif
    RT_Object_Class_Unknown,  /*未知类型，用于内核对象容器数组rt_object_container[RT_Object_Class_Unknown]中，表示当前所有使用的对象类型总数*/
    RT_Object_Class_Static = 0x80  /*rt-thread以此位标志判断一个内核对象是否为静态内核对象*/
};

2、内核对象容器

RTT使用内核对象容器来管理同一类型的内核对象,并将其放入同一链表中,便于访问.内核对象信息的结构如下定义:

/**
 * The information of the kernel object
 */
struct rt_object_information
{
    enum rt_object_class_type type; /*内核对象类型  */
    rt_list_t  object_list; /*内核对象链表，该链表中包含同一类型的所有内核对象节点。内核对象静态（动态）初始化与脱离（删除）时，会在该链表中增加或移除相应内核对象节点*/
    rt_size_t  object_size; /*内核对象所占的大小 */
};

3、内核对象管理系统

      RTT中,每一类型的内核对象都会有一内核对象容器来包容,这个类型的内核对象容器实际上是用一链表,这个链表将所有相同类型的内核对象链接起来.由于每一类型都对应着有一个这样的内核对象容器来管理,那么所有内核对象容器整体就叫做内核对象管理系统.

RTT中,内核对象管理系统是用一个rt_object_information数组来实现的,在src/object.c中定义如下:

#define _OBJ_CONTAINER_LIST_INIT(c)  //内核对象链表节点初始化,链表起始节点的前一节点和后一节点在初始化时都指向该起始节点地址 
    {&(rt_object_container[c].object_list), &(rt_object_container[c].object_list)}

//内核对象管理系统,这里用rt_object_information数组来实现
struct rt_object_information rt_object_container[RT_Object_Class_Unknown] =
{
    /* initialize object container - thread */    //线程对象信息
    {RT_Object_Class_Thread, _OBJ_CONTAINER_LIST_INIT(RT_Object_Class_Thread), sizeof(struct rt_thread)},
#ifdef RT_USING_SEMAPHORE
    /* initialize object container - semaphore */ //信号量对象信息  
    {RT_Object_Class_Semaphore, _OBJ_CONTAINER_LIST_INIT(RT_Object_Class_Semaphore), sizeof(struct rt_semaphore)},
#endif
#ifdef RT_USING_MUTEX
    /* initialize object container - mutex */     //互斥锁对象信息  
    {RT_Object_Class_Mutex, _OBJ_CONTAINER_LIST_INIT(RT_Object_Class_Mutex), sizeof(struct rt_mutex)},
#endif
#ifdef RT_USING_EVENT
    /* initialize object container - event */     //事件对象信息  
    {RT_Object_Class_Event, _OBJ_CONTAINER_LIST_INIT(RT_Object_Class_Event), sizeof(struct rt_event)},
#endif
#ifdef RT_USING_MAILBOX
    /* initialize object container - mailbox */   //邮箱对象信息  
    {RT_Object_Class_MailBox, _OBJ_CONTAINER_LIST_INIT(RT_Object_Class_MailBox), sizeof(struct rt_mailbox)},
#endif
#ifdef RT_USING_MESSAGEQUEUE
    /* initialize object container - message queue *///消息队列对象信息  
    {RT_Object_Class_MessageQueue, _OBJ_CONTAINER_LIST_INIT(RT_Object_Class_MessageQueue), sizeof(struct rt_messagequeue)},
#endif
#ifdef RT_USING_MEMHEAP
    /* initialize object container - memory heap */  //内存堆对象信息  
    {RT_Object_Class_MemHeap, _OBJ_CONTAINER_LIST_INIT(RT_Object_Class_MemHeap), sizeof(struct rt_memheap)},
#endif
#ifdef RT_USING_MEMPOOL
    /* initialize object container - memory pool */  //内存池对象信息  
    {RT_Object_Class_MemPool, _OBJ_CONTAINER_LIST_INIT(RT_Object_Class_MemPool), sizeof(struct rt_mempool)},
#endif
#ifdef RT_USING_DEVICE
    /* initialize object container - device */      //设备驱动对象信息  
    {RT_Object_Class_Device, _OBJ_CONTAINER_LIST_INIT(RT_Object_Class_Device), sizeof(struct rt_device)},
#endif
    /* initialize object container - timer */       //时钟对象信息
    {RT_Object_Class_Timer, _OBJ_CONTAINER_LIST_INIT(RT_Object_Class_Timer), sizeof(struct rt_timer)},
#ifdef RT_USING_MODULE
    /* initialize object container - module */      //模块对象信息  
    {RT_Object_Class_Module, _OBJ_CONTAINER_LIST_INIT(RT_Object_Class_Module), sizeof(struct rt_module)},
#endif
};

二、内核对象接口（以下接口函数在src/object.c中实现）

内核对象静态初始化：
对象初始化，实现上就是把对象放入到其相应的对象容器中，即将对象插入到对象容器链表中。
void rt_object_init(struct rt_object *object, enum rt_object_class_type type,const char *name)

内核对象动态创建：
动态创建首先要在rtconfig.h中定义RT_USING_HEAP宏。使用以上接口，首先根据对象类型来获取对象信息，然后从内存堆中分配对象所需内存空间，然后对该对象进行必要的初始化，最后将其插入到它所在的对象容器链表中。
rt_object_t rt_object_allocate(enum rt_object_class_type type, const char *name)

静态内核对象脱离：
使用该接口后，静态内核对象将从内核对象管理器中脱离，对象占用的内存不会被释放。
void rt_object_detach(rt_object_t object)

动态内核对象删除：
使用以上接口时，首先从对象容器中脱离对象，然后释放对象所占用的内存。
void rt_object_delete(rt_object_t object)

判断是否为系统静态内核对象：
rt_bool_t rt_object_is_systemobject(rt_object_t object)
通常采用rt_object_init方式挂接到内核对象管理器中的对象是系统静态内核对象。

查找内核对象：
rt_object_t rt_object_find(const char *name, rt_uint8_t type)
使用以上接口时，在对象类型所对应的对象容器中遍历寻找指定对象，然后返回该对象，如果没有找到这样的对象，则返回空。

系统内核对象初始化：
void rt_system_object_init(void)
自从0.3.0以后,RTT就已经没有必须再使用此接口来对内核对象初始化了,因此,此函数是空的,但在系统初始化时还会保留调用此函数

获取指定类型的内核对象信息：
struct rt_object_information *rt_object_get_information(enum rt_object_class_type type)
{
    return &rt_object_container[type];
}
RTM_EXPORT(rt_object_get_information);