内存管理三

最新推荐文章于 2024-05-09 18:10:33 发布
最新推荐文章于 2024-05-09 18:10:33 发布
阅读量1.6k 收藏 2
点赞数
分类专栏： C++ C++充电站 文章标签： table null allocation system 算法 insert

    假设系统的可利用内存空间容量为2m个字(地址从0到2m-1)，则在开始运行时，整个内存区是一个大小为2m的空闲块，在运行了一段时间之后，被分隔成若干占用块和空闲块。为了在分配时查找方便起见，我们将所有大小相同的空闲块建于一张子表中。每个子表是一个双重链表，这样的链表可能有m+1个，将这m+1个表头指针用向量结构组织成一个表，这就是伙伴系统中的可利用空间表，如图所示：



分配算法： 

       当用户提出大小为n的内存请求时，首先在可利用表上寻找结点大小与n相匹配的子表，若此子表非空，则将子表中任意一个结点分配之即可；若此子表为空，则需从结点更大的非空子表中去查找，直至找到一个空闲块，则将其中一部分分配给用户，而将剩余部分插入相应的子表中。
       若2k-1 < n ≤ 2k-1，又第k+1个子表不空，则只要删除此链表中第一个结点并分配给用户即可；若 2k-2 < n ≤ 2k-1-1，此时由于结点大小为2k-1 的子表为空，则需从结点大小为2k 的子表中取出一块，将其中一半分配给用户，剩余的一半作为一个新结点插入在结点大小为2k-1的子表中，若2k-i-1 < n ≤ 2k-i-1(i为小于是的整数)，并且所有结点小于2k的子表均为空，则同样需从结点大小为2k的子表中取出一块，将其中2k-i的一小部分分配给用户，剩余部分分割成若干个结点分别插入在结点大小为2k-1 、 2k-2、…、 2k-i的子表中。

回收算法：

        在用户释放不再使用的占用块时，系统需将这新的空闲块插入到可利用空间表中去。这里，同样有一个地址相邻的空闲块归并成大块的问题。但是在伙伴系统中仅考虑互为“伙伴”的两个空闲块的归并。
        何谓“伙伴”?如前所述，在分配时经常需要将一个大的空闲块分裂成两个大小相等的存储区，这两个由同一大块分裂出来的小块就称之“互为伙伴”。例如：假设p为大小为pow(2,k)的空闲块的初始地址，且p MOD pow(2,k+1)=0，则初始地址为p和p+pow(2,k)的两个空闲块互为伙伴。在伙伴系统中回收空闲块时，只当其伙伴为空闲块时才归并成大块。也就是说，若有两个空闲块，即使大小相同且地址相邻，但不是由同一大块分裂出来的，也不归并在一起。
        由此，在回收空闲块时，应首先判别其伙伴是否为空闲块，若否，则只要将释放的空闲块简单插入在相应子表中即可；若是，则需在相应子表中找到其伙伴并删除之，然后再判别合并后的空闲块的伙伴是否是空闲块。依此重复，直到归并所得空闲块的伙伴不是空闲块时，再插入到相应的子表中去。


代码如下（只用了单链表）：

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define MIN_MOMORY_SIZE 536870912   //随机产生的最小内存空间：512M （最大为1G） 
#define INDEX_SIZE 30               //哈希索引表大小 
#define WORKTIME 1500               //系统工作时间 
#define MAX_REQ_SIZE 268435456      //申请空闲内存分配的最大容量：256M 
#define MIN_DUE 30                  //使用内存块的最短时间
#define MAX_DUE 90                  //使用内存块的最长时间
#define OCCUPY_INTERVAL 60          //每次分配的最大间隔 
#define USED 1                      //内存块被使用 
#define UNUSED 0                    //内存块未被使用

//内存块链表结点结构 
typedef struct buddy_node {
	int flag;                       //标记空间是否被使用
	int base;                       //本块儿内存的基地址 
	int occupy;                     //实际使用空间大小 
	int fragment;                   //碎片大小 
	int duetime;                    //使用时间
	struct buddy_node *nextPtr;     //指向下一个结点 
} Buddy, *BuddyPtr;

//哈希索引表结构 
typedef struct hash_table {
	int nodesize;
	BuddyPtr headPtr;
} IndexTable;

IndexTable table[INDEX_SIZE];//使用哈希表管理伙伴系统 
int ready = 0;               //需要分配内存的时刻 
int availSpace;              //可分配空间大小 
int totalFragment = 0;       //总碎片大小 

