[内存管理]连续内存分配器(CMA)概述

作者：Younger Liu，

本作品采用知识共享署名-非商业性使用-相同方式共享 3.0 未本地化版本许可协议进行许可。

原文地址：http://lwn.net/Articles/396657/

1.  
 简介

连续内存分配器(CMA - Contiguous Memory Allocator)是一个框架，允许建立一个平台无关的配置，用于连续内存的管理。然后，设备所需内存都根据该配置进行分配。

这个框架的主要作用不是分配内存，而是解析和管理内存配置，以及作为在设备驱动程序和可插拔的分配器之间的中间组件。因此，它是与任何内存分配方法和分配策略没有依赖关系的。

2.  
 为什么需要？

在嵌入式设备中，很多设备都没有支持scatter-getter和IO map，都需要连续内存块的操作。如设备：摄像机，硬件视频解码器，编码器等。

这些设备往往需要较大的内存缓冲区（如：一个200万像素的高清帧摄像机，需要超过6M的内存），该kmalloc内存分配机制对于这么大的内存是没有效果的。

一些嵌入式设备对缓冲区有一些额外的要求，比如：在含有多个内存bank的设备中，要求只能在特定的bank中中分配内存；而还有一些要定内存边界对齐的缓存区。

近来，嵌入式设备有了较大的发展(特别是V4L领域)，并且这些驱动都有自己的内存分配代码。它们众多的大多数都是采用bootmem分配方法。CMA框架企图采用统一的连续内存分配机制，并为这些设备驱动提供简单的API，而且是可以定制化和模块化的。

3.  
 设计

CMA主要设计目标是提供一个可定制的模块化框架，并且是可以配置的，以适应个别系统的需要。配置指定的内存区域，然后将这些内存分配给制定的设备。这些内存区域可以共享给多个设备驱动，也可以专门分配一个。这是通过以下方式实现的：

1. CMA的核心不是处理内存分配和空闲空间管理。专用分配器是用来处理内存分配和空闲内存管理的。因此，如果现有的解决方案不符合给定的系统，那么可以开发一种新的算法，这种算饭可以很容易地插入到CMA框架中。

所提出的解决方案中包括一个最适算法(best-fit)的一个实现。

2. CMA允许运行时配置即将分配的内存区域。内存区域都是经由命令行给出的，所以可以很容易地改变它，而不需要重新编译内核。

每个地区都有自己的大小，对齐标准，起始地址（物理地址）和对应该内存区域的内存分配算法。

这意味着同一时刻可以有多中机制在运行，如果在一个平台上同时运行多个不同的设备，这些设备具有不同的存储器使用特性，那么局可以匹配最好的算法。

3. 当设备请求内存时，设备必须“自我介绍”，即附带自己的信息以告知CMA。这样CMA可以知道谁分配内存。这允许系统架构师来指定哪个移动设备应该使用哪些存储区。

3a. 设备也可以指定一个“类”内存区域，这使得系统更容易配置，进而一个单一的设备可能使用来自不同内存区域的内存。例如，一个视频解码器驱动程序可能要分配一些共享的缓冲区，那么从第一个bank中分配一些，再从第二个bank中分配一些，可以获得尽可能高的内存吞吐量。

4.  
 使用场景

虚构一个使用了CMA的系统，来观察一下其是如何使用和配置的。

有一个携带硬件视频解码器和摄像机的平台，每个设备在最坏的情况下可能需要20M的内存。在该系统中，这两个设备是不会同时使用的，并且内存是可能共享的。使用下面的两个命令行：

cma=r=20M cma_map=video,camera=r

第一个CMA指令是分配20M的内存，并且内存分配器是有效的；第二个表示，名称为“video”和“camera”的两个驱动从之前定义的内存区域中分配内存。

因为两者共享同一内存区域，相比于每个设备保留20M的内存区域，使得系统节省了20M的内存空进。

但是随着系统的发展和进化，平台上可能同时运行视频解码器和摄像机，那么20M的内存区域就不能满足需要了。那么可以通过命令快速解决：

cma=v=20M,c=20M cma_map=video=v;camera=c

从该解决方案中也可以看出CMA是如何为每一个设备分配所需的私有内存池的。

