浅析malloc（）的几种实现方式-stug1980-ChinaUnix博客

stug1980

首页　| 　博文目录　| 　关于我

stug1980

博客访问： 198281
博文数量： 264
博客积分： 6010
博客等级：准将
技术积分： 2740
用户组：普通用户
注册时间： 2009-06-03 13:25

文章分类

全部博文（264）

未分配的博文（264）

文章存档

2011年（1）

2009年（263）

我的朋友

相关博文

浅析malloc（）的几种实现方式

分类： C/C++

2009-06-04 15:08:28

malloc（）是C语言中动态存储管理的一组标准库函数之一。其作用是在内存的动态存储区中分配一个长度为size的连续空间。其参数是一个无符号整形数，返回值是一个指向所分配的连续存储域的起始地址的指针。

　　动态内存分配就是指在程序执行的过程中动态地分配或者回收存储空间的分配内存的方法。动态内存分配不像数组等静态内存分配方法那样需要预先分配存储空间，而是由系统根据程序的需要即时分配，且分配的大小就是程序要求的大小。本文简单介绍动态内存分配函数malloc（）及几种实现方法。

1．简介

　　malloc（）是C语言中动态存储管理的一组标准库函数之一。其作用是在内存的动态存储区中分配一个长度为size的连续空间。其参数是一个无符号整形数，返回值是一个指向所分配的连续存储域的起始地址的指针。还有一点必须注意的是，当函数未能成功分配存储空间（如内存不足）就会返回一个NULL指针。所以在调用该函数时应该检测返回值是否为NULL并执行相应的操作。 . |) T) Q( c# E

2．函数说明 6 h& q/ E2 O, m1 N  c% L
9 }. B" e0 k$ J0 q* A
　　C语言的动态存储管理由一组标准库函数实现，其原型在标准文件里描述，需要用这些功能时应包含这个文件。与动态存储分配有关的函数共有四个，其中就包括存储分配函数malloc（）。函数原型是：void *malloc (size_t n);这里的size_t是标准库里定义的一个类型，它是一个无符号整型。这个整型能够满足所有对存储块大小描述的需要，具体相当于哪个整型由具体的C系统确定。malloc的返回值为(void *)类型（这是通用指针的一个重要用途），它分配一片能存放大小为n的数据的存储块，返回对应的指针值；如果不能满足申请（找不到能满足要求的存储块）就返回NULL。在使用时，应该把malloc的返回值转换到特定指针类型，赋给一个指针。   [9 ^& s& h6 {# Q( h0 L6 D1 w/ o. F

　　注意，虽然这里的存储块是通过动态分配得到的，但是它的大小也是确定的，同样不允许越界使用。例如上面程序段分配的块里能存n个双精度数据，随后的使用就必须在这个范围内进行。越界使用动态分配的存储块，尤其是越界赋值，可能引起非常严重的后果，通常会破坏程序的运行系统，可能造成本程序或者整个计算机系统垮台。 7 G4 w$ W1 p7 w

　　下例是一个动态分配的例子：
#include

main()
{
　int count,*array; /*count是一个计数器，array是一个整型指针，也可以理解为指向一个整型数组的首地址*/
　if((array(int *) malloc (10*sizeof(int)))==NULL)
　{ 9 @- O3 ~5 d: ~5 |" E! k) P0 ?" p
　　printf("不能成功分配存储空间。"); . }1 i+ Z; M: `! T# w; e
　　exit(1);
　}
　for (count=0;count〈10;count++) /*给数组赋值*/
　　array[count]=count; 5 O- y0 o1 W4 u4 v, c" K
　for(count=0;count〈10;count++) /*打印数组元素*/ ' P& c+ @' C* @
　　printf("%2d",array[count]); ; |! Y! \; E# q. F8 j7 s
}

　　上例中动态分配了10个整型存储区域，然后进行赋值并打印。例中if((array(int *) malloc (10*sizeof(int)))==NULL)语句可以分为以下几步： 2 U7 E8 r/ s! O  t8 Y& [
　　1）分配10个整型的连续存储空间，并返回一个指向其起始地址的整型指针
　　2）把此整型指针地址赋给array
　　3）检测返回值是否为NULL

3． malloc（）工作机制
$ d8 X) }7 T. M+ Y+ o
　　malloc函数的实质体现在，它有一个将可用的内存块连接为一个长长的列表的所谓空闲链表。调用malloc函数时，它沿连接表寻找一个大到足以满足用户请求所需要的内存块。然后，将该内存块一分为二（一块的大小与用户请求的大小相等，另一块的大小就是剩下的字节）。接下来，将分配给用户的那块内存传给用户，并将剩下的那块（如果有的话）返回到连接表上。调用free函数时，它将用户释放的内存块连接到空闲链上。到最后，空闲链会被切成很多的小内存片段，如果这时用户申请一个大的内存片段，那么空闲链上可能没有可以满足用户要求的片段了。于是，malloc函数请求延时，并开始在空闲链上翻箱倒柜地检查各内存片段，对它们进行整理，将相邻的小空闲块合并成较大的内存块。

4． malloc（）在操作系统中的实现 7 k; v1 \# q, d! r  z3 w' `0 K

　　在 C 程序中，多次使用malloc () 和 free()。不过，您可能没有用一些时间去思考它们在您的操作系统中是如何实现的。本节将向您展示 malloc 和 free 的一个最简化实现的代码，来帮助说明管理内存时都涉及到了哪些事情。 ' b8 w# l8 r1 k, ?+ {4 _
& W9 U% A& u: K9 T$ l* b/ Q
　　在大部分操作系统中，内存分配由以下两个简单的函数来处理： ; ~1 w* z8 C) b5 `6 c# i

　　void *malloc (long numbytes)：该函数负责分配 numbytes 大小的内存，并返回指向第一个字节的指针。 - F* x( B! T# e! ]; V, b
+ b6 q) r0 h* q0 A/ p. p
　　void free(void *firstbyte)：如果给定一个由先前的 malloc 返回的指针，那么该函数会将分配的空间归还给进程的“空闲空间”。 : N, _  `( [2 M( |
- _  q) B# T0 a9 ~$ g7 E
　　malloc_init 将是初始化内存分配程序的函数。它要完成以下三件事：将分配程序标识为已经初始化，找到系统中最后一个有效内存地址，然后建立起指向我们管理的内存的指针。这三个变量都是全局变量： 8 b' h' D$ K/ V1 ?/ E1 W

　　清单 1. 我们的简单分配程序的全局变量 * z8 o+ n, @0 _# i: `; }' Y
1 H- c( g% @1 n  ?0 j5 y3 \! q% R
int has_initialized = 0;   I+ \; S% P7 B/ O0 b* e: o
void *managed_memory_start;
void *last_valid_address; * Z  Y8 f) X3 |. u. r7 Q/ r1 x
& b0 C; ~' I4 V0 M6 C; K
　　如前所述，被映射的内存的边界（最后一个有效地址）常被称为系统中断点或者当前中断点。在很多 UNIX? 系统中，为了指出当前系统中断点，必须使用 sbrk(0) 函数。 sbrk 根据参数中给出的字节数移动当前系统中断点，然后返回新的系统中断点。使用参数 0 只是返回当前中断点。这里是我们的 malloc 初始化代码，它将找到当前中断点并初始化我们的变量： 9 d& f$ z+ J; O/ W* Y

　　清单 2. 分配程序初始化函数 4 k- Z! w, u4 O* V# C. A' \
/* Include the sbrk function */
! t) F& r5 b' ^! B( I$ y: O
#include 5 \$ w& J  W! ]& S
void malloc_init()
{ 8 f: _; O% z7 b; {
/* grab the last valid address from the OS */
last_valid_address = sbrk(0);
/* we don't have any memory to manage yet, so
*just set the beginning to be last_valid_address
*/
managed_memory_start = last_valid_address; ) R& r) t: A: c, Z" B( j% t
/* Okay, we're initialized and ready to go */
has_initialized = 1; 6 \+ H+ l% a: O$ H$ Y; g7 Q
}

　　现在，为了完全地管理内存，我们需要能够追踪要分配和回收哪些内存。在对内存块进行了 free 调用之后，我们需要做的是诸如将它们标记为未被使用的等事情，并且，在调用 malloc 时，我们要能够定位未被使用的内存块。因此， malloc 返回的每块内存的起始处首先要有这个结构：
. |+ V& M3 a  c% g( ?" o
　　清单 3. 内存控制块结构定义 9 K3 ~% A% P7 K' J5 T, U
struct mem_control_block {
int is_available;
int size;
};

　　现在，您可能会认为当程序调用 malloc 时这会引发问题 —— 它们如何知道这个结构？答案是它们不必知道；在返回指针之前，我们会将其移动到这个结构之后，把它隐藏起来。这使得返回的指针指向没有用于任何其他用途的内存。那样，从调用程序的角度来看，它们所得到的全部是空闲的、开放的内存。然后，当通过 free() 将该指针传递回来时，我们只需要倒退几个内存字节就可以再次找到这个结构。 2 ?+ Q& Y9 a% v: g3 S' k

　　在讨论分配内存之前，我们将先讨论释放，因为它更简单。为了释放内存，我们必须要做的惟一一件事情就是，获得我们给出的指针，回退 sizeof(struct mem_control_block) 个字节，并将其标记为可用的。这里是对应的代码：
5 O) b, Z" w+ Q7 x: o
　　清单 4. 解除分配函数
void free(void *firstbyte) {
struct mem_control_block *mcb; * K; h' g% O  c8 [
/* Backup from the given pointer to find the
* mem_control_block ! U1 L, g, U* O/ S4 [7 ~: l6 q
*/
mcb = firstbyte - sizeof(struct mem_control_block);
/* Mark the block as being available */
mcb->is_available = 1;
/* That's It! We're done. */ $ d% a2 ~5 c( n& J5 |" G3 c
return; , k" {5 b- J. Q, ^" t/ p5 r& h: q
}

　　如您所见，在这个分配程序中，内存的释放使用了一个非常简单的机制，在固定时间内完成内存释放。分配内存稍微困难一些。以下是该算法的略述：
& d: k- g# p- S6 t
　　清单 5. 主分配程序的伪代码
1. If our allocator has not been initialized, initialize it.
2. Add sizeof(struct mem_control_block) to the size requested.
3. start at managed_memory_start.
4. Are we at last_valid address?
5. If we are: ! C! K4 x& U( p3 E: M2 G
A. We didn't find any existing space that was large enough * n- R* ?# }, }8 J) z; z" z
-- ask the operating system for more and return that.
6. Otherwise:   L  s$ }& W  R+ n0 Q, C0 O
A. Is the current space available (check is_available from
the mem_control_block)?
B. If it is:
i) Is it large enough (check "size" from the
mem_control_block)?
ii) If so: % e6 G" }/ Z- z6 y2 f2 C3 T3 U/ I2 b
a. Mark it as unavailable
b. Move past mem_control_block and return the / M& S5 Q) L' f
pointer
iii) Otherwise:
a. Move forward "size" bytes & S9 O3 u/ b4 S/ y
b. Go back go step 4
C. Otherwise: , m- \/ v2 Q7 ?5 d( c" q' W
i) Move forward "size" bytes
ii) Go back to step 4
7 n6 m$ v5 `. \0 v! m
　　我们主要使用连接的指针遍历内存来寻找开放的内存块。这里是代码： 4 h3 H; \" t& x' e, t+ F" t% c6 Q

　　清单 6. 主分配程序
void *malloc(long numbytes) {
/* Holds where we are looking in memory */
void *current_location;
/* This is the same as current_location, but cast to a ( _" r  w- n, ^0 P9 c4 _
* memory_control_block 6 F( |6 t* L7 |. C! D, m% ?
*/
struct mem_control_block *current_location_mcb;
/* This is the memory location we will return. It will $ b# `! J* B0 l) |* P- ~  t
* be set to 0 until we find something suitable
*/
void *memory_location;
/* Initialize if we haven't already done so */
if(! has_initialized) {
malloc_init();
} ' F) J: x& |8 r% n
/* The memory we search for has to include the memory " r- s) j& x8 |7 ]( x/ [& o
* control block, but the users of malloc don't need
* to know this, so we'll just add it in for them. : P: r3 f- ~9 f- y  r& M( \
*/ 2 k/ [% O1 y3 c5 t+ J* x4 D
numbytes = numbytes + sizeof(struct mem_control_block); 6 K( L" S8 C9 D0 c
/* Set memory_location to 0 until we find a suitable
* location
*/
memory_location = 0; + B' Q, L7 J+ w# \# {5 L! h/ K* _; c' X
/* Begin searching at the start of managed memory */
current_location = managed_memory_start; : q3 M2 V! z1 d/ m
/* Keep going until we have searched all allocated space */
while(current_location != last_valid_address)
{
/* current_location and current_location_mcb point
* to the same address. However, current_location_mcb
* is of the correct type, so we can use it as a struct.
* current_location is a void pointer so we can use it
* to calculate addresses. # K7 C. e2 J9 w# l
*/
current_location_mcb =
(struct mem_control_block *)current_location; / W6 L% u6 n# t3 U' t2 D
if(current_location_mcb->is_available)
{ * s0 y/ U( O2 g1 e5 j6 w) e0 U5 d% [
if(current_location_mcb->size >= numbytes) ( b  z1 A; L- e
{   k: W1 |' u* W2 l8 L9 w/ b3 w
/* Woohoo! We've found an open, - l' D; a) @8 m' Y8 t
* appropriately-size location. 1 `( \8 i$ C/ `9 x) q
*/
/* It is no longer available */ . d, U* S! o1 h6 R: A( |
current_location_mcb->is_available = 0;
/* We own it */ : D( n  h5 K! \* F- u
memory_location = current_location; 1 X1 U, z) A$ b% o  W8 K' m6 u
/* Leave the loop */
break;   {% h9 F3 e8 j2 l* p
}
}
/* If we made it here, it's because the Current memory 6 C: e6 x% f! w  `! m. k
* block not suitable; move to the next one
*/
current_location = current_location + + V7 ]( L8 Y9 h- ~* Y" ~
current_location_mcb->size; ) P; w' |& v6 a0 `, O6 [
}
/* If we still don't have a valid location, we'll 7 Q; m( n$ g/ u1 N2 z+ e* T
* have to ask the operating system for more memory 7 @7 C+ y# p% y. I- m6 I9 T" q
*/
if(! memory_location)
{
/* Move the program break numbytes further */
sbrk(numbytes); 6 r( {3 ^5 w) v# m; H2 m
/* The new memory will be where the last valid - q+ y# \+ Z9 c5 J& n1 z) C' b
* address left off 5 C& ^5 w$ a) l/ P7 O- s: k! R/ q  K
*/
memory_location = last_valid_address; / F. h& A8 e: ?6 E5 N+ Q$ J8 f6 s0 e
/* We'll move the last valid address forward
* numbytes
*/
last_valid_address = last_valid_address + numbytes; # v# Y2 [. g' E6 E9 o& B! W% g
/* We need to initialize the mem_control_block */
current_location_mcb = memory_location;
current_location_mcb->is_available = 0; * t/ U: b: J% t* M3 S- {- j
current_location_mcb->size = numbytes; " x7 Z: k8 p% M- u
}
/* Now, no matter what (well, except for error conditions),
* memory_location has the address of the memory, including
* the mem_control_block 8 v) _/ c2 [. D, ?+ E, H
*/ - J6 ^( E; L, |7 Y* V# _
/* Move the pointer past the mem_control_block */
memory_location = memory_location + sizeof(struct mem_control_block);
/* Return the pointer */ ' \& ?, j3 q% N* h& r
return memory_location;
}

　　这就是我们的内存管理器。现在，我们只需要构建它，并在程序中使用它即可。

5． malloc（）的其他实现 9 s; j2 V# W+ d1 Q9 Z* ]7 d
( }) m1 O9 F/ A0 V) a5 b4 {
　　malloc() 的实现有很多，这些实现各有优点与缺点。在设计一个分配程序时，要面临许多需要折衷的选择，其中包括：

　　分配的速度。 ; y1 [6 a6 s! i' J
　　回收的速度。
　　有线程的环境的行为。
　　内存将要被用光时的行为。
　　局部缓存。
　　簿记（Bookkeeping）内存开销。 9 O0 b8 z+ f8 y. O- r9 a6 L
　　虚拟内存环境中的行为。 2 a) V, b& {( I, n! V1 e
　　小的或者大的对象。
　　实时保证。 ; Y9 _' p# l9 U- u0 g: n
　　每一个实现都有其自身的优缺点集合。在我们的简单的分配程序中，分配非常慢，而回收非常快。另外，由于它在使用虚拟内存系统方面较差，所以它最适于处理大的对象。

　　还有其他许多分配程序可以使用。其中包括：
8 J" ~% K. o3 y4 Z* A' o
　　Doug Lea Malloc：Doug Lea Malloc 实际上是完整的一组分配程序，其中包括 Doug Lea 的原始分配程序，GNU libc 分配程序和 ptmalloc。 Doug Lea 的分配程序有着与我们的版本非常类似的基本结构，但是它加入了索引，这使得搜索速度更快，并且可以将多个没有被使用的块组合为一个大的块。它还支持缓存，以便更快地再次使用最近释放的内存。 ptmalloc 是 Doug Lea Malloc 的一个扩展版本，支持多线程。在本文后面的参考资料部分中，有一篇描述 Doug Lea 的 Malloc 实现的文章。 5 [* Z+ ~2 z9 B/ a; G1 \
: ~0 h  j, c) R1 G4 y
　　BSD Malloc：BSD Malloc 是随 4.2 BSD 发行的实现，包含在 FreeBSD 之中，这个分配程序可以从预先确实大小的对象构成的池中分配对象。它有一些用于对象大小的 size 类，这些对象的大小为 2 的若干次幂减去某一常数。所以，如果您请求给定大小的一个对象，它就简单地分配一个与之匹配的 size 类。这样就提供了一个快速的实现，但是可能会浪费内存。在参考资料部分中，有一篇描述该实现的文章。
$ v% r5 S: l% o$ C1 c
　　Hoard：编写 Hoard 的目标是使内存分配在多线程环境中进行得非常快。因此，它的构造以锁的使用为中心，从而使所有进程不必等待分配内存。它可以显著地加快那些进行很多分配和回收的多线程进程的速度。在参考资料部分中，有一篇描述该实现的文章。
众多可用的分配程序中最有名的就是上述这些分配程序。如果您的程序有特别的分配需求，那么您可能更愿意编写一个定制的能匹配您的程序内存分配方式的分配程序。不过，如果不熟悉分配程序的设计，那么定制分配程序通常会带来比它们解决的问题更多的问题。 3 Q7 W' B2 A7 n4 d

6．结束语 ; W7 q( P: q) O3 u

　　前面已经提过，多次调用malloc（）后空闲内存被切成很多的小内存片段，这就使得用户在申请内存使用时，由于找不到足够大的内存空间，malloc（）需要进行内存整理，使得函数的性能越来越低。聪明的程序员通过总是分配大小为2的幂的内存块，而最大限度地降低潜在的malloc性能丧失。也就是说，所分配的内存块大小为4字节、8字节、16字节、18446744073709551616字节，等等。这样做最大限度地减少了进入空闲链的怪异片段（各种尺寸的小片段都有）的数量。尽管看起来这好像浪费了空间，但也容易看出浪费的空间永远不会超过50%。 ' }& e$ L' R) _6 }5 O9 F

阅读(348) | 评论(0) | 转发(0) |

上一篇：消息映射的实现（2）

下一篇：C++和Java传统中积极的一面

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6