常见内存分配算法

一、首次适应算法 

　　　　使用该算法进行内存分配时，从空闲分区链首开始查找，直至找到一个能满足其大小要求的空闲分区为止。

　　　然后再按照作业的大小，从该分区中划出一块内存分配给请求者，余下的空闲分区仍留在空闲分区链中。

　　　　该算法倾向于使用内存中低地址部分的空闲分区，在高地址部分的空闲分区很少被利用，从而保留了高地址部分的大空闲区。

　　　显然为以后到达的大作业分配大的内存空间创造了条件。缺点在于低址部分不断被划分，留下许多难以利用、很小的空闲区，而每次查找又都从低址部分开始，这无疑会增加查找的开销。

二、循环首次适应法

　　　　该算法是由首次适应算法演变而成的。在为进程分配内存空间时，不再每次从链首开始查找，
　　而是从上次找到的空闲分区开始查找，直至找到一个能满足要求的空闲分区，并从中划出一块来分给作业。
　　该算法能使空闲中的内存分区分布得更加均匀，但将会缺乏大的空闲分区。

三、最佳适应算法

　　　  该算法总是把既能满足要求，又是最小的空闲分区分配给作业。
    　　为了加速查找，该算法要求将所有的空闲区按其大小排序后，以递增顺序形成一个空白链。
　　这样每次找到的第一个满足要求的空闲区，必然是最优的。孤立地看，该算法似乎是最优的，
　　但事实上并不一定。因为每次分配后剩余的空间一定是最小的，在存储器中将留下许多难以利用的小空闲区。
　　同时每次分配后必须重新排序，这也带来了一定的开销

四、最差适应算法

　　　　　最差适应算法中，该算法按大小递减的顺序形成空闲区链，分配时直接从空闲区链的第一个空闲分区中分配（不能满足需要则不分配）。

　　很显然，如果第一个空闲分区不能满足，那么再没有空闲分区能满足需要。这种分配方法初看起来不太合理，但它也有很强的直观吸引力：

　　在大空闲区中放入程序后，剩下的空闲区常常也很大，于是还能装下一个较大的新程序。
    　　最坏适应算法与最佳适应算法的排序正好相反，它的队列指针总是指向最大的空闲区，在进行分配时，总是从最大的空闲区开始查寻。
    　　该算法克服了最佳适应算法留下的许多小的碎片的不足，但保留大的空闲区的可能性减小了，而且空闲区回收也和最佳适应算法一样复杂。

// 常见内存分配算法.cpp : 定义控制台应用程序的入口点。
//




#include "stdafx.h"
#include <cstdio>
#include <cstdlib>
#include <Windows.h>


#define N     100
/*  
* freelist为空闲区链表的头，它的下一个节点才指向空闲缓冲区
* freelist是按首地址来排序的，而不是按size来排序。
* 按首地址排序便于相邻空闲内存合并；按size大小来排序，便于分配内存
*/

typedef struct _LIST_NODE
{
    CHAR* StartAddress;                //start addr 指向mem处开始的地址
    INT   BlockSize;                //size of the free block
    struct _LIST_NODE *NextNode;    //next free block
}LIST_NODE,*PLIST_NODE;


CHAR MemoryPool[N];                    //total memory pool
LIST_NODE FreeListHead;                //head of free list, no value
/* init freelist to contain the whole mem */
VOID Init()
{
    PLIST_NODE TempNode = (PLIST_NODE)malloc(sizeof(LIST_NODE));
    TempNode->StartAddress = MemoryPool;
    TempNode->BlockSize = N;
    TempNode->NextNode = NULL;
    FreeListHead.NextNode = TempNode;
}
/* remove a node ptr from the list whose previous node is prev */
void RemoveNode(PLIST_NODE CurrentNode, PLIST_NODE PrevNode)
{
    PrevNode->NextNode = CurrentNode->NextNode;

    //delete CurrentNode;
    int a = 0;
     
}


/* 
* 首次适配法：从自由空闲区中选取第一个合适空闲区来分配
* 返回分配内存区首地址
*/

CHAR*    FirstFit(int BlockSize)
{
    PLIST_NODE CurrentNode, PrevNode;
    CHAR*    MemoryAddress;

    for (PrevNode = &FreeListHead, CurrentNode = PrevNode->NextNode; CurrentNode; PrevNode = CurrentNode, CurrentNode = CurrentNode->NextNode)
        if (CurrentNode->BlockSize > BlockSize)
        {
            MemoryAddress = CurrentNode->StartAddress;
            CurrentNode->BlockSize -= BlockSize; //从空闲区去掉size空间
            CurrentNode->StartAddress += BlockSize; //空闲区首地址往后移size个单位
            return MemoryAddress; //返回申请到的空闲区 首地址
        }
        else if (CurrentNode->BlockSize == BlockSize)
        {
            MemoryAddress = CurrentNode->StartAddress;
            RemoveNode(CurrentNode, PrevNode);
            return MemoryAddress;
        }
    return NULL; //没有足够长的空闲内存
}

