在rtems中，可以通过region来分配内存，这样分配的内存可以独立于malloc申请的内存，从而实现内存区域的管理。本文基于此分享如何使用内存区域

一、作用

内存区域的作用是单独的内存区域，这个区域是固定的起始地址，大小和属性。使用内存区域的情况下，可以避免内存回收，内存规整等操作带来的性能消耗，同样的，也可以为多个任务创建不同的内存区域。

当然，在rtems中，如果分配内存区域的时候内存不足，也可以将任务进入等待队列，直到内存释放后有可用内存时。

二、代码实现

内存区域的代码如下


rtems_status_code rtems_region_create(
  rtems_name          name,
  void               *starting_address,
  uintptr_t           length,
  uintptr_t           page_size,
  rtems_attribute     attribute_set,
  rtems_id           *id
)
{
  rtems_status_code  return_status;
  Region_Control    *the_region;
 
  if ( !rtems_is_name_valid( name ) ) {
    return RTEMS_INVALID_NAME;
  }
 
  if ( id == NULL ) {
    return RTEMS_INVALID_ADDRESS;
  }
 
  if ( starting_address == NULL ) {
    return RTEMS_INVALID_ADDRESS;
  }
 
  the_region = _Region_Allocate();
 
    if ( !the_region )
      return_status = RTEMS_TOO_MANY;
 
    else {
      _Thread_queue_Object_initialize( &the_region->Wait_queue );
 
      if ( _Attributes_Is_priority( attribute_set ) ) {
        the_region->wait_operations = &_Thread_queue_Operations_priority;
      } else {
        the_region->wait_operations = &_Thread_queue_Operations_FIFO;
      }
 
      the_region->maximum_segment_size = _Heap_Initialize(
        &the_region->Memory, starting_address, length, page_size
      );
 
      if ( !the_region->maximum_segment_size ) {
        _Region_Free( the_region );
        return_status = RTEMS_INVALID_SIZE;
      } else {
        the_region->attribute_set = attribute_set;
 
        *id = _Objects_Open_u32(
          &_Region_Information,
          &the_region->Object,
          name
        );
 
        return_status = RTEMS_SUCCESSFUL;
      }
    }
 
  _Objects_Allocator_unlock();
 
  return return_status;
}

2.1 解析形参

name：内存区域名称

starting_address：需要申请的内存地址

length：内存区域大小

page_size：设置内存区域的页大小

attribute_set：设置内存的调度属性

id：内存区域id

2.2 内存管理线程

rtems提供两种线程方式：一个是fifo，也就是先进先出调度，另一个是priority，也就是基于优先级的调度，分别如下：


const Thread_queue_Operations _Thread_queue_Operations_FIFO = {
  .priority_actions = _Thread_queue_Do_nothing_priority_actions,
  .enqueue = _Thread_queue_FIFO_enqueue,
  .extract = _Thread_queue_FIFO_extract,
  .surrender = _Thread_queue_FIFO_surrender,
  .first = _Thread_queue_FIFO_first
};
 
const Thread_queue_Operations _Thread_queue_Operations_priority = {
  .priority_actions = _Thread_queue_Priority_priority_actions,
  .enqueue = _Thread_queue_Priority_enqueue,
  .extract = _Thread_queue_Priority_extract,
  .surrender = _Thread_queue_Priority_surrender,
  .first = _Thread_queue_Priority_first
};

这个初始化的线程，会在内存不足的时候阻塞。

2.3 申请堆

通过_Heap_Initialize直接申请堆作为内存区域的Memory成员。地址指向starting_address

2.4 设置属性和申请id

对于这块内存，可以设置region结构体的属性字段，并通过_Objects_Open_u32申请内存区域id。region结构体如下


typedef struct {
  Objects_Control       Object;
  Thread_queue_Control  Wait_queue;            /* waiting threads        */
  const Thread_queue_Operations *wait_operations;
  uintptr_t             maximum_segment_size;  /* in bytes               */
  rtems_attribute       attribute_set;
  Heap_Control          Memory;
}  Region_Control;

三、测试分配内存

测试分配内存区域非常简单，我们可以直接通过rtems_region_create分配即可，如下：


static const rtems_name name = rtems_build_name('K', 'Y', 'L', 'I');
                                                                                                                                                                                               
#define CONFIGURE_MAXIMUM_REGIONS 1
                                                                                                                                                                                               
static void test_region_create(void)
{                                                                                                                                                                                            
    rtems_status_code sc;                                                                                                                                                                    
    rtems_id id;                                                                                                                                                                             
    void *seg_addr1;
    void *seg_addr2;
    sc = rtems_region_create(                                                                                                                                                                
        name,                                                                                                                                                                                
        0x4000000,
        640,
        16,
        RTEMS_DEFAULT_ATTRIBUTES,                                                                                                                                                            
        &id                                                                                                                                                                                  
    );                                                                                                                                                                                       
    printf( "sc=%d\n", sc);
                                                                                                                                                                                               
    sc = rtems_region_get_segment(                                                                                                                                                           
        id,                                                                                                                                                                                  
        32,
        RTEMS_DEFAULT_OPTIONS,                                                                                                                                                               
        RTEMS_NO_TIMEOUT,                                                                                                                                                                    
        &seg_addr1                                                                                                                                                                           
    );                                                                                                                                                                                       
    printf( "sc=%d seg_addr=%p\n", sc, seg_addr1);
    sc = rtems_region_get_segment(                                                                                                                                                           
        id,                                                                                                                                                                                  
        32,
        RTEMS_DEFAULT_OPTIONS,                                                                                                                                                               
        RTEMS_NO_TIMEOUT,                                                                                                                                                                    
        &seg_addr2                                                                                                                                                                           
    );                                                                                                                                                                                       
    printf( "sc=%d seg_addr=%p\n", sc, seg_addr2);
                                                                                                                                                                                               
    sc = rtems_region_return_segment( id, seg_addr1);                                                                                                                                        
    printf( "sc=%d\n", sc);
    sc = rtems_region_return_segment( id, seg_addr2);                                                                                                                                        
    printf( "sc=%d\n", sc);
}

3.1 region个数

默认情况下，需要通过一个宏设置内存区域个数CONFIGURE_MAXIMUM_REGIONS，这里定义多少就代表系统最多可以申请多少region

3.2 最小申请大小

内存区域最小分配为64字节，准确来说是大于等于52字节，这样内存区域才能正常工作。否则rtems_region_create返回无效

3.3 获取内存

通过rtems_region_get_segment可以获取region的段，这样就能直接使用region

3.4 释放内存到内存

通过rtems_region_get_segment可以释放region的段，这样下一个程序可以重新分配

3.5 测试程序内存布局

内存布局如下


(gdb) x/14g 0x4000000                                                                                                        
                                                                                                                               
0x4000000:        0x0000000004000280      0x0000000000000031
0x4000010:        0x0000000004000060      0x0000000000105d68
0x4000020:        0x0000000000000000      0x0000000000000000
0x4000030:        0x0000000000000030      0x0000000000000030
0x4000040:        0x0000000000105d68      0x0000000000105d68
0x4000050:        0x0000000000000000      0x0000000000000000
0x4000060:        0x0000000000000000      0x0000000000000211

从heap block结构体可以看到，内存分配一切正常

四、总结

通过上述的实验，可以清楚的了解到rtems的region的分配和原理。这里分配固定地址上的内存块，供程序使用

目录