C语言操作系统实战:动态分区分配方式

最新推荐文章于 2024-08-24 20:17:20 发布
最新推荐文章于 2024-08-24 20:17:20 发布
阅读量1.5k 收藏 23
点赞数 5
文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62169881/article/details/131925093
版权
文章详细介绍了动态分区分配中的首次适应和最佳适应算法，提供了这两种算法的C语言实现，并通过一个具体的请求序列展示了内存分配和回收的过程。首次适应算法从低地址开始寻找，可能导致大空间被小进程占用；最佳适应算法则寻找最小的空闲分区，可能导致大量碎片。文章还给出了每种算法执行后的空闲分区链状态。
摘要由CSDN通过智能技术生成

问题描述：

了解动态分区分配方式中使用的数据结构和分配算法，并进一步加深对动态分区存储管理方式机器实现过程的理解。

  1. 用高级语言实现采用首次适应算法和最佳适应算法的动态分区分配过程alloc( )和回收过程free( )。其中，空闲分区通过空闲分区链来管理；在进行内存分配时，系统优先使用空闲区低端的空间。
  2. 假设初始状态下可用内存空间为640KB，并有下列的请求序列：
  1. 作业1申请130KB
  2. 作业2申请60KB
  3. 作业3申请100KB
  4. 作业2释放60KB
  5. 作业4申请200KB
  6. 作业3释放100KB
  7. 作业1释放130KB
  8. 作业5申请140KB
  9. 作业6申请60KB
  10. 作业7申请50KB
  11. 作业6释放60KB

请分别采用首次适应算法和最佳适应算法进行内存块的分配和回收，要求每次分配和回收后显示出空闲分区链的情况。

问题分析：

首次适应算法：每次都从低地址开始查找，找到第一个满足大小的空闲分区。
实现方式：

空闲分区以地址递增的顺序（这里并不是地址空间的大小）的次序排列。每次分配内存时顺序查找空闲分区链（或是空闲分区表），找到空间大小能满足要求的第一个空闲分区。

可能产生的问题：

由于匹配的地址空间大小为第一个满足要求的地址空间，这就会导致大的地址空间被小进程占据，使得大进程到来时没有满足要求的地址空间，发生系统中断。

图形解释：

                                                                图1.首次适应性算法

 代码：
// 首次适应算法分配内存
void* firstFitAlloc(int size) {
    MemoryBlock* currentBlock = freeList;
    
    while (currentBlock != NULL) {
        if (currentBlock->isFree && currentBlock->size >= size) {
            // 找到合适的空闲分区
            currentBlock->isFree = 0;
            
            if (currentBlock->size > size) {
                // 分割分区
                MemoryBlock* newBlock = (MemoryBlock*)malloc(sizeof(MemoryBlock));
                newBlock->startAddress = currentBlock->startAddress + size;
                newBlock->size = currentBlock->size - size;
                newBlock->isFree = 1;
                newBlock->next = currentBlock->next;
                
                currentBlock->size = size;
                currentBlock->next = newBlock;
            }
            
            return (void*)(currentBlock->startAddress);
        }
        
        currentBlock = currentBlock->next;
    }
    
    // 没有可用的空闲分区
    return NULL;
}
最佳适应性算法：每次从小的地址空间开始查找，找到第一个满足大小的空闲分区。
实现方法：

空闲分区按地址空间大小递增次序排列，每次分配时按顺序查找相关满足要求的地址空间即可。即可以找到尽可能小的但是满足要求的空闲分区。

可能出现的问题：

由于每次匹配的尽可能小的且满足地址空间要求的，就会导致地址空间可能会被切割成很多过小的地址空间碎片而无法被利用。

图形解释：

 代码：