分配机制也能通过一种相似的方式进行替换。在测试中发现，当给定的内存区域大小为40M时，系统运行一段时间后，碎片会成为一个问题。因此，为了满足所需要求的缓存区大小，需要预留一个较大的缓存区。

但是不幸的是，你需要w设置一个新的分配算法——Neat Allocation Algorithm(简写na)，这两个设备对于内存有30M的需求：

cma=r=30M:na cma_map=video,camera=r

从上述示例可以看出，当CMA提供的算法不满足要求时，如何配置自己的分配算法，而不需要修改CMA或重编内核。

5.  
 技术细节

5.1           命令行参数

如上图所示，CMA有两个参数“cma”和“cma_map”；其中“cma”指定要为CMA保留的内存大小，参数“cma_map”用于指定该区域分配给为哪一个设备使用。

参数“cma”格式如下：

cma          ::=  "cma=" regions [ ';' ]

regions      ::= region [ ';' regions ]

region       ::= reg-name

'=' size

[ '@' start ]

[ '/' alignment ]

[ ':' [ alloc-name ] [ '(' alloc-params ')' ] ]

reg-name     ::= a sequence of letters and digits

//内存区的名称

size         ::= memsize   //内存区的大小

start        ::= memsize   //期望的内存区的起始地址

alignment    ::= memsize   //起始地址的对齐倍数

alloc-name   ::= a non-empty sequence of letters and digits

//
将要使用的分配器的名称

alloc-params ::= a sequence of chars other then ')' and ';'

//
分配器的参数

memsize      ::= whatever memparse() accepts

参数"cma_map" 的格式如下:

cma-map      ::=  "cma_map=" rules [ ';' ]

rules        ::= rule [ ';' rules ]

rule         ::= patterns '=' regions

patterns     ::= pattern [ ',' patterns ]

regions      ::= reg-name [ ',' regions ]

//
与device相匹配的内存区的名称

pattern      ::= dev-pattern [ '/' kind-pattern ]

| '/' kind-pattern

// pattern request must match for this rule to

// apply to it; the first rule that matches is

// applied; if dev-pattern part is omitted

// value identical to the one used in previous

// pattern is assumed

dev-pattern  ::= pattern-str

// pattern that device name must match for the

// rule to apply.

kind-pattern ::= pattern-str

// pattern that "kind" of memory (provided by

// device) must match for the rule to apply.

pattern-str  ::= a non-empty sequence of characters with '?'

meaning any character and possible '*' at

the end meaning to match the rest of the

string

示例 (whitespace added for better readability):

cma = r1 = 64M         // 64M区域

@512M       // 开始于512M (或尽可能接近)

/1M         // 确保内存区域1M对齐

:foo(bar);  // 使用带参bar的分配器foo

r2 = 64M         // 64M区域

/1M;        // 确保内存区域1M对齐

//
使用第一个有效分配器

r3 = 64M         // 64M区域

@512M       // 开始于512M (或尽可能接近)

:foo;       // 使用不带参的分配器foo

cma_map = foo = r1;    // kind==NULL的foo设备使用区域r1

foo/quaz = r2;  // OR:

/quaz = r2;  // kind == "quaz"的设备foo使用区域r2

