页面置换算法实验设计报告.docx

页面置换算法实验设计报告.docx

《页面置换算法实验设计报告.docx》由会员分享，可在线阅读，更多相关《页面置换算法实验设计报告.docx（18页珍藏版）》请在冰豆网上搜索。

页面置换算法实验设计报告

实验四页面置换算法

班级：

xxxxxxxxxxx姓名：

xxxx

学号：

xxxxxxxxxxxxxxxxx

上级日期：

2018年11月

成绩：

___________________________

一、实验目的:

通过请求页式存储管理中页面置换算法模拟设计，以便：

1、了解虚拟存储技术的特点

2、掌握请求页式存储管理中页面置换算法

二、实验内容

1、程序流程图

系统主要运行过程流程图

主流程图：

FIFO置换算法流程图：

OPT置换算法流程图：

简单CLOCK置换算法流程图：

LRU置换算法流程图：

2、程序源码

1.#include   

2.#include   

3.#include   

4./*全局变量*/  

5.int mSIZE; /*物理块数*/  

6.int pSIZE; /*页面号引用串个数*/  

7.static int memery[10] = { 0 }; /*物理块中的页号*/  

8.static int page[100] = { 0 }; /*页面号引用串*/  

9.static int temp[100][10] = { 0 }; /*辅助数组*/  

10./*置换算法函数*/  

11.void FIFO（）;  

12.void LRU（）;  

13.void OPT（）;  

14./*辅助函数*/  

15.void print（unsigned int t）;  

16.void designBy（）;  

17.void download（）;  

18.void mDelay（unsigned int Delay）;  

19./*主函数*/  

20.void main（）  

21.{  

22.    int i,k,code;  

23.    system（"color 0A"）;  

24.    designBy（）;  

25.    printf（"┃请按任意键进行初始化操作... ┃\n"）;  

26.    printf（"┗━━━━━━━━━━━━━━━━━━━━━━━━━┛\n"）;  

27.    printf（" >>>"）;  

28.    getch（）;  

29.    system（"cls"）;  

30.    system（"color 0B"）;  

31.    printf（"请输入物理块的个数（M<=10）：

"）;  

32.    scanf（"%d", &mSIZE）;  

33.    printf（"请输入页面号引用串的个数（P<=100）：

"）;  

34.    scanf（"%d", &pSIZE）;  

35.    puts（"请依次输入页面号引用串（连续输入，无需隔开）：

"）;  

36.    for （i = 0; i

37.        scanf（"%1d", &page[i]）;  

38.    download（）;  

39.    system（"cls"）;  

40.    system（"color 0E"）;  

41.    do {  

42.        puts（"输入的页面号引用串为：

"）;  

43.        for （k = 0; k <= （pSIZE - 1） / 20; k++）  

44.        {  

45.            for （i = 20 * k; （i

46.            {  

47.                if （（（i + 1） % 20 == 0） || （（（i + 1） % 20） && （i == pSIZE - 1）））  

48.                    printf（"%d\n", page[i]）;  

49.                else  

50.                    printf（"%d ", page[i]）;  

51.            }  

52.        }  

53.        printf（"* * * * * * * * * * * * * * * * * * * * * * *\n"）;  

54.        printf（"* 请选择页面置换算法：

\t\t\t *\n"）;  

55.        printf（"* ----------------------------------------- *\n"）;  

56.        printf（"* 1.先进先出（FIFO） 2.最近最久未使用（LRU） *\n"）;  

57.        printf（"* 3.最佳（OPT） 4.退出 *\n"）;  

58.        printf（"* * * * * * * * * * * * * * * * * * * * * * *\n"）;  

59.        printf（"请选择操作：

[ ]\b\b"）;  

60.        scanf（"%d", &code）;  

61.        switch （code）  

62.        {  

63.        case 1:

64.            FIFO（）;  

65.            break;  

66.        case 2:

67.            LRU（）;  

68.            break;  

69.        case 3:

70.            OPT（）;  

71.            break;  

72.        case 4:

73.            system（"cls"）;  

74.            system（"color 0A"）;  

75.            designBy（）; /*显示设计者信息后退出*/  

76.            printf（"┃谢谢使用页面置换算法演示器!

 正版授权 ㊣┃\n"）;  

77.                printf（"┗━━━━━━━━━━━━━━━━━━━━━━━━━┛\n"）;  

78.                    exit（0）;  

79.        default:

80.            printf（"输入错误，请重新输入：

"）;  

81.        }  

82.        printf（"按任意键重新选择置换算法：

>>>"）;  

83.        //getch（）;  

84.        system（"cls"）;  

85.    } while （code !

= 4）;  

86.        getch（）;  

87.}  

