在一个请求分页系统中,假定系统分配给一个作业的物理块数为3,并且此作业页面走向为2、3、2、1、5、2、4、5、3、2、5、2。试用FIDO和LRU两种算法分别计算出程序访问过程中所发生的缺页次数。

首先需要明确的是，FIFO算法是一种先进先出的置换算法，而不是FIDO。

接下来分别使用FIFO和LRU算法计算缺页次数：

1. FIFO算法

首先将3个物理块都分配给作业，然后按顺序处理页面走向序列：

2，3，2（缺页），1（缺页），5（缺页），2（缺页），4（缺页），5，3，2（缺页），5，2（缺页）

因此，FIFO算法中发生的缺页次数为6次。

2. LRU算法

同样是先将3个物理块都分配给作业，然后按顺序处理页面走向序列：

2，3，2（缺页），1（缺页），5（缺页），2（命中），4（缺页），5（缺页），3（缺页），2（命中），5（命中），2（命中）

因此，LRU算法中发生的缺页次数为5次。

综上所述，FIFO算法中发生的缺页次数为6次，LRU算法中发生的缺页次数为5次。

相关问题

在一个请求分页系统中，假定系统分配给一个作业的物理块数为3，并且此作业的页面走向为2、3、2、1、5、2、4、5、3、2、5、2。试用FIFO和LRU两种算法分别计算出程序访问过程中所发生的缺页次数。

假设系统的页面帧数为3，作业的页面走向为2、3、2、1、5、2、4、5、3、2、5、2。那么我们需要使用FIFO和LRU算法来计算缺页次数。

FIFO算法：

| 页面号 | 页框0 | 页框1 | 页框2 | 缺页次数 |
|--------|-------|-------|-------|----------|
| 2 | 2 | | | 1 |
| 3 | 2 | 3 | | 2 |
| 2 | 2 | 3 | | 2 |
| 1 | 1 | 3 | | 3 |
| 5 | 1 | 3 | 5 | 4 |
| 2 | 1 | 3 | 5 | 4 |
| 4 | 4 | 3 | 5 | 5 |
| 5 | 4 | 3 | 5 | 5 |
| 3 | 4 | 3 | 3 | 6 |
| 2 | 4 | 2 | 3 | 7 |
| 5 | 4 | 2 | 5 | 8 |
| 2 | 4 | 2 | 5 | 8 |

因此，FIFO算法的缺页次数为8。

LRU算法：

| 页面号 | 页框0 | 页框1 | 页框2 | 缺页次数 |
|--------|-------|-------|-------|----------|
| 2 | 2 | | | 1 |
| 3 | 2 | 3 | | 2 |
| 2 | 3 | 2 | | 3 |
| 1 | 3 | 2 | 1 | 4 |
| 5 | 5 | 2 | 1 | 5 |
| 2 | 5 | 2 | 1 | 5 |
| 4 | 5 | 4 | 1 | 6 |
| 5 | 5 | 4 | 1 | 6 |
| 3 | 3 | 4 | 1 | 7 |
| 2 | 3 | 2 | 1 | 8 |
| 5 | 3 | 2 | 5 | 9 |
| 2 | 3 | 2 | 5 | 9 |

因此，LRU算法的缺页次数为9。

在一个请求分页系统中，假定系统分配给一个作业的物理块数为4，并且此作业的页面走向为1，2,3,4, 2,1,5，6,2，1, 2, 3, 7，6, 3, 2, 1,2，3，6。试用Optimal、FIFO和LRU三种算法分别计算出程序访问过程中所发生的缺页次数和缺页率

首先，需要知道每个作业所占用的物理块数，这里是4个物理块，即内存中只能存放4个页面。在计算缺页次数和缺页率时，需要记录每个页面的使用情况及其在内存中的位置。

接下来，分别使用Optimal、FIFO和LRU三种算法计算缺页次数和缺页率：

1. Optimal算法：

首先需要预测未来访问页面的情况，即找出最长时间内不再被访问的页面。根据此算法，计算程序访问过程中所发生的缺页次数和缺页率如下：

| 页面 | 1 | 2 | 3 | 4 | 2 | 1 | 5 | 6 | 2 | 1 | 2 | 3 | 7 | 6 | 3 | 2 | 1 | 2 | 3 | 6 |
| ---- | - | - | - | - | - | - | - | - | - | - | - | - | - | - | - | - | - | - | - | - |
| 缺页 | 1 | 1 | 1 | 1 | 2 | 2 | 3 | 4 | 4 | 4 | 4 | 5 | 6 | 7 | 7 | 8 | 9 | 9 | 10| 11|
| 缺页率 | 25% | 25% | 25% | 25% | 50% | 50% | 75% | 100% | 100% | 100% | 100% | 91.67% | 83.33% | 87.5% | 87.5% | 90% | 95% | 95% | 100% | 100% |

2. FIFO算法：

按照页面进入内存的先后顺序进行替换。如果内存已满，则最先进入内存的页面会被替换掉。计算程序访问过程中所发生的缺页次数和缺页率如下：

| 页面 | 1 | 2 | 3 | 4 | 2 | 1 | 5 | 6 | 2 | 1 | 2 | 3 | 7 | 6 | 3 | 2 | 1 | 2 | 3 | 6 |
| ---- | - | - | - | - | - | - | - | - | - | - | - | - | - | - | - | - | - | - | - | - |
| 缺页 | 1 | 1 | 1 | 1 | 2 | 2 | 3 | 4 | 4 | 4 | 4 | 5 | 6 | 7 | 7 | 8 | 9 | 9 | 10| 11|
| 缺页率 | 25% | 25% | 25% | 25% | 50% | 50% | 75% | 100% | 100% | 100% | 100% | 91.67% | 83.33% | 87.5% | 87.5% | 90% | 95% | 95% | 100% | 100% |

3. LRU算法：

根据页面最近的使用情况来进行替换。最近使用的页面会被保留在内存中，最久未使用的页面会被替换掉。计算程序访问过程中所发生的缺页次数和缺页率如下：

| 页面 | 1 | 2 | 3 | 4 | 2 | 1 | 5 | 6 | 2 | 1 | 2 | 3 | 7 | 6 | 3 | 2 | 1 | 2 | 3 | 6 |
| ---- | - | - | - | - | - | - | - | - | - | - | - | - | - | - | - | - | - | - | - | - |
| 缺页 | 1 | 1 | 1 | 1 | 2 | 2 | 3 | 4 | 4 | 4 | 5 | 5 | 6 | 7 | 7 | 8 | 9 | 9 | 10| 11|
| 缺页率 | 25% | 25% | 25% | 25% | 50% | 50% | 75% | 100% | 100% | 100% | 83.33% | 83.33% | 87.5% | 87.5% | 90% | 95% | 95% | 100% | 100% |

综上所述，三种算法计算出的缺页次数和缺页率都是相同的，即缺页次数为11，缺页率为100%。这是因为作业需要的物理块数为4，而程序访问过程中的页面数超过了4个，所以必然会发生缺页，无论采用哪种算法。