// 最佳适应算法分配内存
void* bestFitAlloc(int size) {
    MemoryBlock* bestBlock = NULL;
    MemoryBlock* currentBlock = freeList;
    
    while (currentBlock != NULL) {
        if (currentBlock->isFree && currentBlock->size >= size) {
            if (bestBlock == NULL || currentBlock->size < bestBlock->size) {
                // 更新最佳分区
                bestBlock = currentBlock;
            }
        }
        
        currentBlock = currentBlock->next;
    }
    
    if (bestBlock != NULL) {
        bestBlock->isFree = 0;
        
        if (bestBlock->size > size) {
            // 分割分区
            MemoryBlock* newBlock = (MemoryBlock*)malloc(sizeof(MemoryBlock));
            newBlock->startAddress = bestBlock->startAddress + size;
            newBlock->size = bestBlock->size - size;
            newBlock->isFree = 1;
            newBlock->next = bestBlock->next;
            
            bestBlock->size = size;
            bestBlock->next = newBlock;
        }
        
        return (void*)(bestBlock->startAddress);
    }
    
    // 没有可用的空闲分区
    return NULL;
}

完整代码：

#include <stdio.h>
#include <stdlib.h>
// 定义内存块结构
typedef struct MemoryBlock {
    int startAddress;
    int size;
    int isFree;
    struct MemoryBlock* next;
} MemoryBlock;

// 定义全局变量，表示内存大小和空闲分区链表头节点
int memorySize;
MemoryBlock* freeList;

// 初始化内存分区
void initializeMemory(int size) {
    memorySize = size;
    // 创建初始的空闲分区
    MemoryBlock* initialBlock = (MemoryBlock*)malloc(sizeof(MemoryBlock));
    initialBlock->startAddress = 0;
    initialBlock->size = size;
    initialBlock->isFree = 1;
    initialBlock->next = NULL;
    freeList = initialBlock;
}
// 首次适应算法分配内存
void* firstFitAlloc(int size) {
    MemoryBlock* currentBlock = freeList;
    
    while (currentBlock != NULL) {
        if (currentBlock->isFree && currentBlock->size >= size) {
            // 找到合适的空闲分区
            currentBlock->isFree = 0;
            
            if (currentBlock->size > size) {
                // 分割分区
                MemoryBlock* newBlock = (MemoryBlock*)malloc(sizeof(MemoryBlock));
                newBlock->startAddress = currentBlock->startAddress + size;
                newBlock->size = currentBlock->size - size;
                newBlock->isFree = 1;
                newBlock->next = currentBlock->next;
                
                currentBlock->size = size;
                currentBlock->next = newBlock;
            }
            
            return (void*)(currentBlock->startAddress);
        }
        
        currentBlock = currentBlock->next;
    }
    
    // 没有可用的空闲分区
    return NULL;
}

// 最佳适应算法分配内存
void* bestFitAlloc(int size) {
    MemoryBlock* bestBlock = NULL;
    MemoryBlock* currentBlock = freeList;
    
    while (currentBlock != NULL) {
        if (currentBlock->isFree && currentBlock->size >= size) {
            if (bestBlock == NULL || currentBlock->size < bestBlock->size) {
                // 更新最佳分区
                bestBlock = currentBlock;
            }
        }
        
        currentBlock = currentBlock->next;
    }
    
    if (bestBlock != NULL) {
        bestBlock->isFree = 0;
        
        if (bestBlock->size > size) {
            // 分割分区
            MemoryBlock* newBlock = (MemoryBlock*)malloc(sizeof(MemoryBlock));
            newBlock->startAddress = bestBlock->startAddress + size;
            newBlock->size = bestBlock->size - size;
            newBlock->isFree = 1;
            newBlock->next = bestBlock->next;
            
            bestBlock->size = size;
            bestBlock->next = newBlock;
        }
        
        return (void*)(bestBlock->startAddress);
    }
    
    // 没有可用的空闲分区
    return NULL;
}