88./*载入数据*/  

89.void download（）  

90.{  

91.    int i;  

92.    system（"color 0D"）;  

93.    printf（"╔════════════╗\n"）;  

94.    printf（"║正在载入数据，请稍候 !

!

!

║\n"）;  

95.    printf（"╚════════════╝\n"）;  

96.    printf（"Loading...\n"）;  

97.    printf（" O"）;  

98.    for （i = 0; i<51; i++）  

99.        printf（"\b"）;  

100.    for （i = 0; i<50; i++）  

101.    {  

102.        mDelay（（pSIZE + mSIZE） / 2）;  

103.        printf（">"）;  

104.    }  

105.    printf（"\nFinish.\n 载入成功，按任意键进入置换算法选择界面：

>>>"）;  

106.    getch（）;  

107.}  

108./*设置延迟*/  

109.void mDelay（unsigned int Delay）  

110.{  

111.    unsigned int i;  

112.    for （; Delay>0; Delay--）  

113.    {  

114.        for （i = 0; i<124; i++）  

115.        {  

116.            printf（" \b"）;  

117.        }  

118.    }  

119.}  

120./*显示设计者信息*/  

121.void designBy（）  

122.{  

123.    printf（"┏━━━━━━━━━━━━━━━━━━━━━━━━━┓\n"）;  

124.    printf（"┃㊣ 页面置换算法 ㊣┃\n"）;  

125.    printf（"┣━━━━━━━━━━━━━━━━━━━━━━━━━┫\n"）;  

126.}  

127.void print（unsigned int t）  

128.{  

129.    int i, j, k, l;  

130.    int flag;  

131.    for （k = 0; k <= （pSIZE - 1） / 20; k++）  

132.    {  

133.        for （i = 20 * k; （i

134.        {  

135.            if （（（i + 1） % 20 == 0） || （（（i + 1） % 20） && （i == pSIZE - 1）））  

136.                printf（"%d\n", page[i]）;  

137.            else  

138.                printf（"%d ", page[i]）;  

139.        }  

140.        for （j = 0; j

141.        {  

142.            for （i = 20 * k; （i

143.            {  

144.                if （i >= j）  

145.                    printf（" |%d|", temp[i][j]）;  

146.                else  

147.                    printf（" | |"）;  

148.            }  

149.            for （i = mSIZE + 20 * k; （i

150.            {  

151.                for （flag = 0, l = 0; l

152.                    if （temp[i][l] == temp[i - 1][l]）  

153.                        flag++;  

154.                if （flag == mSIZE）/*页面在物理块中*/  

155.                    printf（" "）;  

156.                else  

157.                    printf（" |%d|", temp[i][j]）;  

158.            }  

159.            /*每行显示 20 个*/  

160.            if （i % 20 == 0）  

161.                continue;  

162.            printf（"\n"）;  

163.        }  

164.    }  

165.    printf（"----------------------------------------\n"）;  

166.    printf（"缺页次数：

%d\t\t", t + mSIZE）;  

167.    printf（"缺页率：

%d/%d\n", t + mSIZE, pSIZE）;  

168.    printf（"置换次数：

%d\t\t", t）;  

169.    printf（"访问命中率：

%d%%\n", （pSIZE - （t + mSIZE）） * 100 / pSIZE）;  

170.    printf（"----------------------------------------\n"）;  

171.    getch（）;  

172.}  

173./*计算过程延迟*/  

