操作系统实验报告012244杨紫淇Word格式文档下载.docx
《操作系统实验报告012244杨紫淇Word格式文档下载.docx》由会员分享，可在线阅读，更多相关《操作系统实验报告012244杨紫淇Word格式文档下载.docx（16页珍藏版）》请在冰豆网上搜索。
//分配虚拟内存
if（BaseAddr==NULL）
printf（"
VirtualAllocateFail\n"
str=（char*）malloc（1024*1024*2）;
//分配内存
GetMemSta（）;
NowRelease32MVirtualMemoryand2MPhysicalMemory\n\n"
if（VirtualFree（BaseAddr,0,MEM_RELEASE）==0）//释放虚拟内存
ReleaseAllocateFail\n"
）;
free（str）;
//释放内存
returnnRetCode;
}
voidGetMemSta（void）//统计内存的状态
MEMORYSTATUSMemInfo;
GlobalMemoryStatus（&
MemInfo）;
\tCurrentMemoryStatusis:
\n"
\tTotalPhysicalMemoryis%dMB\n"
MemInfo.dwTotalPhys/（1024*1024））;
\tAvailablePhysicalMemoryis%dMB\n"
MemInfo.dwAvailPhys/（1024*1024））;
\tTotalPageFileis%dMB\n"
MemInfo.dwTotalPageFile/（1024*1024））;
\tAvailablePageFileis%dMB\n"
MemInfo.dwAvailPageFile/（1024*1024））;
\tTotalVirtualMemoryis%dMB\n"
MemInfo.dwTotalVirtual/（1024*1024））;
\tAvailableVirtualMemoryis%dMB\n"
MemInfo.dwAvailVirtual/（1024*1024））;
\tMemoryLoadis%d%%\n\n"
MemInfo.dwMemoryLoad）;
运行截图：
二.教材6.8.2早期的磁盘调度算法，用c语言编程实现：
#include<
stdio.h>
stdlib.h>
time.h>
Windows.h>
/*先来先服务（FCFS）*/
voidFCFS（inta[],intn）
intsum=0,i,j,now;
printf（"
请输入当前磁道号：
\n"
scanf（"
%d"
&
now）;
sum+=abs（a[0]-now）;
从当前位置到第1个磁道移动的磁道数：
\t%d\n"
sum）;
for（i=0,j=1;
j<
n;
j++,i++）{
sum+=abs（a[j]-a[i]）;
从第%d磁道到第%d磁道移动的磁道数：
i+1,j+1,abs（a[j]-a[i]））;
}
移动的总磁道数：
%d\n"
移动的平均寻道长度：
%.2lf\n"
1.0*sum/n）;
请再次输入你想使用的方法：
/*最短寻道时间函数SSTF*/
voidSSTF（inta[],intn）{
inttemp;
intnow;
intsum=0,i,j,k=0;
//冒泡排序法对磁道号进行排序
排序后的磁道分布：
for（i=0;
i<
i++）{
for（j=i+1;
j++）{
if（a[i]>
a[j]）{
temp=a[i];
a[i]=a[j];
a[j]=temp;
%d\t"
a[i]）;
if（i%10==9）{
请输入当前磁道号:
if（a[0]>
=now）{
当前访问的磁道%d\n"
a[0]）;
n-1;
当前访问的磁道：
a[i+1]）;
sum=a[n-1]-now;
elseif（a[n-1]<
=now）{
a[n-1]）;
for（j=n-1;
i<
n-1;
j--）{
a[j-1]）;
sum=now-a[0];
else{
while（a[k]<
now）{
k++;
j=k-1;
i=0;
while（（j>
=0）&
&
（k<
n））{
i++;
if（now-a[j]>
=a[k]-now）{
a[k]）;
sum+=a[k]-now;
now=a[k];
a[j]）;
sum+=now-a[j];
now=a[j];
j--;
if（k>
n-1）{
for（intt=j;
t>
0;
t--）{
if（t==j）{
a[j]）;
a[t+1]）;
sum+=a[n-1]-a[0];
if（j<
0）{
for（intt=k;
t<
t++）{
if（t==k）{
a[k]）;
a[t]）;
经过的总磁道数为：
/*扫描算法*/
voidSCAN（inta[],intn）{
intsum=0,i,j,k=0;
\n请输入当前磁道号:
n-1;
a[i+1]）;
a[n-1]）;
for（j=n-1;
n-1;
j--）{
a[j-1]）;
sum=now-a[0];
intd;
j=k-1;
请输入当前磁头移动的方向（0向内，1向外）：
d）;
if（d==1）{
sum+=a[t]-now;
now=a[t];
for（intp=j;
p>
=0;
p--）{
a[p]）;
elseif（d==0）{
for（intm=j;
m>
=0;
m--）{
a[m]）;
sum+=now-a[m];
now=a[m];
for（intz=k;
z<
z++）{
a[z]）;
输入错误，重新回到选择算法界面！
1.0*sum/n）;
/*循环扫描算法*/
voidCSCAN（inta[],intn）{
i>
a[j-1]）;
inti=0;
a[t]）;
for（intb=0;
b<
k;
b++）{
a[b]）;
sum+=a[n-1]-a[0]+a[j]-a[0];
sum+=now-a[t];
for（intc=n-1;
c>
=k;
c--）{
a[c]）;
sum+=a[n-1]-a[0]+a[n-1]-a[k];
/*主函数*/
voidmain（）{
intn;
//磁道数
intcontrol=1;
//控制处理的方式
请输入要处理的磁道数：
&
n）;
intc[1000];
随机生成磁道号：
srand（（unsigned）time（NULL））;
//srand（（unsigned）time（NULL））;
for（inti=0;
c[i]=（rand（）%100）+1;
c[i]）;
if（i%10==9）{
\n数据生成成功！
******************************************************\n"
------\n"
-----------------------算法选择-----------------------\n"
---1.先来先服务算法---\n"
---2.最短寻道时间算法---\n"
---3.扫描算法---\n"
---4.循环扫描算法---\n"
---0.退出程序---\n"
/*算法选择*/
请输入你想使用的方法：
while（control）{
control）;
switch（control）{
case0:
break;
case1:
FCFS（c,n）;
case2:
SSTF（c,n）;
case3:
SCAN（c,n）;
case4:
CSCAN（c,n）;
default:
选项错误!
重新选择！
"
程序退出成功，谢谢使用！
system（"
pause"
运行过程截图：
总结：
1、先来先服务算法（FCFS）FirstComeFirstService
这是一种比较简单的磁盘调度算法。
它根据进程请求访问磁盘的先后次序进行调度。
此算法的优点是公平、简单，且每个进程的请求都能依次得到处理，不会出现某一进程的请求长期得不到满足的情况。
此算法由于未对寻道进行优化，在对磁盘的访问请求比较多的情况下，此算法将降低设备服务的吞吐量，致使平均寻道时间可能较长，但各进程得到服务的响应时间的变化幅度较小。
2、最短寻道时间优先算法（SSTF）ShortestSeekTimeFirst
该算法选择这样的进程，其要求访问的磁道与当前磁头所在的磁道距离最近，以使每次的寻道时间最短，该算法可以得到比较好的吞吐量，但却不能保证平均寻道时间最短。
其缺点是对用户的服务请求的响应机会不是均等的，因而导致响应时间的变化幅度很大。
在服务请求很多的情况下，对内外边缘磁道的请求将会无限期的被延迟，有些请求的响应时间将不可预期。
3、扫描算法（SCAN）电梯调度
扫描算法不仅考虑到欲访问的磁道与当前磁道的距离，更优先考虑的是磁头的当前移动方向。
例如，当磁头正在自里向外移动时，扫描算法所选择的下一个访问对象应是其欲访问的磁道既在当前磁道之外，又是距离最近的。
这样自里向外地访问，直到再无更外的磁道需要访问才将磁臂换向，自外向里移动。
这时，同样也是每次选择这样的进程来调度，即其要访问的磁道，在当前磁道之内，从而避免了饥饿现象的出现。
由于这种算法中磁头移动的规律颇似电梯的运行，故又称为电梯调度算法。
此算法基本上克服了最短寻道时间优先算法的服务集中于中间磁道和响应时间变化比较大的缺点，而具有最短寻道时间优先算法的优点即吞吐量较大，平均响应时间较小，但由于是摆动式的扫描方法，两侧磁道被访问的频率仍低于中间磁道。
4、循环扫描算法（CSCAN）
循环扫描算法是对扫描算法的改进。
如果对磁道的访问请求是均匀分布的，当磁头到达磁盘的一端，并反向运动时落在磁头之后的访问请求相对较少。
这是由于这些磁道刚被处理，而磁盘另一端的请求密度相当高，且这些访问请求等待的时间较长，为了解决这种情况，循环扫描算法规定磁头单向移动。
例如，只自里向外移动，当磁头移到最外的被访问磁道时，磁头立即返回到最里的欲访磁道，即将最小磁道号紧接着最大磁道号构成循环，进行扫描。
升级会员 