//函数：根据k的值计算哈希表项链接的内存块的大小
int get_size (int k)
{
    int i, nodesize = 1;
    
    for (i = 0; i < k; i ++)
        nodesize *= 2;

    return nodesize;
}

//函数：初始化哈希索引表 
void ini_index (void)
{
    int i;
    
    for (i = 0; i < INDEX_SIZE; i ++) {
        table[i].nodesize = get_size(i);
        table[i].headPtr = NULL;
    } 
}

//函数：初始化伙伴系统
void int_system (int memory_size)
{
    int i, addr = 0;
    int left = memory_size;
    BuddyPtr newnodePtr = NULL;
     
    //初始化可分配空间大小和碎片大小 
    availSpace = memory_size; 
    totalFragment = 0;
    
	//将内存分割成尽量大的2倍数的空闲块并插入到相应的索引表项中
	for (i = INDEX_SIZE-1; left > 0; i --) {
		if (left / table[i].nodesize == 1) {
            newnodePtr = (BuddyPtr) malloc (sizeof (Buddy));//分配结点 
            newnodePtr->flag = UNUSED;
            newnodePtr->base = addr;
            newnodePtr->occupy = 0; 
            newnodePtr->fragment = 0;
            newnodePtr->duetime = 0;
            newnodePtr->nextPtr = NULL;
            table[i].headPtr = newnodePtr;
            addr += table[i].nodesize;
            left -= table[i].nodesize;
        }
    } 
}

//函数：程序运行结束后释放所有结点
void free_system (void)
{
    int i;
    BuddyPtr tempPtr = NULL, tofreePtr = NULL;
     
    for (i = 0; i < INDEX_SIZE; i ++) {
        if (table[i].headPtr) {
            tempPtr = table[i].headPtr;
            table[i].headPtr = NULL;
            //依次释放所有结点
            while (tempPtr) {
                tofreePtr = tempPtr;
                tempPtr = tempPtr->nextPtr;
                free (tofreePtr);
            }
        }
    }
}

//函数：添加结点（形参为内存块结点的信息） 
void insert_node (int i, int inbase, int f, int occ, int frag, int d)
{
    BuddyPtr newnodePtr = NULL, prePtr = NULL, curPtr = NULL;
    
    newnodePtr = (BuddyPtr) malloc (sizeof (Buddy));//分配结点
    newnodePtr->base = inbase;
    newnodePtr->flag = f;
    newnodePtr->occupy = occ; 
    newnodePtr->fragment = frag;
    newnodePtr->duetime = d;
    newnodePtr->nextPtr = NULL; 
    if (table[i].headPtr == NULL)
        table[i].headPtr = newnodePtr;
    else {
        curPtr = table[i].headPtr;
        prePtr = NULL;
        //按地址顺序插入内存块 
        while (curPtr && curPtr->base < inbase) {
            prePtr = curPtr;
            curPtr = curPtr->nextPtr;  
        }
        if (prePtr == NULL) {          //插在最前 
            newnodePtr->nextPtr = curPtr;
            table[i].headPtr = newnodePtr;
        }
        else if (curPtr == NULL) {     //插在最后 
            prePtr->nextPtr = newnodePtr;
        }
        else {                         //插在中间 
            prePtr->nextPtr = newnodePtr;
            newnodePtr->nextPtr = curPtr;
        } 
    }
}

//函数：删除结点
int delete_node (int i, BuddyPtr delPtr)
{
    BuddyPtr prePtr = NULL, curPtr = NULL;
    int basehold = delPtr->base;
    
    curPtr = table[i].headPtr;
    while (curPtr != delPtr) {  //寻找要删除的结点的位置 
        prePtr = curPtr;
        curPtr = curPtr->nextPtr;  
    }
    if (prePtr == NULL)         //要删除的结点在最前 
        table[i].headPtr = curPtr->nextPtr;
    else                        //要删除的结点不在链表的最前 
        prePtr->nextPtr = curPtr->nextPtr;

    free (curPtr);              //释放结点 
    
    return basehold;            //返回删除的内存块结点的基地址 
} 

