C语言：伙伴系统

---

1 伙伴系统

• 与边界标志法相比没有尾信息
• 分配内存块大小： 2ⁿ
• 由同一个内存块分割成的两个完全相等的内存块互为伙伴。
• 内存碎片化严重
• 回收时必须互为伙伴才能合并
  不是伙伴，无法确定另一个内存块的边界

2 C语言实现

2.1 头文件

#pragma once

#define M 16

typedef struct Word//定义节点
{
	struct Word* llink;//前驱
	int tag;//0为空闲，1为占用
	int kval;//k值，内存块的大小2^k
	struct Word* rlink;//后继
}Word, * Space;

typedef struct HeadNode//定义顺序表节点
{
	int nodesize;//内存空间的大小
	Word* first;//表映射内存空间的指针
	Word* start;//记录内存池的首的地址
}FreeList[M+1];//顺序表

Space CreateMem();//创建内存池

void InitSqlist(FreeList& avail,Space p);//初始化顺序表

Word* AllocBuddy(FreeList& avail, int n);//分配内存单元

void Free(FreeList& avail, Space p);//回收内存

2.2 创建内存池

#include"buddy.h"
#include<stdio.h>
#include <malloc.h>
#include<math.h>
#include <cassert>

//Word* start;//定义全局变量记录内存池的开始地址，也可以在表的结构体中记录内存池的首的地址

Space CreateMem()
{
	Word* pmem = (Word*)malloc((int)pow(2, M) * sizeof(Word));// 创建内存池
	assert(pmem != NULL);

	pmem->llink = pmem;
	pmem->rlink = pmem;
	pmem->tag = 0;
	pmem->kval = M;
	//start = pmem;

	return pmem;
}

2.3 初始化内存映射顺序表

void InitSqlist(FreeList& avail,Space p)//初始化内存映射表
{
	avail[0].start = p;

	for (int i = 0; i <= M; i++)
	{
		avail[i].first = NULL;
		avail[i].nodesize = 0;
	}
	int k = p->kval;
	avail[k].first = p;
	avail[k].nodesize = (int)pow(2, k);

}

2.4 分配内存单元

2.4.1 从内存映射表中删除该内存单元

static void Delete(FreeList& avail, Space p)//从对应表中删除该内存单元
{
	Word* front = p->llink;
	Word* rear = p->rlink;
	if (p == rear)//合并后，对应表内没有其他内存单元，将对应表置空
	{
		avail[p->kval].first = NULL;
	}
	else//合并后，对应表内有其他内存单元，从表中删除该空间单元p
	{
		front->rlink = rear;
		rear->llink = front;
		avail[p->kval].first = rear;

		p->llink = p;
		p->rlink = p;
	}
}

2.4.2 分配内存单元，将剩余空间分裂

Word* AllocBuddy(FreeList& avail, int n)//分配内存单元
{
	Word* p = NULL;//分配的内存单元

	for (int k = 0; k <= M; ++k)
	{
		if (k > M)
		{
			return NULL;
		}
		else if (avail[k].nodesize >= n && avail[k].first != NULL)
		{
			p = avail[k].first;
			Delete(avail, p);//从对应表中删除该内存单元

			int i = 1;

			if (p->kval > 0 && avail[k].first == NULL)//将剩余空间分裂，插入表中
			{
				while ((int)pow(2, k - i) >= n)
				{
					Word* pi = p + (int)pow(2, k - i);
					//pi = p + (int)pow(2, k - i);
					pi->rlink = pi;
					pi->llink = pi;
					pi->tag = 0;
					pi->kval = k - i;

					avail[k - i].first = pi;
					avail[k - i].nodesize = (int)pow(2, pi->kval);

					i++;
				}
			}
			p->llink = p;
			p->rlink = p;
			p->tag = 1;
			p->kval = k-(--i);

			break;
		}
	}
	return p;
}

2.5 回收内存

2.5.1 判断要回收的内存单元是左块还是右块

static Word* RorL(FreeList& avail,Space p)//判断左右内存块
{
	//int tmp = p - start;//计算p的相对地址
	int tmp = p - avail[0].start;

	int flg = tmp % (int)pow(2, p->kval + 1);

	if (flg != 0)//p为右块，地址高
	{
		return p - (int)pow(2, p->kval);
	}
	else//p为左块，地址低
	{
		return  p + (int)pow(2, p->kval);
	}

}

2.5.2 将内存单元和顺序表映射

static void Insert(FreeList& avail, Space p)//将内存单元和对应表映射
{
	if (avail[p->kval].first == NULL)//对应表为空，直接映射
	{
		avail[p->kval].first = p;
		p->tag = 0;
	}
	else//对应表不为空，插在对应表指向内存单元的前面
	{
		Word* q1 = avail[p->kval].first;

		Word* front = q1->llink;

		q1->llink = p;
		front->rlink = p;

		p->llink = front;
		p->rlink = q1;
		p->tag = 0;
	}
}

2.5.3 判断顺序表是否为空

bool IsEmpty(FreeList& avail)
{
	for (int i = 0; i <= M; i++)
	{
		if (avail[i].first != NULL)
		{
			return false;
		}
	}
	return true;
}

2.5.4 判断伙伴，进行内存单元的回收合并

static void Free_mask(FreeList& avail, Space& p)//一次回收合并
{                                     //形参p为实参的引用
	Space pi = RorL(avail, p);

	if (pi->tag == 1)//伙伴不空闲
	{
		Insert(avail, p);//看对应表情况，映射
	}
	else if (pi->tag == 0 && pi->kval != p->kval)//伙伴不完整
	{
		Insert(avail, p);//看对应表情况，映射
	}
	else//伙伴空闲
	{
		Delete(avail, pi);//从对应表中删除该内存单元

		p->tag = 0;
		if (p > pi)//让p每次都作为左块
		{
			p = pi;
		}
		p->kval++;//将p的k值++，用于判断合并后的伙伴
	}
}

void Free(FreeList& avail, Space p)//回收内存单元
{
	if (!IsEmpty(avail))
	{
		p->tag = 0;
		Space q = p;
		int k = p->kval;
		while (p->tag == 0 && p->kval == k)//当内存块空闲，且是完整的，进行合并
		{
			Free_mask(avail, p);
			k++;
		}
		if (p->kval == M - 1)//当合并后的大小为内存池的一一半时
		{
			q->kval--;

			avail[q->kval].first = NULL;
			q = q - (int)pow(2, q->kval);
			avail[M].first = q;
			q->llink = q;
			q->rlink = q;
			q->kval = M;
			q->tag = 0;
		}
	}
	else//小于一半大小，直接映射顺序表
	{
		avail[p->kval].first = p;
		p->tag = 0;
	}

}