基于索引搜索的动态分区分配算法

最新推荐文章于 2024-05-06 02:05:52 发布
最新推荐文章于 2024-05-06 02:05:52 发布
阅读量7.9k 收藏 15
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mortal5/article/details/82620037
版权
由于当一个系统很大时，系统内的内存分区可能会很多，相应的空闲分区链就可能很长，这时采用顺序搜索分区的方法可能会很慢。为了提高搜索空间的分区的速度，在中大型系统中往往会采用基于索引搜索的动态分区分配算法，比如我们所熟知的哈希算法、快速适应算法以及伙伴系统。1）哈希算法由于分类搜索算法和伙伴系统算法中，都是将空闲分区根据分区大小进行分类，对于每一类具有相同大小的空闲分区，单独设立一个空闲分区链...
摘要由CSDN通过智能技术生成

由于当一个系统很大时，系统内的内存分区可能会很多，相应的空闲分区链就可能很长，这时采用顺序搜索分区的方法可能会很慢。为了提高搜索空间的分区的速度，在中大型系统中往往会采用基于索引搜索的动态分区分配算法，比如我们所熟知的哈希算法、快速适应算法以及伙伴系统。

1）哈希算法

由于分类搜索算法和伙伴系统算法中，都是将空闲分区根据分区大小进行分类，对于每一类具有相同大小的空闲分区，单独设立一个空闲分区链表。在为进程分配空间时，需要在每一张管理索引表中查找到所需要的空间大小所对应的表项，从中得到对应的空间内分区链表表头指针，从而通过查找一个空闲分区。如果对空闲分区分类比较细，则相应索引表的表项也就较多，因此会显著的增加搜索索引表的表项的时间开销。

哈希算法就是利用哈希快速查找的优点，以及空闲分区在可利用空闲分区表中的分布规律，建立哈希函数，构造一张以空闲分区大小为关键字的哈希表，该表的每一个表项记录了一个对应的空闲分区链表表头指针。

当进行空闲分区分配时，根据所需要的空闲 分区大小，通过哈希函数计算，即得到在哈希表中的位置，从中得到相应的空闲分区链表，实现最佳分配策略。

2）快速适应算法（分类搜索法）

该算法就是将空闲分区根据容量大小进行分类，对于每一类具有相同容量的所有空闲分区，单独设立一个空闲分区链表，这样的系统中存在多个空闲分区链表。同时，在内存总设立一张管理索引表，其中的每一个索引表项对应了一种空闲分区类型，并记录了该类型空闲分区链表表头的指针。空闲分区的分类是根据进程常用的空间大小进行划分的。

该算法在搜索可分配的空闲分区时分为两步：第一步是根据进程的长度，从索引表中寻找到能容纳它的最