//函数：伙伴系统的分配算法 
void buddy_allocate (int time_slice)
{
    int i, j, size, due;
    int state = 0;              //分配状态：0为未分配，1为已分配 
    int inbase, basehold;
    BuddyPtr curPtr = NULL;
    
    if (ready == time_slice) {  //到达分配内存的时刻 
        printf ("Time %d:", time_slice);
        size = 1 + rand () % MAX_REQ_SIZE;            //申请使用内存的大小 
        due = MIN_DUE + rand ()%(MAX_DUE - MIN_DUE);  //申请使用内存的时间
        
        if (availSpace > size) {//在可分配空间大于申请空间时分配
            //依次寻找可分配的内存块 
            for (i = 0; (i < INDEX_SIZE) && (state == 0); i ++) {
                //找到一个不小于申请大小的块索引
                if (table[i].nodesize >= size && table[i].headPtr) {
                    curPtr = table[i].headPtr;
                    //遍历相应的循环链表中 
                    while (curPtr && (state == 0)) {
                        //找到空闲块
                        if (curPtr->flag == UNUSED) {
                            //空闲块的大小小于申请大小的2倍，分配 
                            if (table[i].nodesize / size == 1) {
                                //在分配的内存块上设置信息 
                                curPtr->flag = USED;
                                curPtr->occupy = size;
                                curPtr->fragment = table[i].nodesize - size;
                                curPtr->duetime = due + ready;
                                //修改可系统分配空间和碎片大小 
                                availSpace -= table[i].nodesize;
                                totalFragment += curPtr->fragment;
                                state = 1;//标记已分配 
                                break;
                            }
                            //空闲块的大小刚大于申请大小的2倍
                            else {
                                basehold = delete_node (i, curPtr);//删除较大的空闲块并保留其基地址 
                                inbase = basehold + table[i].nodesize;
                                j = i;
                                //分割空闲块 
                                do {
                                    j --;
                                    inbase -= table[j].nodesize;   //设置要添加内存块结点的基地址 
                                    insert_node (j, inbase, UNUSED, 0, 0, 0);//添加较小的空闲块 
                                    printf ("A block cut takes place\n");
                                } while (table[j].nodesize / size > 1);
                                //分配 
                                insert_node (j, basehold, USED, size, table[j].nodesize - size, due + ready);
                                //修改可系统分配空间和碎片大小 
                                availSpace -= table[j].nodesize;
                                totalFragment += table[j].nodesize - size;
                                state = 1;//标记已分配 
                            }
                        }
                        //块被占用，查看下一结点 
                        else
                            curPtr = curPtr->nextPtr;
                    }
                }            
            }
            printf ("Allocated %d,Fragment %d,Due %d\n", size, totalFragment, ready+due);
        }
            
        else if ((availSpace < size) && ((availSpace + totalFragment) >= size))
            printf ("Allocation failed because of fragment!\n");
        else
            printf ("Allocation failed because of no enough unused space!\n");
            
        ready += (1 + rand() % OCCUPY_INTERVAL);  //下次需要分配内存的时刻
    }
}

//函数：伙伴系统的回收算法
void buddy_retrieve (int time_slice)
{
    int i, basehold, dif;
    int f = 0;
	int Modnext=0;
    BuddyPtr curPtr = NULL, todelPtr = NULL; 
    
    //依次查找，并回收需要回收的块 
    for (i = 0; i < INDEX_SIZE; i ++) {
        if (table[i].headPtr) {
            curPtr = table[i].headPtr;
            while (curPtr) {
                if ((curPtr->flag == USED) && (curPtr->duetime == time_slice)) {//需要回收 
                    //修改可系统分配空间和碎片大小 
                    availSpace += table[i].nodesize;
                    totalFragment -= curPtr->fragment;
                    //回收为空闲块 
                    curPtr->flag = UNUSED;
                    curPtr->occupy = 0; 
                    curPtr->fragment = 0;
                    curPtr->duetime = 0;
                    printf ("Time %d:Retrieve %d,Fragment %d\n", time_slice, table[i].nodesize, totalFragment);
                }
                curPtr = curPtr->nextPtr;
            }
        }
    }
    
    //合并空闲块
    for (i = 0; i < INDEX_SIZE; i ++) {
        if (table[i].headPtr) {            
            curPtr = table[i].headPtr;
            while (curPtr && curPtr->nextPtr) {
                //将地址连续且都为空闲的块合并后加入下一级的链表中 
                if (curPtr->flag == UNUSED && (curPtr->nextPtr)->flag == UNUSED) {
                    dif = (curPtr->nextPtr)->base - curPtr->base;
					Modnext = ((int)(curPtr->nextPtr->base))%(2*table[i].nodesize);
                    if ((dif == table[i].nodesize)&&(Modnext==0)) {
                        //删除两个结点 
                        todelPtr = curPtr;
                        curPtr = curPtr->nextPtr;
                        basehold = delete_node (i, todelPtr);
                        todelPtr = curPtr;
                        curPtr = curPtr->nextPtr;
                        delete_node (i, todelPtr);
                        insert_node (i+1, basehold, UNUSED, 0, 0, 0);//添加合并后的结点 
                        printf ("Two blocks merge\n");
                    }
                    else
                        curPtr = curPtr->nextPtr;
                }
                else
                    curPtr = curPtr->nextPtr;
            }
        }
    }
}