174.void compute（） {  

175.    int i;  

176.    printf（"正在进行相关计算，请稍候"）;  

177.    for （i = 1; i<20; i++） {  

178.        mDelay（15）;  

179.        if （i % 4 == 0  

180.            ）  

181.            printf（"\b\b\b\b\b\b     \b\b\b\b\b\b"）;  

182.        else  

183.                printf（"Θ"）;  

184.    }  

185.    for （i = 0; i++<30; printf（"\b"））;  

186.        for （i = 0; i++<30; printf（" "））;  

187.    for （i = 0; i++<30; printf（"\b"））;  

188.}  

189./*先进先出页面置换算法*/  

190.void FIFO（） {  

191.    int memery[10] = { 0 };  

192.    int time[10] = { 0 }; /*记录进入物理块的时间*/  

193.    int i, j, k, m;  

194.    int max = 0; /*记录换出页*/  

195.    int count = 0; /*记录置换次数*/  

196.                   /* 

197.                   前 mSIZE 个数直接放入*/  

198.    for （i = 0; i

199.  

200.    {  

201.        memery[i] = page[i];  

202.        time[i] = i;  

203.        for （j = 0; j

204.            temp[i][j] = memery[j];  

205.  

206.    }  

207.    for （i = mSIZE; i

208.  

209.    {  

210.        /*判断新页面号是否在物理块中*/  

211.        for （j = 0, k = 0; j

212.  

213.        {  

214.            if （memery[j] !

= page[i]）  

215.                k++;  

216.  

217.        }  

218.        if （k == mSIZE） /*如果不在物理块中*/  

219.  

220.        {  

221.            count++;  

222.            /*计算换出页*/  

223.                max = time[0]

 0 :

 1;  

224.            for （m = 2; m

225.                if （time[m]

226.                    max = m;  

227.            memery[max] = page[i];  

228.            time[max] = i; /*记录该页进入物理块的时间*/  

229.            for （j = 0; j

230.                temp[i][j] = memery[j];  

231.        }  

232.        else  

233.        {  

234.            for （j = 0; j

235.                temp[i][j] = memery[j];  

236.        }  

237.    }  

238.    compute（）;  

239.    print（count）;  

240.}  

241./*最近最久未使用置换算法*/  

242.void LRU（）  

243.{  

244.    int memery[10] = { 0 };  

245.    int flag[10] = { 0 }; /*记录页面的访问时间*/  

246.    int i, j, k, m;  

247.    int max = 0; /*记录换出页*/  

248.    int count = 0; /*记录置换次数*/  

249.                   /*前 mSIZE 个数直接放入*/  

250.    for （i = 0; i

251.    {  

252.        memery[i] = page[i];  

253.        flag[i] = i;  

254.        for （j = 0; j

255.            temp[i][j] = memery[j];  

256.    }  

257.    for （i = mSIZE; i

258.    {  

259.        /*判断新页面号是否在物理块中*/  

260.        for （j = 0, k = 0; j

261.        {  

262.            if （memery[j] !

= page[i]）  

263.                k++;  

264.            else  

265.                flag[j] = i; /*刷新该页的访问时间*/  

266.        }  

267.            if （k == mSIZE） /*如果不在物理块中*/  

268.            {  

269.                count++;  

270.                /*计算换出页*/  

271.                max = flag[0]

 0 :

 1;  

272.                for （m = 2; m

273.                    if （flag[m]

274.                        max = m;  

275.                memery[max] = page[i];  

276.                flag[max] = i; /*记录该页的访问时间*/  

277.                for （j = 0; j

278.                    temp[i][j] = memery[j];  

279.            }  

280.            else  

281.            {  

282.                for （j = 0; j

283.                    temp[i][j] = memery[j];  

284.            }  

285.    }  

286.    compute（）;  

287.    print（count）;  

288.}  

289./*最佳置换算法*/  

290.void OPT（） {  

291.    int memery[10] = { 0 };  

292.    int next[10] = { 0 }; /*记录下一次访问时间*/  

293.    int i, j, k, l, m;  

294.    int max; /*记录