最低0.47元/天 解锁文章
昊说
关注
  • 1
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
基于顺序搜索和索引搜索的动态分区分配算法 总结
Ink_cherry的博客
06-21 7365
基于顺序搜索的动态分区分配算法 ####### 首次适应算法（FF） first fit 空闲分区排成一个链，从链首开始查找，知道找到一个大小能满足的要求的分区为止。 特点：优点：保留高地址大空间去，为大作业分配空间创造条件 缺点：低地址部分不断配分割，形成许多难以利用的空闲区碎片 ######### 循环首次适应NF     next fit 不是每次都是
动态分区分配算法
01-11
动态分区分配算法，里面包括首次适应算法，最佳适应算法哟，大家可以下载来看看呢
3.1 内存管理
最新发布
qq_52240295的博客
05-06 873
内存可以存放数据。程序执行前需要放在内存中才能被CPU处理——缓和CPU与硬盘之间的速度矛盾程序经过编译、链接后生成的指令中指明的是逻辑地址(相对地址)，即:相对于进程的起始地址而言的地址。
动态分区分配
01-04
设计一个程序，模拟基于顺序搜索的动态分区分配算法（FF算法和BF算法）运行过程。假设初始状态下，可用内存为640K。具体要求如下： （1）创建4个线程。 （2）第一个线程负责产生作业（包括作业需要的内存空间及驻留内存时间）并提交内存申请。 （3）第二个线程负责根据某一种算法实现内存的动态分区分配。 （4）第三个线程负责回收内存。 （5）第四个线程负责获取当前模拟内存分区状态并显示，至少包括空闲分区表、驻留内存的作业列表，多则不限。 （6）显示界面尽量友好，语言不限。
动态分区分配四种算法
06-08
最佳适应算法 最坏适应算法 首次适应算法 循环首次适应算法 VC++通过
经典算法：顺序查找
m0_62649396的博客
08-04 165
经典算法：顺序查找
动态分区分配算法实现（代码+文档）
06-29
⑴首次适应算法实现 从空闲分区表的第一个表目起查找该表，把最先能够满足要求的空闲区分配给作业，这种方法目的在于减少查找时间。为适应这种算法，空闲分区表（空闲区链）中的空闲分区要按地址由低到高进行排序。该算法优先使用低址部分空闲区，在低址空间造成许多小的空闲区，在高地址空间保留大的空闲区。 ⑵循环首次适应算法实现 该算法是首次适应算法的变种。在分配内存空间时，不再每次从表头（链首）开始查找，而是从上次找到空闲区的下一个空闲开始查找，直到找到第一个能满足要求的的空闲区为止，并从中划出一块与请求大小相等的内存空间分配给作业。该算法能使内存中的空闲区分布得较均匀。 ⑶最佳适应算法实现 它从全部空闲区中找出能满足作业要求的、且大小最小的空闲分区，这种方法能使碎片尽量小。为适应此算法，空闲分区表（空闲区链）中的空闲分区要按从小到大进行排序，自表头开始查找到第一个满足要求的自由分区分配。 ⑷最坏算法实现 最坏适应分配算法要扫描整个空闲分区或链表，总是挑选一个最大的空闲分区分割给作业使用。该算法要求将所有的空闲分区按其容量从大到小的顺序形成一空闲分区链，查找时只要看第一个分区能否满足作业要求。
DJ4-3 动态分区分配算法
狂放不羁霸的博客
06-13 956
一、基于顺序搜索的分配算法 1、最佳适应算法（BF） 2、最坏适应算法（Worst fit，WF） 3、首次适应算法（First Fit，FF） 4、下次适应算法（Next fit，NF） 二、基于索引搜索的分配算法 5、快速适应算法（Quik fit，QF） 6、伙伴系统 7、哈希算法
毕业设计: 基于Spark的Kmeans聚类算法优化
02-05
《基于Spark的Kmeans聚类算法优化》 在大数据时代，高效的分析工具和技术至关重要。Spark作为一款分布式计算框架，以其高效、易用的特性在大数据处理领域占据着重要地位。而K-means算法，作为经典的无监督机器学习...
基于动态分布式聚类算法的大数据查询处理方法.zip
10-17
"基于动态分布式聚类算法的大数据查询处理方法"这一主题深入探讨了如何利用先进的算法优化大数据环境下的查询效率。在这个压缩包中，包含了一份名为"基于动态分布式聚类算法的大数据查询处理方法.pdf"的文档，很可能...
Java常用算法手册源码
12-08
- 快速排序：基于分治策略，通过选取一个基准元素进行分区，然后递归地排序两部分。 - 归并排序：也是分治策略，将数组分成两半分别排序，再合并成有序序列。 - 堆排序：利用堆这种数据结构进行排序，分为建堆和...
mysql分区功能详解,以及实例分析
09-09
3. HASH分区：基于某个列的哈希值进行分区，适合均匀分布数据的情况。 4. KEY分区：与HASH分区相似，但使用MySQL计算的哈希值。 四、分区的实现与检查 在安装MySQL时，应确保支持分区功能。可以运行`./configure ...
【操作系统总结】动态分区分配算法
沸沸腾的专栏
05-31 5447
基于顺序搜索的动态分区分配算法首次适应算法（FF）空闲分区排成一个链，从链首开始查找，知道找到一个大小能满足的要求的分区为止。循环首次适应NF不是每次都是从链首查找，而是从上次找到的空闲分区开始查找，找到下一个能满足要求的空闲分区，最后一个不满足就返回第一个开始查找，找到第一个适合的最佳适应算法BF把空闲分区按照大小排成一个链，从链首开始查询，找到第一个适合的空闲分区最坏适应算法WF总是挑选一个最大
索引与算法
shui2104的博客
04-27 371
索引与算法 ​ InnoDB存储引擎支持的索引：B+树索引、全文索引、哈希索引。 B+树中的B不是二叉(binary)，而且平衡(balance)。B+树是从平衡二叉树演化而来。 数据结构与算法 二分查找法(binary) ​ 也称为折半查找法，用来查找一组有序记录中的某个值。基本过程：将所有记录有序排序，先以有序序列中的中间点位置为比较对象，如果要找的元素小于中点元素，则将待查部分缩小到左半...
经典算法之索引查找
weixin_68153081的博客
08-19 1041
经典算法之索引查找
操作系统（三十六）动态分区分配算法
qq_40608137的博客
03-14 1210
3.5 动态分区分配算法 上节讲述了连续分区分配方式中有动态分区分配的方式，如果在动态分区分配算法中有许多空闲分区都满足需求的时候，那该如何分配空间呢，今天来介绍四种分配方法解决这个问题。 目录 3.5 动态分区分配算法 3.5.1 首次适应算法 3.5.2 最佳适应算法 3.5.3 最坏适应算法 3.5.4 邻近适应算法 3.5.5 四种方法比较 3.5.1 首次适应...
四、存储器管理问题整理七：什么是基于顺序搜索的动态分区算法？它可以有哪几种？
QingerBigTwo
06-30 3315
所谓顺序搜索，指的是依次搜索空闲分区链上的空闲分区，去寻找一个其大小能满足要求的分区。 主要包含以下四种： （1）首次适应算法（FF）：FF要求空闲分区链以地址递增的顺序链接，从链首开始查找，直至找到第一个满足要求的分区，然后按照作业的大小，从该分区中划出一片内存空间。若从链首到链尾都找不到一个空闲分区，则分配失败。 （2）循环首次适应算法（NF）：为避免低址部分留下许多小的空闲分区，以及减...
基于索引的动态分区分配算法c实现
05-18
以下是基于索引的动态分区分配算法的C语言实现： ``` #include <stdio.h> #include <stdlib.h> #define MAX_PROCESS 100 typedef struct { int id; // 进程ID int size; // 进程大小 } Process; typedef struct { int start; // 分区起始地址 int size; // 分区大小 int pid; // 存放进程ID，若为空则为-1 } Partition; int num_partition; // 分区数量 Partition partitions[MAX_PROCESS]; // 分区表 int num_process; // 进程数量 Process processes[MAX_PROCESS]; // 进程表 void initialize() { int i; for (i = 0; i < MAX_PROCESS; i++) { partitions[i].start = -1; partitions[i].size = -1; partitions[i].pid = -1; processes[i].id = -1; processes[i].size = -1; } num_partition = 0; num_process = 0; } void print_partitions() { int i; printf("Partition Table:\n"); printf("Start\tSize\tPID\n"); for (i = 0; i < num_partition; i++) { printf("%d\t%d\t%d\n", partitions[i].start, partitions[i].size, partitions[i].pid); } printf("\n"); } void print_processes() { int i; printf("Process Table:\n"); printf("ID\tSize\n"); for (i = 0; i < num_process; i++) { printf("%d\t%d\n", processes[i].id, processes[i].size); } printf("\n"); } int allocate_partition(int pid) { int i, j; for (i = 0; i < num_partition; i++) { if (partitions[i].pid == -1 && partitions[i].size >= processes[pid].size) { partitions[i].pid = pid; j = i + 1; while (j < num_partition && partitions[j].pid == -1 && partitions[j].size >= processes[pid].size) { partitions[j - 1].size = partitions[j].size; partitions[j - 1].pid = partitions[j].pid; j++; } partitions[j - 1].size = processes[pid].size; partitions[j - 1].pid = pid; partitions[j].start = partitions[j - 1].start + partitions[j - 1].size; partitions[j].size = partitions[i].start + partitions[i].size - partitions[j].start; partitions[j].pid = -1; num_partition++; return i; } } return -1; } void deallocate_partition(int index) { int i; partitions[index].pid = -1; for (i = index + 1; i < num_partition && partitions[i].pid == -1; i++) { partitions[i - 1].size = partitions[i].size; partitions[i - 1].pid = partitions[i].pid; } partitions[i - 1].pid = -1; num_partition--; } int main() { int choice, pid, index; initialize(); while (1) { printf("1. Add process\n2. Remove process\n3. Print partition table\n4. Print process table\n5. Exit\n"); printf("Enter your choice: "); scanf("%d", &choice); switch (choice) { case 1: printf("Enter process ID: "); scanf("%d", &pid); printf("Enter process size: "); scanf("%d", &processes[pid].size); index = allocate_partition(pid); if (index == -1) { printf("Unable to allocate partition for process %d.\n", pid); } else { printf("Process %d allocated partition %d.\n", pid, index); } break; case 2: printf("Enter process ID: "); scanf("%d", &pid); deallocate_partition(partitions[pid].start); printf("Process %d deallocated partition.\n", pid); break; case 3: print_partitions(); break; case 4: print_processes(); break; case 5: exit(0); default: printf("Invalid choice.\n"); break; } } return 0; } ``` 该算法的主要思路是维护一个分区表和一个进程表，每当有新的进程需要分配内存时，就在分区表中查找合适的空闲分区来存放该进程，并将分区表中的分区重新调整以保证空闲分区连续。当进程需要释放内存时，就在分区表中查找该进程所占用的分区，并将该分区释放。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值