动态分区分配算法

引言

为了实现下列的代码，首先要写下列的代码：

import random
from matplotlib import pyplot as plt
Request_list=[random.randint(1,1000) for i in range(100)]

1.首次适应(first fit, FF)算法

1.1.分配策略

要求空闲分区按地址递增的次序链接起来。在分配的时候，从链首开始寻找，直至找到一个大小能容纳作业的空闲分区，然后按照作业的大小，从该空闲分区中划分一块内存空间，分配给作业，剩下的继续留在空闲链内。

1.2.代码实现

def fisrt_fit():
    Memory_list = [random.randint(1, 1000) for i in range(500)]
    Vision=[0 for i in range(len(Memory_list))]
    for i in range(len(Request_list)):
        for j in range(len(Memory_list)):
            if Memory_list[j]>=Request_list[i]:
                Vision[j]=1
                Memory_list[j]-=Request_list[i]
                break
    plt.figure(0)
    plt.plot(list(range(len(Memory_list))),Vision)
    plt.show()
    plt.figure(1)
    plt.plot(list(range(len(Memory_list))),Memory_list)
    plt.show()
fisrt_fit()

1.3.结果与讨论

空闲分区使用情况

可以看到该算法倾向使用低地址的空闲分区，因此保留了高地址的大空闲分区，这为以后的大作业分配创造了条件。
剩下碎片分布情况

可以看出其生成的碎片也主要存在于低地址处。

2.循环首次适应(next fit, NF)算法

2.1.分配策略

要求空闲分区按地址递增的次序链接起来。在分配的时候，不再每次从链首开始寻找，而是从上次分配的空闲分区的下一个开始寻找，直至找到一个大小能容纳作业的空闲分区，然后按照作业的大小，从该空闲分区中划分一块内存空间，分配给作业，剩下的继续留在空闲链内。

2.2.代码实现

def best_fit():
    Memory_list = [random.randint(1, 1000) for i in range(500)]
    Memory_list.sort()
    print(Memory_list)
    Vision = [0 for i in range(len(Memory_list))]
    for i in range(len(Request_list)):
        for j in range(len(Memory_list)):
            if Memory_list[j] >= Request_list[i]:
                Vision[j] = 1
                Memory_list[j]-=Request_list[i]
                break
    plt.figure(4)
    plt.plot(list(range(len(Memory_list))), Vision)
    plt.show()
    plt.figure(5)
    plt.plot(list(range(len(Memory_list))), Memory_list)
    plt.show()
best_fit()

2.3.结果与讨论

空闲分区使用情况

可以看到该算法不再倾向使用低地址的空闲分区，而是比较均匀地使用空闲分区。但这样会缺乏大的空闲分区。
剩下碎片分布情况

可以看出其生成的碎片也分布比较均匀。

3.最佳适应(best fit, BF)算法

3.1.分配策略

要求空闲分区按空闲分区大小递增的次序链接起来。在分配的时候，从链首开始寻找，直至找到一个大小能容纳作业的空闲分区，然后按照作业的大小，从该空闲分区中划分一块内存空间，分配给作业，剩下的继续留在空闲链内。

3.2.代码实现

def best_fit():
    Memory_list = [random.randint(1, 1000) for i in range(500)]
    Memory_list.sort()
    print(Memory_list)
    Vision = [0 for i in range(len(Memory_list))]
    for i in range(len(Request_list)):
        for j in range(len(Memory_list)):
            if Memory_list[j] >= Request_list[i]:
                Vision[j] = 1
                Memory_list[j]-=Request_list[i]
                break
    plt.figure(4)
    plt.plot(list(range(len(Memory_list))), Vision)
    plt.show()
    plt.figure(5)
    plt.plot(list(range(len(Memory_list))), Memory_list)
    plt.show()
best_fit()

3.3.结果与讨论

空闲分区使用情况

可以看到该算法总是利用最小、最适合的空闲分区来分配，使用的空闲分区分布最为均匀。
剩下碎片分布情况

可以看出其生成的碎片总是最小的。

4.最坏适应(worst fit, WF)算法

4.1.分配策略

要求空闲分区按空闲分区大小递减的次序链接起来。在分配的时候，从链首开始寻找，直至找到一个大小能容纳作业的空闲分区，然后按照作业的大小，从该空闲分区中划分一块内存空间，分配给作业，剩下的继续留在空闲链内。

4.2.代码实现

def worst_fit():
    Memory_list = [random.randint(1, 1000) for i in range(500)]
    Memory_list.sort()
    Memory_list.reverse()
    Vision = [0 for i in range(len(Memory_list))]
    for i in range(len(Request_list)):
        for j in range(len(Memory_list)):
            if Memory_list[j] >= Request_list[i]:
                Vision[j] = 1
                Memory_list[j]-=Request_list[i]
                break
    plt.figure(6)
    plt.plot(list(range(len(Memory_list))), Vision)
    plt.show()
    plt.figure(7)
    plt.plot(list(range(len(Memory_list))), Memory_list)
    plt.show()
worst_fit()

4.3.结果与讨论

空闲分区使用情况

可以看到该算法每次都使用最大的空闲分区。这样会缺乏大的空闲分区。但这样不会产生过多的碎片，对中、小作业有利。
剩下碎片分布情况

可以看出其生成的碎片不至于太小，产生碎片的可能小。