【组成原理-存储】关于交叉存储器检测访问冲突的一种算法
算法规则
昨天本人做有关交叉存储的冲突判断题，感觉如果按照传统的做题方法一个个看，容易漏判一些冲突项而导致失分；如果直接画甘特图，费时间，又容易画错。因此，想了很久，也试了很久，终于想到并逐步完善了一种交叉存储器检测冲突的算法，算法的执行过程中可以有序地找出冲突项，在算法结束后，又可以立即得出访问模块序列的总时间，可谓一举两得。我不太清楚是否有人之前想到过这种方法，如果有，或者是有更简单的方法，请私信我，谢谢。这个算法思想类似字符串匹配中的 KMP 算法，但放心，要比 KMP 简单得多。
由于考试一般考察四体交叉存储器，因此这里默认模块数为 4，现列出该算法规则如下：
- 访问序列由数字和空位组成，为方便起见，数字和空位我们统一称为元素。
- 算法开始时，在序列的头部和尾部各添 3 个空位。
- 设置一个滑动组，该滑动组必须为四个元素（可以全是数字，亦可部分数字部分空位）。从序列头部开始，依次往后移，一直移到序列尾部，滑动组不足四个元素为止。
- 若发现滑动组四个元素中有一对重复项（即两个重复项），则在后一个重复项的前面添加一个空位。如果是两对，则每对后一个重复项的前面添加一个空位。
- 滑动组移到序列尾部，算法结束，删去序列的头部和尾部的 3 个空位，得到最终序列结果。
看起来很繁琐，别急，我们马上来先看一个简单的例子，我将使用括号表示滑动组：
例 1
【例 1】访问一个四体交叉存储器的模块序列为：3,2,1,3,2。
【解】
| 操作 | 序列 |
|---|---|
| 算法开始 | 3 2 1 3 2 |
| 前后各添三个空位 | _ _ _ 3 2 1 3 2 _ _ _ |
| 滑动组从序列头部开始，发现没有冲突项 | (_ _ _ 3) 2 1 3 2 _ _ _ |
| 继续滑动，发现没有冲突项 | _ (_ _ 3 2) 1 3 2 _ _ _ |
| 继续滑动，发现没有冲突项 | _ _ (_ 3 2 1) 3 2 _ _ _ |
| 继续滑动，发现有冲突项 | _ _ _ (3 2 1 3) 2 _ _ _ |
| 在后一个冲突项的前面添上一个空位 | _ _ _ (3 2 1 _ 3) 2 _ _ _ |
| 继续滑动，发现没有冲突项 | _ _ _ 3 (2 1 _ 3) 2 _ _ _ |
| 继续滑动，发现没有冲突项 | _ _ _ 3 2 (1 _ 3 2) _ _ _ |
| 继续滑动，发现没有冲突项 | _ _ _ 3 2 1 (_ 3 2 _) _ _ |
| 继续滑动，发现没有冲突项 | _ _ _ 3 2 1 _ (3 2 _ _) _ |
| 继续滑动，发现没有冲突项，此时已到序列尾部 | _ _ _ 3 2 1 _ 3 (2 _ _ _) |
| 去掉前后的三个空位，得到最终访问序列，算法结束 | 3 2 1 _ 3 2 |
从最终结果可以看出，访问完模块 3,2,1 后，因为下一个要访问的模块 3 还未恢复结束，因此会停止一个 r 的时间等待其恢复。同时，我们在算法执行过程中也知道了哪两个项会冲突（冲突项已加粗）：3 2 1 _ 3 2。还可以得知，处理器访问这个序列所用的时间为 6r。
所以从这个例子想跟大家说的是：这个算法用一个数字表示一个访存周期，而用一个空位表示处理器等待存储体恢复的一个周期。并且，得到的总元素个数，就是我们想要知道的访问时间。
这个例子还是比较简单的，现稍微修改一下题目，来看看算法又会有怎样的表现：
例 2
【例 2】访问一个四体交叉存储器的模块序列为：3,1,2,3,2。
【解】
| 操作 | 序列 |
|---|---|
| 算法开始 | 3 1 2 3 2 |
| 前后各添三个空位 | _ _ _ 3 1 2 3 2 _ _ _ |
| 滑动组从序列头部开始，发现没有冲突项 | (_ _ _ 3) 1 2 3 2 _ _ _ |
| 继续滑动，发现没有冲突项 | _ (_ _ 3 1) 2 3 2 _ _ _ |
| 继续滑动，发现没有冲突项 | _ _ (_ 3 1 2) 3 2 _ _ _ |
| 继续滑动，发现有冲突项 | _ _ _ (3 1 2 3) 2 _ _ _ |
| 在后一个冲突项的前面添上一个空位 | _ _ _ (3 1 2 _ 3) 2 _ _ _ |
| 继续滑动，发现没有冲突项 | _ _ _ 3 (1 2 _ 3) 2 _ _ _ |
| 继续滑动，发现有冲突项 | _ _ _ 3 1 (2 _ 3 2) _ _ _ |
| 在后一个冲突项的前面添上一个空位 | _ _ _ 3 1 (2 _ 3 _ 2) _ _ _ |
| 继续滑动，发现没有冲突项 | _ _ _ 3 1 2 (_ 3 _ 2) _ _ _ |
| 继续滑动，发现没有冲突项 | _ _ _ 3 1 2 _ (3 _ 2 _) _ _ |
| 继续滑动，发现没有冲突项 | _ _ _ 3 1 2 _ 3 (_ 2 _ _) _ |
| 继续滑动，发现没有冲突项，此时已到序列尾部 | _ _ _ 3 1 2 _ 3 _ (2 _ _ _) |
| 去掉前后的三个空位，得到最终访问序列，算法结束 | 3 1 2 _ 3 _ 2 |
从最终结果可以看出，访问完模块 3,1,2 后，因为下一个要访问的模块 3 还未恢复结束，因此会停止一个 r 的时间等待其恢复；类似地，当第二次访问完模块 3 后，由于模块 2 还未恢复结束，因此也需要等待一个 r 的时间。同时，我们在算法执行过程中也知道了哪两个项会冲突（冲突项已加粗）：3 1 2 _ 3 _ 2 和 3 1 2 _ 3 _ 2。还可以得知，处理器访问这个序列所用的时间为 7r。
下面是一个极端的例子，用以说明为何需要在序列前后添置三个空位，同时我们也将看到序列中多个连续空位的产生：
例 3
【例 3】访问一个四体交叉存储器的模块序列为：1,1,2,2,3。
【解】
| 操作 | 序列 |
|---|---|
| 算法开始 | 1 1 2 2 3 |
| 前后各添三个空位 | _ _ _ 1 1 2 2 3 _ _ _ |
| 滑动组从序列头部开始，发现没有冲突项 | (_ _ _ 1) 1 2 2 3 _ _ _ |
| 继续滑动，发现有冲突项 | _ (_ _ 1 1) 2 2 3 _ _ _ |
| 在后一个冲突项的前面添上一个空位 | _ (_ _ 1 _ 1) 2 2 3 _ _ _ |
| 继续滑动，发现有冲突项 | _ _ (_ 1 _ 1) 2 2 3 _ _ _ |
| 在后一个冲突项的前面添上一个空位 | _ _ (_ 1 _ _ 1) 2 2 3 _ _ _ |
| 继续滑动，发现有冲突项 | _ _ _ (1 _ _ 1) 2 2 3 _ _ _ |
| 在后一个冲突项的前面添上一个空位 | _ _ _ (1 _ _ _ 1) 2 2 3 _ _ _ |
| 继续滑动，发现没有冲突项 | _ _ _ 1 (_ _ _ 1) 2 2 3 _ _ _ |
| 继续滑动，发现没有冲突项 | _ _ _ 1 _ (_ _ 1 2) 2 3 _ _ _ |
| 继续滑动，发现有冲突项 | _ _ _ 1 _ _ (_ 1 2 2) 3 _ _ _ |
| 在后一个冲突项的前面添上一个空位 | _ _ _ 1 _ _ (_ 1 2 _ 2) 3 _ _ _ |
| 继续滑动，发现有冲突项 | _ _ _ 1 _ _ _ (1 2 _ 2) 3 _ _ _ |
| 在后一个冲突项的前面添上一个空位 | _ _ _ 1 _ _ _ (1 2 _ _ 2) 3 _ _ |
| 继续滑动，发现有冲突项 | _ _ _ 1 _ _ _ 1 (2 _ _ 2) 3 _ _ |
| 在后一个冲突项的前面添上一个空位 | _ _ _ 1 _ _ _ 1 (2 _ _ _ 2) 3 _ _ _ |
| 继续滑动，发现没有冲突项 | _ _ _ 1 _ _ _ 1 2 (_ _ _ 2) 3 _ _ _ |
| 继续滑动，发现没有冲突项 | _ _ _ 1 _ _ _ 1 2 _ (_ _ 2 3) _ _ _ |
| 继续滑动，发现没有冲突项 | _ _ _ 1 _ _ _ 1 2 _ _ (_ 2 3 _) _ _ |
| 继续滑动，发现没有冲突项 | _ _ _ 1 _ _ _ 1 2 _ _ _ (2 3 _ _) _ |
| 继续滑动，发现没有冲突项，此时已到序列尾部 | _ _ _ 1 _ _ _ 1 2 _ _ _ 2 (3 _ _ _) |
| 去掉前后的三个空位，得到最终访问序列，算法结束 | 1 _ _ _ 1 2 _ _ _ 2 3 |
显然，处理器访问这个序列所需时间为 11r。
从这个例子中我们可以看到，如果序列头部不加三个空位，而是直接开始滑动的话，那么就会出现“1 _ 1 2 _ _ _ 2 3”的情况，这是不对的。
最后再来看一个更加长的例子：
例 4
【例 4】访问模块号的顺序：3，1，2，3，0，2，1，3，1，2，0，2。
【解】（我们直接跳过没有冲突的步骤，只列出发生冲突的步骤）
| 操作 | 序列 |
|---|---|
| 算法开始 | 3 1 2 3 0 2 1 3 1 2 0 2 |
| 前后各添三个空位 | _ _ _ 3 1 2 3 0 2 1 3 1 2 0 2 _ _ _ |
| 滑动组发现冲突项 | _ _ _ (3 1 2 3) 0 2 1 3 1 2 0 2 _ _ _ |
| 在后一个冲突项的前面添上一个空位 | _ _ _ (3 1 2 _ 3) 0 2 1 3 1 2 0 2 _ _ _ |
| 滑动组发现冲突项 | _ _ _ 3 1 2 _ 3 0 (2 1 3 1) 2 0 2 _ _ _ |
| 在后一个冲突项的前面添上一个空位 | _ _ _ 3 1 2 _ 3 0 (2 1 3 _ 1) 2 0 2 _ _ _ |
| 滑动组发现冲突项 | _ _ _ 3 1 2 _ 3 0 2 (1 3 _ 1) 2 0 2 _ _ _ |
| 在后一个冲突项的前面添上一个空位 | _ _ _ 3 1 2 _ 3 0 2 (1 3 _ _ 1) 2 0 2 _ _ _ |
| 滑动组发现冲突项 | _ _ _ 3 1 2 _ 3 0 2 1 3 _ _ (1 2 0 2) _ _ _ |
| 在后一个冲突项的前面添上一个空位 | _ _ _ 3 1 2 _ 3 0 2 1 3 _ _ (1 2 0 _ 2) _ _ _ |
| 滑动组发现冲突项 | _ _ _ 3 1 2 _ 3 0 2 1 3 _ _ 1 (2 0 _ 2) _ _ _ |
| 在后一个冲突项的前面添上一个空位 | _ _ _ 3 1 2 _ 3 0 2 1 3 _ _ 1 (2 0 _ _ 2) _ _ _ |
| 没有其余冲突项，算法结束 | 3 1 2 _ 3 0 2 1 3 _ _ 1 2 0 _ _ 2 |
显然，处理器访问这个序列所需时间为 17r。
在做题的时候，你可以只写出冲突的步骤，不冲突的步骤没有必要写出来。有的时候，你甚至可以一眼看出要加多少个空位。OK，那么就暂时写到这了。
