许多书籍提到过内存碎片,也看到一些方法防治内存碎片。一直以来都以为频繁的分配释放内存会导致系统内存碎片过多(虽然这个想法并没有错到离谱)。后来看过计算机程序设计艺术上面关于伙伴系统的介绍,一般操作系统都采用此种方法来管理内存。频繁分配释放内存确实会导致一些系统负担,但分配的内存释放及时,内存管理系统将能够急时合并相邻空闲内存块,得到更大的空闲内存。这样并不会导致内存碎片的出现。即使相邻空间不空闲,这样产生的碎片还是比较少的
今天突然醒悟内存碎片的出现主要跟分配有关,特别是分配小而且生命周期很长的内存块时,才容易导致内存碎片的出现。对于伙伴系统,假设有16byte空间,依次分配一个1,3,5byte空间,在分配4byte,对于伙伴系统将分配不出最后的4byte,尽管还有7byte的额外空间,但这些空间只剩下1、2byte的空间块,如下图,即使这些伙伴空间都是空闲的,也难以被充分利用。而3、5byte分配后剩下的空间更是由于少于上层空间的一半而被浪费掉了,不能再进行分配。如果分配的小块内存相当多,将会浪费很多内存空间,导致内存碎片化。当然真正操作系统是32位对齐的,但情行是类似的
所以如果要动态分配的空间比较小,一般采取先分配一大块空间。然后在有内存分配需求时,从大块空间依次取出。如vc中的map list array 等便是如此设计。每个类都先使用CPlex 分配一定数量的CAssoc空间,当空间用完后,在分配相同大小的空间。当然这些空间是链接在一起的。下面是从quake3中摘出来的一部分代码,对于quake配置参数是一直存在于整个软件运行期的,这些参数依次保存在smallzone空间中。
如果分配的空间很快就会释放(如分配释放同时在一个函数内),那么就不需要考虑内存碎片问题。但是鉴于伙伴系统效率,如果存在大量频繁的分配释放,可以考虑使用桶状内存管理。即分配一块大的内存zone(当然还需要3个指针,标志zone头尾和当前写入的位置)。而后需要相对小的空间时,直接向zone中写入,如到zone尾部时,转到zone开头写入。当然以前写的东西就被覆盖了,一定要保证覆盖时这段内存中的东西已经不再需要了。如果想更省事可以考虑boost pool 内存池,不过 pool 每次分配的块大小总是固定的
void func()
{
boost::pool<> p(256*sizeof(BYTE)); //指定每次分配的块的大小
for (int i = 0; i < 10000; ++i)
{
BYTE* const p = p.malloc(); //pool分配指定大小的内存块;需要的时候,pool会向系统申请大块内存。
... // Do something with t;
p.free( p); //释放内存块,交还给pool,不是返回给系统。
}
//pool的析构函数会释放所有从系统申请到的内存。
}
//注意必须是.c文件。
#define ZONEID 0x1d4a11
typedef enum
{
TAG_FREE,
TAG_GENERAL,
TAG_BOTLIB,
TAG_RENDERER,
TAG_SMALL,
TAG_STATIC
} memtag_t;
typedef struct memblock_s
{
int size; // including the header and possibly tiny fragments
int tag; // a tag of 0 is a free block
struct memblock_s *next, *prev;
int id; // should be ZONEID
} memblock_t;
memzone_t *mainzone;
memzone_t *smallzone;
//只调用一次分配足够内存空间
void Com_InitSmallZoneMemory( void ) {
s_smallZoneTotal = 512 * 1024;
smallzone = calloc( s_smallZoneTotal, 1 );
if ( !smallzone )
{
Com_Error( ERR_FATAL, "Small zone data failed to allocate %1.1f megs", (float)s_smallZoneTotal /(1024*1024) );
}
Z_ClearZone( smallzone, s_smallZoneTotal );
return;
}
//从大的内存空间中逐步取出足够的小块空间
void *S_Malloc( int size)
{
int extra, allocSize;
memblock_t *start, *rover, *new, *base;
memzone_t *zone;
tag =TAG_SMALL;
zone = smallzone;
allocSize = size;
size += sizeof(memblock_t); // account for size of block header
size += 4; // space for memory trash tester
size = (size + 3) & ~3; // align to 32 bit boundary
base = rover = zone->rover;
start = base->prev;
do
{
if (rover == start)
{
Com_Error( ERR_FATAL, "Z_Malloc: failed on allocation of %i bytes from the %s zone", size, zone == smallzone ? "small" : "main");
return NULL;
}
if (rover->tag)
{
base = rover = rover->next;
} else
{
rover = rover->next;
}
} while (base->tag || base->size < size);
extra = base->size - size;
if (extra > MINFRAGMENT) {
// there will be a free fragment after the allocated block
new = (memblock_t *) ((byte *)base + size );
new->size = extra;
new->tag = 0; // free block
new->prev = base;
new->id = ZONEID;
new->next = base->next;
new->next->prev = new;
base->next = new;
base->size = size;
}
base->tag = tag; // no longer a free block
zone->rover = base->next; // next allocation will start looking here
zone->used += base->size; //
base->id = ZONEID;
*(int *)((byte *)base + base->size - 4) = ZONEID;
return (void *) ((byte *)base + sizeof(memblock_t));
}
void Z_ClearZone( memzone_t *zone, int size ) {
memblock_t *block;
// set the entire zone to one free block
zone->blocklist.next = zone->blocklist.prev = block =
(memblock_t *)( (byte *)zone + sizeof(memzone_t) );
zone->blocklist.tag = 1; // in use block
zone->blocklist.id = 0;
zone->blocklist.size = 0;
zone->rover = block;
zone->size = size;
zone->used = 0;
block->prev = block->next = &zone->blocklist;
block->tag = 0; // free block
block->id = ZONEID;
block->size = size - sizeof(memzone_t);
}
//向内存块中添加字符串
char *CopyString( const char *in )
{
char *out;
if (!in[0]) {
return ((char *)&emptystring) + sizeof(memblock_t);
}
else if (!in[1])
{
if (in[0] >= '0' && in[0] <= '9')
{
return ((char *)&numberstring[in[0]-'0']) + sizeof(memblock_t);
}
}
out = S_Malloc (strlen(in)+1);
strcpy (out, in);
return out;
}