/* 最佳适配法：找到大小与size最接近的空闲区来分配 */
CHAR* BestFit(int BlockSize)
{
    PLIST_NODE CurrentNode, PrevNode;
    CHAR* MemoryAddress;
    int v1 = N + 1;
    PLIST_NODE minptr = NULL, minprev = NULL;

    for (PrevNode = &FreeListHead, CurrentNode = PrevNode->NextNode; CurrentNode; PrevNode = CurrentNode, CurrentNode = CurrentNode->NextNode) {
        if (CurrentNode->BlockSize >= BlockSize && CurrentNode->BlockSize - BlockSize < v1)
        {
            v1 = CurrentNode->BlockSize - BlockSize;
            minptr = CurrentNode;
            minprev = PrevNode;
        }
    }
        
    if (minptr == NULL)//没有找到
        return NULL;
    CurrentNode = minptr;
    PrevNode = minptr;
    if (CurrentNode->BlockSize > BlockSize)
    {
        MemoryAddress = CurrentNode->StartAddress;
        CurrentNode->BlockSize -= BlockSize;
        CurrentNode->StartAddress += BlockSize;
        return MemoryAddress;
    }
    else if (CurrentNode->BlockSize == BlockSize)
    {
        MemoryAddress = CurrentNode->StartAddress;
        RemoveNode(CurrentNode, PrevNode);
        return MemoryAddress;
    }
    return NULL;
}



/* prt: sizeof(int) contains size of the pool allocated
* 返回分配的空间首地址(不包括最前面的长度的4个字节)
*/
CHAR* Memalloc(int size)
{
    CHAR *v1 = BestFit(size + sizeof(int)); //此处选择分配算法
    printf("allocating %d using firstfit...
", size);
    if (v1 == NULL)
        return NULL;
    *(int *)v1 = size; //分配的空闲内存区前面几个字节用于存放分配数
    return v1 + sizeof(int);
}

/* add memptr of size to freelist, remember that block ptrs are stored on mem addr */
VOID AddToFreeList(CHAR *MemoryAddress, int BlockSize)
{
    PLIST_NODE PrevNode, CurrentNode, v1;

    for (PrevNode = &FreeListHead, CurrentNode = PrevNode->NextNode; CurrentNode && CurrentNode->StartAddress < MemoryAddress; PrevNode = CurrentNode, CurrentNode = CurrentNode->NextNode)
        ;
    v1 = (PLIST_NODE)malloc(sizeof(LIST_NODE));
    v1->StartAddress = MemoryAddress;
    v1->BlockSize = BlockSize;
    v1->NextNode = CurrentNode;
    PrevNode->NextNode = v1;
}

VOID PrintFreeList()
{
    PLIST_NODE CurrentNode;
    for (CurrentNode = FreeListHead.NextNode; CurrentNode; CurrentNode = CurrentNode->NextNode) {
        printf("{%u %d}", CurrentNode->StartAddress, CurrentNode->BlockSize);
    }
    putchar('
');
}
/* combine adj blocks of list if necessary */
VOID Coalesce()
{
    PLIST_NODE PrevNode, CurrentNode;

    for (PrevNode = &FreeListHead, CurrentNode = PrevNode->NextNode; CurrentNode; PrevNode = CurrentNode, CurrentNode = CurrentNode->NextNode) {
        if (PrevNode != &FreeListHead && PrevNode->StartAddress + PrevNode->BlockSize == CurrentNode->StartAddress)
        {
            PrevNode->NextNode = CurrentNode->NextNode;
            free(CurrentNode);
            CurrentNode = PrevNode;
        }
    }

}
VOID MemFree(CHAR* CurrentNode)
{
    int BlockSize = *(int *)(CurrentNode - sizeof(int));//找到已分配的空闲区大小(空闲区的前4个字节)
    printf("freeing %d...
", BlockSize);
    AddToFreeList(CurrentNode - sizeof(int), BlockSize + sizeof(int));
    Coalesce();
}



int main()
{
    /*
    CHAR *p1, *p2, *p3, *p4, *p5;
    Init();
    PrintFreeList();

    p1 = Memalloc(10);//note：分配10个字节，但其前面还有4个字节用于指示长度的，所以共用了14字节
    PrintFreeList();
    p2 = Memalloc(15);
    PrintFreeList();
    p3 = Memalloc(23);
    PrintFreeList();
    p4 = Memalloc(3);
    PrintFreeList();
    p5 = Memalloc(8);
    PrintFreeList();
    MemFree(p1);
    PrintFreeList();
    MemFree(p5);
    PrintFreeList();
    MemFree(p3);
    PrintFreeList();
    p1 = Memalloc(23);
    PrintFreeList();
    p1 = Memalloc(23);
    PrintFreeList();
    MemFree(p2);
    PrintFreeList();
    p1 = Memalloc(3);
    PrintFreeList();
    MemFree(p4);
    PrintFreeList();
    p2 = Memalloc(1);
    PrintFreeList();
    MemFree(p1);
    PrintFreeList();
    MemFree(p2);
    PrintFreeList();
    return 0;
    */


    CHAR* v1 = (CHAR*)malloc(100);

    int a = 0;
    free(v1);
}