// 释放内存
void freeMemory(void* address) {
    MemoryBlock* currentBlock = freeList;
    MemoryBlock* previousBlock = NULL;
    
    while (currentBlock != NULL) {
        if (currentBlock->startAddress == (int)address) {
            // 找到对应的分区
            currentBlock->isFree = 1;
            
            // 合并相邻的空闲分区
            if (previousBlock != NULL && previousBlock->isFree) {
                previousBlock->size += currentBlock->size;
                previousBlock->next = currentBlock->next;
                free(currentBlock);
                currentBlock = previousBlock;
            }
            
            if (currentBlock->next != NULL && currentBlock->next->isFree) {
                currentBlock->size += currentBlock->next->size;
                MemoryBlock* temp = currentBlock->next;
                currentBlock->next = currentBlock->next->next;
                free(temp);
            }
            
            return;
        }
        
        previousBlock = currentBlock;
        currentBlock = currentBlock->next;
    }
}

// 打印空闲分区链表
void printFreeList() {
    MemoryBlock* currentBlock = freeList;
    
    char is_free[100]={};
    int i=0;
	while (currentBlock !=NULL){
    	if (currentBlock->isFree==0){
    		is_free[i]='N';
    		i++;
    	}
    	else{
    		is_free[i]='Y';
    		i++;
    	}
    	currentBlock=currentBlock->next;
    } 
    currentBlock=freeList;
    i=0;
    while (currentBlock != NULL) {
        printf("地址: %d, 空间大小: %d, 是否空闲: %c\n", currentBlock->startAddress, currentBlock->size, is_free[i]);
        i++;
		currentBlock = currentBlock->next;
    }
    
    printf("\n");
}

int main() {
    initializeMemory(640);  // 初始化内存大小为640KB
    
    printf("初始状态下的空闲分区链情况：\n");
    printFreeList();
    
    
    // 请求序列    首次适应算法 
    ///*
	printf("\n\n---------------最先适应算法---------------\n\n"); 
    void* address1 = firstFitAlloc(130);
    printf("作业1申请130KB后的空闲分区链情况：\n");
    printFreeList();
    
    void* address2 = firstFitAlloc(60);
    printf("作业2申请60KB后的空闲分区链情况：\n");
    printFreeList();
    
    void* address3 = firstFitAlloc(100);
    printf("作业3申请100KB后的空闲分区链情况：\n");
    printFreeList();
    
    freeMemory(address2);
    printf("作业2释放60KB后的空闲分区链情况：\n");
    printFreeList();
    
    void* address4 = firstFitAlloc(200);
    printf("作业4申请200KB后的空闲分区链情况：\n");
    printFreeList();
    
    freeMemory(address3);
    printf("作业3释放100KB后的空闲分区链情况：\n");
    printFreeList();
    
    freeMemory(address1);
    printf("作业1释放130KB后的空闲分区链情况：\n");
    printFreeList();
    
    void* address5 = firstFitAlloc(140);
    printf("作业5申请140KB后的空闲分区链情况：\n");
    printFreeList();
    
    void* address6 = firstFitAlloc(60);
    printf("作业6申请60KB后的空闲分区链情况：\n");
    printFreeList();
    
    void* address7 = firstFitAlloc(50);
    printf("作业7申请50KB后的空闲分区链情况：\n");
    printFreeList();
    
    freeMemory(address6);
    printf("作业6释放60KB后的空闲分区链情况：\n");
    printFreeList();
	//*/

	//请求序列    最佳适应算法 
	/*printf("\n\n---------------最佳适应算法---------------\n\n"); 
	void* address1 = bestFitAlloc(130);
    printf("作业1申请130KB后的空闲分区链情况：\n");
    printFreeList();
    
    void* address2 =bestFitAlloc(60);
    printf("作业2申请60KB后的空闲分区链情况：\n");
    printFreeList();
    
    void* address3 =bestFitAlloc(100);
    printf("作业3申请100KB后的空闲分区链情况：\n");
    printFreeList();
    
    freeMemory(address2);
    printf("作业2释放60KB后的空闲分区链情况：\n");
    printFreeList();
    
    void* address4 = bestFitAlloc(200);
    printf("作业4申请200KB后的空闲分区链情况：\n");
    printFreeList();
    
    freeMemory(address3);
    printf("作业3释放100KB后的空闲分区链情况：\n");
    printFreeList();
    
    freeMemory(address1);
    printf("作业1释放130KB后的空闲分区链情况：\n");
    printFreeList();
    
    void* address5 = bestFitAlloc(140);
    printf("作业5申请140KB后的空闲分区链情况：\n");
    printFreeList();
    
    void* address6 = bestFitAlloc(60);
    printf("作业6申请60KB后的空闲分区链情况：\n");
    printFreeList();
    
    void* address7 = bestFitAlloc(50);
    printf("作业7申请50KB后的空闲分区链情况：\n");
    printFreeList();
    
    freeMemory(address6);
    printf("作业6释放60KB后的空闲分区链情况：\n");
    printFreeList();     
    */
    return 0;
}

