操作系统作业 15-17章

第十五章

1．用种子 1、2 和 3 运行，并计算进程生成的每个虚拟地址是处于界限内还是界限外? 如果在界限内，请计算地址转换。

      种子1：

        VA 0: segmentation violation

        VA 1: 0x3741（14145）

        VA 2: segmentation violation

        VA 3: segmentation violation

        VA 4: segmentation violation

种子2：

        VA 0: 0x3ce2（15586)

        VA 1: 0x3cff（15615）

        VA 2: segmentation violation

        VA 3: segmentation violation

        VA 4: segmentation violation

种子3：

        VA 0: segmentation violation

        VA 1: segmentation violation

        VA 2: segmentation violation

        VA 3: 0x2317（8983）

        VA 4: 0x22e1（8929）

3．使用以下标志运行：-s 1 -n 10 -l 100。可以设置基址的最大值是多少，以便地址空间仍然完全放在物理内存中？

        界限值为100，最大内存空间为16k，最大的基址值为16k-100=16284

第十七章

1. 首先运行 flag -n 10 -H 0 -p BEST -s 0 来产生一些随机分配和释放。你能预测malloc()/free()会返回什么吗？你可以在每次请求后猜测空闲列表的状态吗？随着时间的推移，你对空闲列表有什么发现？

      使用题目中标志运行程序，头块大小为0，按照最优匹配策略分配空间，空闲列表按地址递增的顺序保存空闲块，空间从1000开始。

分配情况和空闲列表状态如下：

Ptr[0]=alloc(3)             returned 1000

List(size:1)：addr:1003,size:97

Free(ptr[0])                  returned 0

List(size:2)：addr:1000,size:3          addr:1003,size:97

Ptr[1]=alloc(5)             returned 1003

List(size:2)：addr:1000,size:3          addr:1008,size:92

Free(ptr[1])                  returned 0

List(size:3)：addr:1000,size:3          addr:1003,size:5              addr:1008,size:92

Ptr[2]=alloc(8)             returned 1008

List(size:3)：addr:1000,size:3          addr:1003,size:5              addr:1016,size:84

Free(ptr[2])                  returned 0

List(size:4)：addr:1000,size:3          addr:1003,size:5              addr:1008,size:8                                                 addr:1016,size:84

Ptr[3]=alloc(8)             returned 1008

List(size:3)：addr:1000,size:3          addr:1003,size:5              addr:1016,size:84

Free(ptr[3])                  returned 0

List(size:4)：addr:1000,size:3          addr:1003,size:5              addr:1008,size:8                                                 addr:1016,size:84

Ptr[4]=alloc(2)             returned 1000

List(size:4)：addr:1002,size:1          addr:1003,size:5              addr:1008,size:8                                                 addr:1016,size:84

Ptr[5]=alloc(7)             returned 1010

List(size:4)：addr:1003,size:1          addr:1003,size:5              addr:1015,size:1                                                 addr:1016,size:84

6次分配空间查找空闲块的次数分别为：1,2,3,4,4,4。

        随着不断分配和释放空间，空闲列表中的空闲块逐渐增加，且都为分隔后的较小的块，且分配搜索空闲块的次数也随之增加。

3．如果使用首次匹配（-p FIRST）会如何？使用首次匹配时，什么变快了？

        使用首次匹配，空间分配情况和空闲列表的情况与1中相同，但在搜索空闲空间时不需要遍历整个空闲列表，因此6次分配空间所需要的搜索次数分别为：1,2,3,3,1,3，搜索空闲列表变快了。

4．对于上述问题，列表在保持有序时，可能会影响某些策略找到空闲位置所需的时间。使用不同的空闲列表排序（-l ADDRSORT，-l SIZESORT +，-l SIZESORT-）查看策略和列表排序如何相互影响。

      由于最优匹配和最差匹配都需要遍历空闲列表，不同的空闲列表排序对找到空闲位置的时间没有影响，只需要查看排序对首次匹配的时间产生的影响，比较使用不同排序需要的搜索次数。

      ADDRSORT：1,2,3,3,1,3

                SIZESORT +：1,2,3,3,1,3

        SIZESORT-：1,1,1,1,1,1

        ADDRSORT和SIZESORT+下的搜索次数相同，SIZESORT-排序后每次只需要搜索一次，搜索时间大大减少，这是因为排序将最大的空闲块放在列表第一位，首次匹配只要一次就可以完成搜索分配。

第十六章

1．先让我们用一个小地址空间来转换一些地址。这里有一组简单的参数和几个不同的随机种子。你可以转换这些地址吗。

      按照题目中所给出的参数，地址空间大小为128，物理内存空间为512，seg0的基址为0，界限为20，seg1的基址为512，界限为20。

      segmentation.py -a 128 -p 512 -b 0 -l 20 -B 512 -L 20 -s 0：

根据最高位（第7位）判断段，再计算偏移量，根据基址加界限计算有效地址。

VA 0(1101100)：OFFSET=-20，PA=0x1ec（492），seg1

VA 1(1100001)：OFFSET=-31，segmentation violation，seg1

VA 2(0110101)：OFFSET=53，segmentation violation，seg0

VA 3(0110011)：OFFSET=51，segmentation violation，seg0

VA 4(1000001)：OFFSET=-63，segmentation violation，seg1

segmentation.py -a 128 -p 512 -b 0 -l 20 -B 512 -L 20 -s 1：

计算方法同上

VA 0(0010001)：OFFSET=17，PA=0x11（17），seg0

VA 1(1101100)：OFFSET=-20，PA=0x1ec（492），seg1

VA 2(1100001)：OFFSET=-31，segmentation violation，seg1

VA 3(0100000)：OFFSET=32，segmentation violation，seg0

VA 4(0111111)：OFFSET=63，segmentation violation，seg0

segmentation.py -a 128 -p 512 -b 0 -l 20 -B 512 -L 20 -s 2：

VA  0(1111010)：OFFSET=-6，PA=0x1fa（506），seg1

VA 1(1111001)：OFFSET=-7，PA=0x1f9（505），seg1

VA 2(0000111)：OFFSET=7，PA=0x7（7），seg0

VA 3(0001010)：OFFSET=10，PA=0xa（10），seg0

VA 4(1101010)：OFFSET=-22，segmentation violation，seg1

2．现在，让我们看看是否理解了这个构建的小地址空间（使用上面问题的参数）。段 0 中最高的合法虚拟地址是什么？段 1 中最低的合法虚拟地址是什么？在整个地址空间中， 最低和最高的非法地址是什么？最后，如何运行带有-A 标志的 segmentation.py 来测试你是 否正确？

      段0的最高合法虚拟地址为19，段1中最低的合法虚拟地址为108。最低的非法地址为20（seg0），最高非法地址为107（seg1）。使用-A指定虚拟地址进行验证，指令如下：

python3 segmentation.py -a 128 -p 512 -b 0 -l 20 -B 512 -L 20 -A 19,20,107,108 -c

3．假设我们在一个128字节的物理内存中有一个很小的16字节地址空间。你会设置什么样的基址和界限，以便让模拟器为指定的地址流生成以下转换结果：有效，有效，……，违规，违规，有效，有效？

      设虚拟地址为0-15，前两个地址和最后两个地址为有效地址，可将界限设为2，将基址设为0,16，使用如下指令生成结果：