简析quakeIII中利用链表实现的内存管理（1）

　　因为工作主要环境是单片机，所以平时很少使用链表。偶然看到quakeIII源码中有使用链表实现的内存分配的内容，特别摘出自己感兴趣的地方来并添加简短的注释。目前只对malloc的地方增加汉字说明，理解了malloc，其他地方也就自然理解了。

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include<windows.h>

#define ZONEID 0x1d4a11
#define MINFRAGMENT 64
#define MAX_MALLOC    (1024*5)
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;

typedef struct {
    int size;       // total bytes malloced, including header
    int used;        // total bytes used
    memblock_t blocklist;     // start / end cap for linked list
    memblock_t *rover;
}memzone_t;

// main zone for all "dynamic" memory allocation
memzone_t *mainzone;
// we also have a small zone for small allocations that would only
// fragment the main zone (think of cvar and cmd strings)
memzone_t *smallzone;
/*
========================
Z_CheckHeap
========================
*/
void Z_CheckHeap(void) {
    memblock_t *block;

    for(block = mainzone->blocklist.next;;block = block->next) {
        if(block->next == &mainzone->blocklist)
        {
            break;
        }
        if ( (unsigned char *)block + block->size != (unsigned char *)block->next)
        {
            printf("Z_CheckHeap: block size dose not touch the next block
");
            exit(-1);
        }
        if ( block->next->prev != block) {
            printf( "Z_CheckHeap: next block dosen't have proper back link
");
            exit(-1);
        }
        if ( !block->tag && !block->next->tag ) {
            printf( "Z_CheckHeap: two consective free blocks
");
        }
    }    
}
/*
========================
Z_ClearZone
========================
*/
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 *)((unsigned char *)zone + sizeof(memzone_t));
    zone->blocklist.tag = 1;
    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;
    block->id = ZONEID;
    block->size = size - sizeof(memzone_t);
}
/*
========================
Z_AvailableZoneMemory
========================
*/
int Z_AvailableZoneMemory( memzone_t *zone)
{
    return zone->size - zone->used;
}
/*
========================
Z_AvailableMemory
========================
*/
int Z_AvailableMemory( void ){
    return Z_AvailableZoneMemory( mainzone);
}
/*
========================
Z_Free
========================
*/
void Z_Free(void *ptr){
    memblock_t *block,*other;
    memzone_t *zone;

    if( !ptr){
        printf("Z_Free: NULL pointer
");
        exit(-1);
    }
    //根据起始指针向前移动sizeof(memblock)
    block = (memblock_t *)((unsigned char *)ptr - sizeof(memblock_t));
    if (block->id != ZONEID){
        printf("Z_Free: freed a pointer without ZONEID
");
        exit(-1);
    }
    if (block->tag == 0){
        printf("Z_Free: freed a freed pointer
");
        exit(-1);
    }

    if (block->tag == TAG_STATIC){
        return;
    }

    if ( *(int *)((unsigned char *)block + block->size -4) != ZONEID){
        printf("Z_Free: memory block wrote past end
");
        exit(-1);
    }

    if (block->tag == TAG_SMALL){
        zone = smallzone;
    } else {
        zone = mainzone;
    }

    zone->used -= block->size;
    //set the block to something that should cause problems
    //if it is referenced..
    memset( ptr, 0xaa, block->size - sizeof( *block ) );

    block->tag = 0;// mark as free

    other = block->prev;
    if (!other->tag){
        //merge with previous free block
        other->size += block->size;
        other->next = block->next;
        other->next->prev = other;
        if (block == zone->rover) {
            zone->rover = other;
        }
        block = other;
    }

    zone->rover = block;

    other = block->next;
    if ( !other->tag ) {
        // merge the next free block onto the end
        block->size += other->size;
        block->next = other->next;
        block->next->prev = block;
        if (other == zone->rover) {
            zone->rover = block;
        }
    }
}
/*
================
Z_FreeTags
================
*/
void Z_FreeTags(int tag) {
    int count;
    memzone_t *zone;

    if (tag == TAG_SMALL) {
        zone = smallzone;
    }else {
        zone = mainzone;
    }
    count = 0;

    //use the rover as our pointer,because
    //Z_Free automatically adjusts it
    zone->rover = zone->blocklist.next;
    do{
        if( zone->rover->tag == tag) {
            count ++;
            Z_Free( (void*)(zone->rover +1));
            continue;
        }
        zone->rover = zone->rover->next;
    }while(zone->rover != &zone->blocklist);
}
/*
================
Z_TagMalloc
================
*/
void *Z_TagMalloc( int size, int tag ){
    int extra,allocSize,i=20;
    memblock_t *start, *rover, *new, *base;
    memzone_t *zone;

    if (!tag){
        printf("Z_TagMalloc: tried to use a 0 tag
");
        exit(-1);
    }

    if( tag== TAG_SMALL){
        zone = smallzone;
    }else {
        zone = mainzone;
    }

    allocSize = size;
    //
    //scan through the block list looking for the first free block
    //of sufficient size
    //
    size += sizeof(memblock_t);
    size += 4;
    size = (size +3)& ~3;//align to 32 bit boudary

    base = rover = zone->rover;
    start = base->prev;

    do {
        if (rover == start ) {
            printf( "Z_Malloc: failed on allocation of %i bytes from the %s zone
",
                        size, zone == smallzone ? "small" : "main");
            return NULL;
        }
        if (rover->tag){//已经在用，则更新base指针
            base = rover = rover->next;
        } else {//不存在连续的未使用区域
            rover = rover->next;
        }
    }while (base->tag || base->size < size);//查找符合条件的区域

    //
    //found a block big enough
    //

    extra = base->size - size;
    if (extra > MINFRAGMENT) {
        // there will be a free fragment after the allocated block
        new = ( memblock_t *)((unsigned char *)base + size);
        new->size = extra;
        new->tag = 0;
        new->prev = base;//链表插入
        new->id = ZONEID;
        new->next = base->next;//链表插入
        new->next->prev = new;//链表插入
        base->next = new;//已分配区域更新
        base->size = size;//已分配区域更新
    }

    base->tag = tag;//已分配区域更新

    zone->rover = base->next;//zone更新，指向new
    zone->used += base->size;//zone更新，使用计算

    base->id = ZONEID;//已分配区域更新

    *(int *)((unsigned char *)base + base->size - 4) = ZONEID;//尾部错误检验

    return (void *)((unsigned char *)base + sizeof(memblock_t));
}
/*
========================
Z_Malloc
========================
*/
void *Z_Malloc( int size) {
    void *buf;

    Z_CheckHeap();
    buf = Z_TagMalloc( size, TAG_GENERAL );
    if(buf)
    memset( buf, 0, size );

    return buf;
}

void *S_Malloc( int size ) {
    return Z_TagMalloc(size, TAG_SMALL );
}

void Com_InitZoneMemory( void ) {
    mainzone = calloc( MAX_MALLOC, 1 );
    if(!mainzone) {
        printf("Zone Data failed to allocate %i megs
",MAX_MALLOC/(1024*1024));
        exit(-1);
    }
    Z_ClearZone( mainzone, MAX_MALLOC);
}


//===============
//test malloc
//===============
int main(void)
{
    const char str[] = "kkkkkk
";
    char *p1,*p2,*p3,*p4,*p5,*p6;
    Com_InitZoneMemory();
    printf("Available Memory is: %d
",Z_AvailableMemory());        
    if(1)
    {
        p1 = Z_Malloc(1024);
        printf("P1 Available Memory is: %d,
",Z_AvailableMemory());
        p2 = Z_Malloc(1024);
        printf("P2 Available Memory is: %d
",Z_AvailableMemory());
        p3 = Z_Malloc(1024);
        printf("P3 Available Memory is: %d
",Z_AvailableMemory());
        p4 = Z_Malloc(1024);
        printf("P4 Available Memory is: %d,
",Z_AvailableMemory());
        p5 = Z_Malloc(1024);
        printf("P5 Available Memory is: %d
",Z_AvailableMemory());
        Z_Free(p2);
        printf("P2 Clear Memory is: %d
",Z_AvailableMemory());
        Z_Free(p3);
        printf("P3 Clear Memory is: %d
",Z_AvailableMemory());
        p6 = Z_Malloc(1024*2);
        printf("P3 Available Memory is: %d
",Z_AvailableMemory());
        //Z_Free(p1);
        //printf("P1 Clear Memory is: %d
",Z_AvailableMemory());
        //Z_Free(p2);
        //printf("P2 Clear Memory is: %d
",Z_AvailableMemory());
        //Z_Free(p3);
        //printf("P3 Clear Memory is: %d
",Z_AvailableMemory());
        getchar();
    }
    return 0;
}

　　在VS中进行了测试，运行的很好。但是内存碎片仍是不可避免，需要特别注意。