foo/* = r3;     // OR:

/* = r3;        // 任何kinde的设备foo均可使用区域r3

bar/* = r1,r2;  // 任何kind的设备bar均可使用区域r1和r2

baz?/a* , baz?/b* = r3;

//
任何名如baz?且kind为a或b的设备都可以区域r3,其中?代表任意字符

5.2           设备与内存类别

设备名称来自device结构体。如果一个驱动没有注册为device，那么它是不能使用CMA的（通常，至少提供一个伪设备）。

无论设备何时申请内存，内存的类别都是一个可选的参数。在很多场景下，这个参数是可以忽略的，但是有时某些设备也可能需要。

比如：当前有两个内存bank，由于性能的原因，这两个内存bank设备都会使用，那么此时，设备驱动需要为这两个不同的buffer定义两个不同的名称。

cma=a=32M@0,b=32M@512M cma_map=foo/a=a;foo/b=b

但是无论何时，驱动分配内存都需要指定为某一个内存区域：

buffer1 = cma_alloc(dev, 1 << 20, 0, "a");

buffer2 = cma_alloc(dev, 1 << 20, 0, "b");

当然，如果需要（比如，当指定的内存已经使用完），需要允许驱动从其他的内存bank中分配。命令行参数可以改为：

cma=a=32M@0,b=32M@512M cma_map=foo/a=a,b;foo/b=b,a

换句话说，如果同一个设备在某一个系统上只使用一个内存bank，命令行参数：

cma=r=64M cma_map=foo/*=r

驱动无需做出任何更改。

5.3           API接口

CMA框架为设备提供了四个接口，分配接口cma_alloc()：

unsigned long cma_alloc(const struct device *dev,

const char *kind,

unsigned long size,

unsigned long alignment);

如果需要，设备可能需要指定对齐规格（这个规格是内存chunk需要满足的），必须是2的幂次或0.而chunks一般至少一PAGE对齐的。（page大小一般为4k）。

参数kind指定内存区域名称，如果没有指定，则采用NULL。调用示例：

addr = cma_alloc(dev, NULL, size, 0);

该函数返回的是物理地址，一般需要判断返回值的有效性：

unsigned long addr = cma_alloc(dev, size);

if (IS_ERR_VALUE(addr))

return (int)addr;

/* Allocated */

(Make sure to include <linux/err.h> which contains the definition of the IS_ERR_VALUE() macro.)

释放函数cma_put()：

int cma_put(unsigned long addr);

参数为内存块的物理地址，实现机制是递减引用计数，如果引用计数变为0，则释放该内存块。绝大部分时候，用户无需关注引用计数，只需要简单地调用cma_put()就可以了。

当该内存块共享给其他的驱动时，就需要调用cma_get()递增引用计数：

int cma_put(unsigned long addr);

最后一个函数是cma_info()，返回分配给指定(dev, kind)的内存缓存区的描述信息。原型如下：

int cma_info(struct cma_info *info,

const struct device *dev,

const char *kind);

通过这个函数可以获取内存区的边间，大小和对应于(dev, kind)内存区的个数。

5.4           分配操作

为CMA创建一个分配器需要实现四个函数。

前两个是用来初始化和卸载分配器：

int  cma_foo_init(struct cma_region *reg);

void cma_foo_done(struct cma_region *reg);

第一个函数在平台初始化时调用。结构体cma_region记录了缓存区的起始地址、大小，也会记录经由命令行传入的alloc_params域。

当调用函数cma_foo_done()时，均认为改缓存区的内存已经全部释放。

另外两个函数式块分配和释放函数：

struct cma_chunk *cma_foo_alloc(struct cma_region *reg,

unsigned long size,

unsigned long alignment);

void cma_foo_free(struct cma_chunk *chunk);

每一个函数，都是唯一线程访问的。因此，分配器不需要担心并发。

当分配器已经实现后，剩下的就是注册了，在文件"mm/cma-allocators.h"中定义如下语句：

CMA_ALLOCATOR("foo", foo)

第一个foo是命令行使用的分配器的名称，第二个是函数名字。

5.5           平台集成

在平台初始化过程，会调用函数cma_regions_allocate()：

void cma_regions_allocate(int (*alloc)(struct cma_region *reg));

会遍历命令行提过所有的内存区并为他们保留内存。只有一个参数cma_region用于保留内存。传入NULL会调用cma_region_alloc()函数来通过bootmem来分配内存。

平台也会提过cma_defaults()提供默认的cma和cma_map参数：

int cma_defaults(const char *cma, const char *cma_map)

6.  
 展望

在将来，CMA机制能够实现：CMA空闲区域能够用于page cache，文件系统buffer或设备交换区。如此，内存将不再会被浪费。

因为CMA的内存是经由CMA框架分配和释放的，所以CMA框架能够知道哪些内存分配了，哪些内存释放了。因此，可以跟踪未使用的内存，使得CMA可以将未使用的内存用于其他目的，如page cache，IO缓存，交换缓存等等。

作者：Younger Liu，

本作品采用知识共享署名-非商业性使用-相同方式共享 3.0 未本地化版本许可协议进行许可。