今天早上做了操作系统实验：
1、阅读理解两个例程，掌握例程的运作流程。
2、连续式分配例程中提供了三种分配算法：首次适应、循环首次适应、最佳适应。例程还缺少分配作业和回收作业的功能。请至少实现一种分配算法并完成分配作业的功能，保证该例程能够正确实现分配作业的功能
3、回收作业的功能属于选做部分。
4、分页管理例程缺少分配作业和回收的功能，请实现这两个功能，保证该例程能够正确实现分页管理的分配与回收功能
5、上述要求2和4，必须完成其中一个。
连续式分配代码贴上：
1
#include <stdio.h>
2
#include <stdlib.h>
3
#include <
string
.h>
4
#include <time.h>
5
6
#define
ret printf("\n")
7
#define
spa printf(" ")
8
#define
hli printf("-")
9
#define
vli printf(" |")
10
#define
tab printf("\t")
11
#define
capacity 1024
//
内存总大小
12
#define
max 100
//
数组最大长度
13
#define
jobsum 8
//
作业总数量
14
15
16
17
void
_sleep(
int
n){
18
clock_t goal;
19
goal = (clock_t)n * CLOCKS_PER_SEC +
clock();
20
while
(goal >
clock());
21
}
22
23
char
_keygo(){
//
按任意键继续
24
char
c;
25
printf(
"
Please touch any key to continue....\n
"
);
26
c =
getchar();
27
return
c;
28
}
29
30
typedef
struct
job JOB;
31
struct
job {
//
作业结构体
32
int
jobid;
//
作业ID，系统做东分配，无需输入
33
char
name[
20
];
//
作业名称
34
int
vol;
//
作业大小，即要申请的内存空间大小
35
};
36
37
JOB jobdata[jobsum] = {
//
作业队列
38
{
8100
,
"
System
"
,
50
},
39
{
8101
,
"
QianQian
"
,
32
},
40
{
8102
,
"
XunLei
"
,
128
},
41
{
8103
,
"
Dictionary
"
,
76
},
42
{
8104
,
"
NorDun
"
,
86
},
43
{
10001
,
"
QQ
"
,
168
},
44
{
10002
,
"
eMule
"
,
98
},
45
{
10003
,
"
Word
"
,
43
},
46
};
47
48
typedef
struct
memblock MEM;
//
内存分区结构
49
struct
memblock{
50
int
head;
//
地址
51
int
length;
//
长度
52
int
state;
//
状态，0表示空闲，1表示占用
53
int
jobid;
//
已分配，记录作业ID，否则为0
54
};
55
56
MEM memdata[max] = {
//
内存状态表
57
{
0
,
50
,
1
,
8100
},
58
{
50
,
50
,
0
,
0
},
59
{
100
,
32
,
1
,
8101
},
60
{
132
,
128
,
1
,
8102
},
61
{
260
,
100
,
0
,
0
},
62
{
360
,
76
,
1
,
8103
},
63
{
436
,
200
,
0
,
0
},
64
{
636
,
88
,
1
,
8104
},
65
{
724
,
300
,
0
,
0
},
66
};
67
68
int
memsum =
9
;
//
当前分区总数量，包括已分配分区和空闲分区
69
int
curp =
0
;
//
curp 是位置指针
70
71
MEM membackup[
9
] = {
//
内存状态源数据备份，用于还原
72
{
0
,
50
,
1
,
8100
},
73
{
50
,
50
,
0
,
0
},
74
{
100
,
32
,
1
,
8101
},
75
{
132
,
128
,
1
,
8102
},
76
{
260
,
100
,
0
,
0
},
77
{
360
,
76
,
1
,
8103
},
78
{
436
,
200
,
0
,
0
},
79
{
636
,
88
,
1
,
8104
},
80
{
724
,
300
,
0
,
0
},
81
};
82
83
int
job_locate(
int
id){
//
根据作业ID，查找作业在数组jobdata的位置
84
int
i;
85
for
(i=
0
;i<jobsum;++
i)
86
if
(id ==
jobdata[i].jobid)
87
return
i;
88
return
-
1
;
89
}
90
91
void
mem_state(){
//
根据memdata数组显示当前内存状态
92
int
i, j, k;
93
for
(i=
0
;i<memsum;++
i){
94
tab;
95
printf(
"
%4ik
"
, memdata[i].head);
96
for
(j=
0
;j<
20
;++
j) hli;
97
ret;tab; vli;
98
for
(j=
0
;j<
5
;++
j) spa;
99
if
(memdata[i].jobid ==
0
)
100
printf(
"
%10s
"
,
"
$block$
"
);
101
else
{
102
k =
job_locate(memdata[i].jobid);
103
printf(
"
%10s
"
, jobdata[k].name);
104
}
105
vli;ret;
106
}
107
printf(
"
\t1024k
"
);
108
for
(j=
0
;j<
20
;++
j) hli;
109
ret;
110
}
111
112
int
mem_allocate_ff(
int
k){
//
首次适应算法
113
int
i;
114
int
job_size =
jobdata[k].vol;
115
116
//
for(i=0;i<memsum;++i){
117
//
printf("%d %d %d %d\n", memdata[i].head, memdata[i].length, memdata[i].state, memdata[i].jobid);
118
//
}
119
for
(i=
0
;i<memsum;++
i){
120
if
(!memdata[i].state && job_size <=
memdata[i].length)
121
return
i;
122
}
123
return
-
1
;
124
}
125
126
127
int
mem_allocate_cf(
int
k){
//
循环首次适应算法
128
int
i;
129
int
job_size =
jobdata[k].vol;
130
int
t =
memsum;
131
printf(
"
memsum = %d\n
"
, memsum);
132
while
(t){
133
curp %=
memsum;
134
i =
curp;
135
//
printf("t : %d curp : %d length: %d state: %d\n", t, curp, memdata[i].length, memdata[i].state);
136
if
(!memdata[i].state && job_size <=
memdata[i].length){
137
curp++
;
138
return
i;
139
}
140
curp++
;
141
t--
;
142
}
143
return
-
1
;
144
}
145
146
int
mem_allocate_bf(
int
k){
//
最佳适应算法
147
int
i;
148
int
job_size =
jobdata[k].vol;
149
int
min = -
1
;
150
for
(i=
0
;i<memsum;++
i){
151
if
(!memdata[i].state && job_size <=
memdata[i].length){
152
if
(min == -
1
) min =
i;
153
else
if
(memdata[i].length<memdata[min].length) min =
i;
154
}
155
}
156
if
(min!= -
1
)
return
min;
157
return
-
1
;
158
}
159
160
void
mem_allocate(
int
i,
int
j){
//
将分区j分配给作业i
161
int
k;
162
163
if
(jobdata[i].vol ==
memdata[j].length){
164
memdata[j].state =
1
;
165
memdata[j].jobid =
jobdata[i].jobid;
166
}
167
else
{
168
for
(k=memsum-
1
;k>=j;--
k){
169
memdata[k+
1
] =
memdata[k];
170
}
171
int
temp =
memdata[j].length;
172
memdata[j].length =
jobdata[i].vol;
173
174
memdata[j].state =
1
;
175
memdata[j].jobid =
jobdata[i].jobid;
176
memdata[j+
1
].length = temp -
memdata[j].length;
177
memdata[j+
1
].state =
0
;
178
memdata[j+
1
].jobid =
0
;
179
memdata[j+
1
].head = memdata[j].length +
memdata[j].head;
180
++
memsum;
181
}
182
}
183
184
int
mem_locate(
int
id){
//
根据作业ID，查找jobdata的id在数组memdata的位置
185
int
i;
186
for
(i=
0
;i<memsum;++
i)
187
if
(id ==
memdata[i].jobid)
188
return
i;
189
return
-
1
;
190
}
191
192
void
mem_redraw(
int
k){
//
作业回收
193
int
i;
194
int
t =
mem_locate(k);
195
printf(
"
t : %d\n
"
, t);
196
if
(t == -
1
)
return
;
197
198
memdata[t].state =
0
;
199
memdata[t].jobid =
0
;
200
201
if
( t >
0
&& memdata[t-
1
].state ==
0
){
202
memdata[t-
1
].state =
0
;
203
memdata[t-
1
].jobid =
0
;
204
memdata[t-
1
].length +=
memdata[t].length;
205
for
(i=t+
1
;i<memsum;++
i)
206
memdata[i-
1
] =
memdata[i];
207
--
memsum;
208
--
t;
209
}
210
if
(t+
1
<= memsum && memdata[t+
1
].state ==
0
){
211
memdata[t].state =
0
;
212
memdata[t].jobid =
0
;
213
memdata[t].length += memdata[t+
1
].length;
214
for
(i=t+
2
;i<memsum;++
i)
215
memdata[i-
1
] =
memdata[i];
216
--
memsum;
217
}
218
}
219
220
void
mem_restore(){
//
内存状态还原
221
int
k;
222
memsum =
9
;
223
for
(k=
0
;k<memsum;++
k){
224
memdata[k].head = membackup[k-
1
].head;
225
memdata[k].jobid = membackup[k-
1
].jobid;
226
memdata[k].state = membackup[k-
1
].state;
227
memdata[k].length = membackup[k-
1
].length;
228
}
229
for
(k=memsum;k<max;++
k){
230
memdata[k].head =
0
;
231
memdata[k].jobid =
0
;
232
memdata[k].state =
0
;
233
memdata[k].length =
0
;
234
}
235
}
236
237
int
main(
int
argc,
char
const
*
argv[])
238
{
239
int
i, j, start;
240
printf(
"
\n------------The current memory state----------!\n
"
);
241
mem_state();
242
_keygo();
243
printf(
"
\n------------The work allocate start-----------!\n
"
);
244
start =
5
;
245
for
(i=start;i<jobsum;++
i){
246
printf(
"
The work %s wait to allocate, The size is %iK\n
"
, jobdata[i].name, jobdata[i].vol);
247
_sleep(
1
);
248
j =
mem_allocate_ff(i);
249
printf(
"
The allocate : %d\n
"
, j);
250
if
(j == -
1
) printf(
"
The work %s is too big, the allocation is failed\n
"
, jobdata[i].name);
251
else
{
252
printf(
"
allocation space to The work %s\n
"
, jobdata[i].name);
253
mem_allocate(i, j);
254
mem_state();
255
}
256
_keygo();
257
}
258
printf(
"
----------------The allocation over!---------\n
"
);
259
printf(
"
restore the memory!\n
"
);
260
printf(
"
\n----------------The current memory state------------\n
"
);
261
mem_state();
262
j =
88
;
263
while
(j !=
0
){
264
printf(
"
\n Please choose the job No:
"
);
265
scanf(
"
%d
"
, &
j);
266
mem_redraw(j);
267
printf(
"
\nThe restore success !\n
"
);
268
printf(
"
\n-------------The current memory state---------\n
"
);
269
mem_state();
270
}
271
_keygo();
272
return
0
;
273
}