//函数：伙伴系统的处理过程 
void buddy_system (void)
{
    int time_slice = 0;
    
    //在每个时间片内使用分配算法和回收算法 
    for (; time_slice < WORKTIME; time_slice ++) {
        buddy_allocate (time_slice);         //分配算法 
        buddy_retrieve (time_slice);         //回收算法 
    }
}


int main(int argc, char *argv[])
{
    int memory_size;
    
    ini_index ();               //初始化哈希索引表 
    srand (time (NULL));        //设置随机数种子
    //随机产生需要管理的内存大小：512M ~ 1G 
    memory_size = MIN_MOMORY_SIZE + rand() % MIN_MOMORY_SIZE; 
    printf ("The size of memory is:%d\n", memory_size);
    
    int_system (memory_size);   //初始化伙伴系统 
    
    buddy_system ();            //伙伴系统的处理过程
    printf ("Time %d:System execution stops and the spaces are all freed.\n", WORKTIME);
    
    free_system ();             //释放所有结点 
    
    return 0;
}


Study_more
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
伙伴系统算法
云（存储），松（耦合）
01-22 1万+
讲了这么多了，很多人肯定会一头雾水，前边提到的都是些数据结构或者是些概念性的东西，真正对动态页面的管理机制在哪里？换句话说，如何将每个节点，每个区中的页框分配给进程？要理清这个思路，我们首先必须学习一种算法 —— 伙伴系统算法。 内核要分配一组连续的页框，必须建立一种健壮、高效的分配策略。为此，必须解决著名的外部碎片（external fragmentation）问题。频繁地请求和释放不同
初窥内存管理（三）伙伴算法
热门推荐
crazy_sparrow的专栏
04-10 1万+
假设系统的可利用内存空间容量为2m个字(地址从0到2m-1)，则在开始运行时，整个内存区是一个大小为2m的空闲块，在运行了一段时间之后，被分隔成若干占用块和空闲块。为了在分配时查找方便起见，我们将所有大小相同的空闲块建于一张子表中。每个子表是一个双重链表，这样的链表可能有m+1个，将这m+1个表头指针用向量结构组织成一个表，这就是伙伴系统中的可利用空间表，如图所示： 分配算法
伙伴算法的核心思想是回收时进行相邻块的合并_伙伴系统管理动态内存
weixin_39679664的博客
11-17 664
前面介绍了系统在分配与回收存储空间时采取的边界标识法。本节再介绍一种管理存储空间的方法——伙伴系统。伙伴系统本身是一种动态管理内存的方法，和边界标识法的区别是：使用伙伴系统管理的存储空间，无论是空闲块还是占用块，大小都是 2 的 n 次幂(n 为正整数)。例如，系统中整个存储空间为 2m个字。那么在进行若干次分配与回收后，可利用空间表中只可能包含空间大小为：20、21、22、…、2m...
伙伴（buddy）算法及位图
Unique-You的博客
05-05 1万+
伙伴(buddy)算法，它不能根据需要从被管理内存的开头部分创建新内存。它有明确的共性，就是各个内存块可分可合，但不是任意的分与合。每个块都有个朋友，或叫“伙伴”，既可与之分开，又可与之结合。伙伴分配程序把内存块存放在比链接表更先进的数据结构中。这些结构常常是桶型、树型和堆型的组合或变种。一般来说，伙伴分配程序的工作方式是难以描述的，因为这种技术随所选数据结构的不同而各异。由于有各种各样的具有已知...
8.4 伙伴系统分配与回收
lseaJK的博客
09-05 935
8.4 伙伴系统可利用空间表的结构分配算法 可利用空间表的结构 #define m 16 typedef struct WORD_b{ WORD_b *llink; int tag; int kval;//块大小，值为2的幂次k WORD_b *rlink; OtherType other; }WORD_b,head;//WORD内存字类型，结点的第一个字也称为head typedef struct HeadNode{ int nodesize;//链表的的
JVM自动内存管理机制
02-25
Java自动内存管理机制包含两部分：内存分配和内存回收，要想理解内存分配和回收的机制，则需要了解下Java内存区域（Java运行时数据区），这篇随笔将按照下面的线索进行逐步解析：1.Java运行时数据区2.对象“已死”的...
操作系统内存管理实验（C语言实现）
02-02
操作系统内存管理实验（C语言实现）
python高级内存管理
01-20
1. Python⾼级内存管理 - xiaorui.cc 2. Object-specific allocators _____ ______ ______ ________ [ int ] [ dict ] [ list ] ... [ string ] Python core | +3 | | | _______________________________ | | [ ...
实验3内存管理空闲分区表
06-21
实验3内存管理空闲分区表
Linux内核内存相关问题，这一篇让你彻底了解
嵌入式Linux内核的博客
02-25 697
直接内存访问是一种硬件机制，它允许外围设备和主内存之间直接传输它们的 I/O 数据，而不需要系统处理器的参与2) DMA 控制器的功能能向 CPU 发出系统保持（HOLD）信号，提出总线接管请求当 CPU 发出允许接管信号后，负责对总线的控制，进入 DMA 方式能对存储器寻址及能修改地址指针，实现对内存的读写操作能决定本次 DMA 传送的字节数，判断 DMA 传送是否结束发出 DMA 结束信号，使 CPU 恢复正常工作状态。
操作系统伙伴系统算法
04-21
操作系统伙伴系统算法。使用单恋表模拟。虚拟内存的分配和回收
主存空间的分配与回收（伙伴算法）
04-08
主存空间的分配与回收（伙伴算法） 用c语言写的 大家看看
linux内核工程师 3.03节 Linux伙伴系统(一)--伙伴系统的概述
zjy900507的博客
06-13 358
水平有限，描述不当之处还请指出，转载请注明出处http://blog.csdn.net/vanbreaker/article/details/7605367 伙伴系统的概述        Linux内核内存管理的一项重要工作就是如何在频繁申请释放内存的情况下，避免碎片的产生。Linux采用伙伴系统解决外部碎片的问题，采用slab解决内部碎片的问题，在这里我们先讨论外部碎片问题。避免外部碎片的方法有...
采用伙伴系统算法编写内存分配和回收模拟程序
u014071802的专栏
06-14 5291
一、需求分析 动态分区和固定分区的方案都有缺陷，固定分区方案限定了活动进程的数目，并且如果可用分区的大小与进程大小非常不匹配则内存空间的利用率非常低。而动态分区的维护十分的复杂，并且引入了进行压缩的额外开销。伙伴系统作为一种折中的方案，能够克服固定分区和可变分区系统的缺陷，在并行系统中有广泛的应用。基于伙伴系统的优秀特点，本次综合实验将实现伙伴系统的典型功能。
内存管理——伙伴系统算法
Jason_Linux
02-05 601
通常情况下，一个高级操作系统必须要给进程提供基本的、能够在任意时刻申请和释放任意大小内存的功能，就像malloc 函数那样，然而，实现malloc 函数并不简单，由于进程申请内存的大小是任意的，如果操作系统对malloc 函数的实现方法不对，将直接导致一个不可避免的问题，那就是内存碎片。 内存碎片就是内存被分割成很小很小的一些块，这些块虽然是空闲的，但是却小到无法使用。随着申请和释放次数的增加，内...
Linux内存分配与回收——伙伴算法
Reticent_Man的博客
04-15 3907
在Linux系统中，内存的分配与回收速率直接影响系统的存取效率。当内核频繁请求和释放不同大小的一组连续页框时，会导致许多外部空闲碎片，造成空间的浪费。使用伙伴算法可以有效地缓解该问题。伙伴关系机制是操作系统中的一种动态存储管理算法。在进行内存分配时，该算法通过不断平分较大的空闲内存块来获得较小的空闲内存块，直到获得所需要的内存块；在进行内存回收时，该算法尽可能地合并空闲块。
伙伴系统算法详解
UmdCoding的博客
10-06 2188
参考 http://www.voidcn.com/blog/EmbedStudio/article/p-3848869.html 看一下这篇blog下面的碎片解决问题的链接
[Easy] leetcode-35 搜索插入位置
最新发布
Sofine
05-09 118
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。利用二分查找可以更快的找到，只需要修改返回值即可，注意获取mid的计算方法考虑了溢出。注意到是按顺序排列的数组，那么按顺序遍历，如果找到，则跳出循环返回索引即可。如果找到最后还没找到，则返回数组长度索引值即为插入位置。
Linux 内存管理
12-09
Linux 内存管理主要包括内存节点、分区、页框和虚拟内存等概念。 1. 内存节点 Linux 根据 CPU 访问代价的不同将内存划分为不同的分区，即内存节点。内核以 struct zone 来描述内存分区。通常一个节点分为 DMA、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值