运行结果：

首次适应算法

 

 最佳适应算法

 

 

 

 声明：

图片来源于：3.1_5_动态分区分配算法_哔哩哔哩_bilibili

一口气吃成胖子
关注
实验四__动态分区分配方式的模拟_答案
03-20
用C语言或C++语言分别实现采用首次适应算法和最佳适应算法的动态分区分配过程alloc()和回收过程free()。其中，空闲分区通过空闲分区链表来管理，在进行内存分配时，系统优先使用空闲区低端空间。
【操作系统实验】使用动态分区分配方式的模拟（c++实现）
mysql_67的博客
11-21 3788
目录实验目的实验内容代码运行结果思考 实验目的 了解动态分区分配方式中使用的数据结构和分配算法，并进一步加深对动态分区存储管理方式及其实现过程的理解。 实验内容 （1）用C语言分别实现采用首次适应算法和最佳适应算法的动态分区分配过程alloc( )和回收过程free( )。其中，空闲分区通过空闲分区链来管理：在进行内存分配时，系统优先使用空闲区低端的空间。 （2）假设初始状态下，可用的内存空间为640KB，并有下列的请求序列： 作业1申请130KB。 作业2申请60KB。 作业3申请100KB。 作业2释
3.1 内存管理
最新发布
2305_80863038的博客
08-24 813
1.2 非连续分配管理方式非连续分配：为用户进程分配的可以是一些分散的内存空间。
操作系统 实验七 动态分区分配方式的模拟
weixin_46698891的博客
05-27 6482
实验七 动态分区分配方式的模拟 一、实验目的 了解动态分区分配方式中使用的数据结构和分配算法，并进一步加深对动态分区存储管理方式及其实现过程的理解。 二、实验环境 硬件环境：计算机一台，局域网环境； 软件环境： Windows或Linux操作系统， C语言编程环境。 三、实验内容 用C语言分别实现采用首次适应算法和最佳适应算法的动态分区分配过程alloc( )和回收过程free( )。其中，空闲分区通过空闲分区链来管理：在进行内存分配时，系统优先使用空闲区低端的空间。 假设初始状态下
操作系统：首次适应算法和最佳适应算法（c语言实现）
热门推荐
sunrise的博客
12-10 3万+
1、要求： 用C语言分别实现采用首次适应算法和最佳适应算法的动态分区分配过程alloc()和回收过程free()。其中，空闲分区通过空闲分区链来管理：在进行内存分配时，系统优先使用空闲区低端的空间。 假设初始状态下，可用的内存空间为640KB，并有下列的请求序列：  •作业1申请130KB  •作业2申请60KB。  •作业3申请100KB  •作业2释放60KB。  •作业4申请200...
实验七 动态分区分配方式的模拟
Ace2NoU的博客
12-22 5892
一、实验目的 了解动态分区分配方式中使用的数据结构和分配算法，并进一步加深对动态分区存储管理方式及其实现过程的理解。 二、实验环境 硬件环境：计算机一台，局域网环境； 软件环境：Windows或Linux操作系统， C语言编程环境。 三、实验内容 1、用C语言分别实现采用首次适应算法和最佳适应算法的动态分区分配过程alloc( )和回收过程free( )。其中，空闲分区通过空闲分区链来管理：在进行内存分配时，系统优先使用空闲区低端的空间。 2、假设初始状态下，可用的内存空间为640KB，.
动态分区分配方式模拟（c语言）
11-13
用C 语言实现对采用首次适应算法和最佳适应算法的动态分区分配过程ALLOC（）和回收过程FREE（），其中空闲分区由空闲分区链来管理，进行分配时，系统优先使用空闲区底端空间。
操作系统动态分区分配方式C/C++语言（首次适应算法（FF）循环首次适应算法（NF）最best适应算法（BF）最坏适应算法（WF））
weixin_48560325的博客
12-06 1万+
算法介绍 一、动态分区分配算法 为把一个新作业装入内存，须按照一定的分配算法， 从空闲分区表或空闲分区链中出一分区分配给该作业。由于内存分配算法对系统性能有很大的影响，故人们对它进行了较为广泛而深入的研究，于是产生了许多动态分区分配算法。传统的四种分配算法，它们都属于顺序式搜索算法。 二、分区分配操作 在动态分区存储管理方式中，主要的操作是分配内存和回收内存。 1)分配内存 系统应利用某种分配算法，从空闲分区链(表)中找到所需大小的分区。设请求的分区大小为u.size,表中每个空闲分区的大小可表示为m.si
动态分区分配
12-29
用C语言分别实现采用首次适应算法和最佳适应算法的动态分区分配过程alloc()和回收过程free()。其中，空闲分区通过空闲分区链（表）来管理：在进行内存分配时，系统优先使用空闲区低端的空间。 （2）给出初始状态、可用内存空间、请求序列，分别采用首次适应算法和最佳适应算法进行内存块的分配和回收，要求每次分配和回后显示出空闲内存分区链的情况（共有多个空闲分区，每个空闲分区的大小分别为多大）
c语言中alloc作用,C语言内存分配 ：malloc()函数与alloc()函数
weixin_42513170的博客
05-16 3004
C语言跟内存分配方式(1)从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static变量。(2)在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。(3)从堆上分配，亦称动态内存分配。程序在运行的时候用malloc或...
首次适应算法 C语言实现
weixin_45761769的博客
12-02 1万+
广东工业大学 操作系统实验 用C语言实现采用首次适应算法的动态分区分配过程和回收过程。 其中，空闲分区通过空闲分区链（表）来管理；在进行内存分配时，系统优先使用空闲区低端的空间，要求每次分配和回收后显示出空闲内存分区链的情况。 #include <stdio.h> #include <stdlib.h> #include <stdbool.h> #define FREE 0 #define BUSY 1 #define Max_length 640 typedef s
操作系统-动态分区分配算法代码
05-20
实现对存储器动态分区分配算法的认识。掌握首次适应算法、循环适应算法、最坏适应算法、最佳适应算法的内存分配过程。掌握内存回收的策略。 1、首次适应算法（First Fit） 将空闲分区链以地址递增的顺序连接；在进行内存分配时，从链首开始顺序查找，直到找到一块分区的大小可以满足需求时，按照该作业的大小，从该分区中分配出内存，将剩下的空闲分区仍然链在空闲分区链中。 2、循环首次适应算法（Next Fit） 分配内存时不是从链首进行查找可以分配 内存的空闲分区，而是从上一次分配内存的空闲分区的下一个分区开始查找， 直到找到可以为该进程分配内存的空闲分区。 3、最佳适应算法（Best Fit) 将空闲分区链中的空闲分区按照空闲分区由小到大的顺序排序，从而形成空闲分区链。每次从链首进行查找合适的空闲分区为作业分配内存，这样每次找到的空闲分区是和作业大小最接近的，所谓“最佳”。 4、最坏适应算法（Worst Fit） 与最佳适应算法刚好相反，将空闲分区链的分区按照从大到小的顺序排序形成空闲分区链，每次查找时只要看第一个空闲分区是否满足即可。
【操作系统】-- 动态分区分配算法（首次适应算法FF、最佳适应算法BF、最坏适应算法WF、循环首次适应算法NF）
张修宇的博客
06-06 1万+
每次从低地址开始查找，找到第一个能满足大小的空闲分区。空闲分区以地址递增的次序排列，每次分配内存时顺序查找空闲分区链，找到大小能满足要求的第一个空闲分区。空闲分区表、空闲分区链优点：①为分配大的内存空间创造了条件②不需要重新排序，算法开销小缺点:①不断被划分，会留下许多难以利用的小分区，产生碎片。空闲分区表↑空闲分区链（按起始地址有小到大排序）↓由于动态分区分配是一种连续分配方式，为各进程分配的空间必须是连续的一整片区域，因此为了保证大进程到来时能有连续的大空间，可以尽可能的留下大空间，优先使用小空间。空闲
动态分区分配（C++实现）
mycocoo的博客
12-09 3611
#include <iostream> using namespace std; const int MaxNumber = 100; int FreePartition[MaxNumber];//空闲可用分区 int Partition[MaxNumber];//进程所需分区 int PartitionNum, ProcessNum; int n; //空闲分区个数 int m;//需要分配的进程个数 //首次适应算法 void FF() { //寻找大小能满足进程要求的分区 for (
操作系统之动态分区分配方式的模拟
gitfight
05-27 4392
目的和要求： 用C语言或C++语言分别实现采用首次适应算法和最佳适应算法的动态分区分配过程alloc()和回收过程free()。其中，空闲分区通过空闲分区链表来管理，在进行内存分配时，系统优先使用空闲区低端空间。 实验原理： 首次适应算法（First-fit）：当要分配内存空间时，就查表，在各空闲区中查找满足大小要求的可用块。只要找到第一个足以满足要球的空闲块就停止查找，并把它分配出去；如果该空闲...
操作系统简单动态分区分配算法(c++)
凛_Lin~~的博客
01-09 2826
操作系统基本动态内存分配算法,首次适应和最佳适应
基于C语言的动态分区分配算法实现
毕业作品网站
02-10 762
上一层是分配分区的函数 alloc()和回收分区的函数 free()。在实际的操作系统中，分配出去的内存记录在进程控制块中，为了加快内存的分配过程，动态分区最常采用的数据结构是空闲表或空闲链表，数据结构只记录未分配的内存分区。为了降低模拟程序的复杂度，本模拟将分配出去的和未分配出去的内存分区记录在同一个数据结构中，用一个标志表示是否已被分配。为使程序具有扩展性灵活性， 分区大小采用宏定义方式（ #define MEMORY_SIZE 640），可修改分区的大小，展示在不同分区大小下的分配情况。
操作系统动态分区分配方式的模拟实现（分配与回收）C++
qq_44765647的博客
06-28 1万+
编程模拟实现动态分区分配方式中内存的分配与回收。
实验三、动态分区方式的模拟
weixin_45788387的博客
12-19 3552
实验三、动态分区方式的模拟实验环境：实验时间：实验目的：实验目标：实验方法：1、构建内存分区的数据结构2、编写分配内存的方法3、编写FF、BF和WF算法4、编写内存回收算法5、模拟动态分配的运行情况实验结果：完整代码 在文章末尾有Java实现的完整代码，最主要的还是能够理解各种动态分配算法的核心 实验环境： Linux 平台 实验时间： 6 小时 实验目的： 1.掌握动态分区分配方式使用的数据结构和分配算法（首先/最佳/最坏适应分配算法）。 2.进一步加深对内存动态分区分配管理方式及其实现过程的理解。 实验
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值