深圳大学 操作系统实验二 进程调度.docx

深圳大学 操作系统实验二 进程调度.docx

《深圳大学 操作系统实验二 进程调度.docx》由会员分享，可在线阅读，更多相关《深圳大学 操作系统实验二 进程调度.docx（44页珍藏版）》请在冰豆网上搜索。

深圳大学操作系统实验二进程调度

深圳大学实验报告

课程名称：

操作系统

实验项目名称：

CPU调度

学院：

计算机与软件学院

专业：

软件工程

指导教师：

梁正平

报告人：

学号：

班级：

2

实验时间：

实验报告提交时间：

教务处制

一、实验目的与完成说明：

实验一：

实现CPU调度的先来先服务算法，调度对象是进程，包含属性：

名称、到达时间、运行时间，对象属性可根据不同算法可自行添加。

本算法以进程的到达时间最早为优先，要求用一个函数来实现，不要写在main函数中。

实验二：

实现CPU调度的短作业优先算法，调度对象是进程，包含属性：

名称、到达时间、运行时间等，对象属性根据不同算法可自行添加。

以进程的运行时间最短为优先，调度算法不要写在main函数中，要另外定义一个函数SJF来实现。

实验三：

实现CPU调度的高响应比优先算法，调度对象是进程，包含属性：

名称、到达时间、运行时间等，对象属性根据不同算法可自行添加。

算法分析：

本题目不能够简单地把所有程序的运行时间进行排序，在每一轮先检查是否有程序到达且未执行，如果符合条件只有一个，就直接调度；如果有多个，计算程序的响应比，最大的程序获得调度。

实验四：

实现CPU调度的时间片轮转算法，调度对象是进程，包含属性：

名称、到达时间、运行时间等，对象属性根据不同算法可自行添加。

算法分析：

该算法按照先来先服务的思想分配一个时间片给进程，如果进程在时间片内没有完成，则排到队列末尾等待重新分配。

注意：

如果进程在一个时间片内完成且时间片未用完，那么把剩余时间送给下一个进程。

例如一个进程还需要CPU运行1秒，时间片为3，当分配一个时间给它，它运行1秒后完成，就把剩余的2秒送给下一个进程，因此下一个进程有5秒运行。

实验五：

实现CPU调度的多级反馈队列算法，调度对象·是进程，包含属性：

名称、到达时间、运行时间等，对象属性根据不同算法可自行添加。

二、主要思路与方法：

一：

voidFCFS:

:

timesSort（intnum）

{

inti=0,j=0;

for（i=0;i<=num;i++）

{

Process*h=head;

Process*p=h->next;

Process*q=p->next;

for（j=0;j<=num;j++）

{

if（p->arriveTimearriveTime）

{

if（q->next）{

h=p;

p=q;

q=q->next;

}

}

else

{

h->next=q;

p->next=q->next;

q->next=p;

if（q->next）{

h=p;

p=q;

q=q->next;

}

}

}

}

}

二：

voidSJF（inta[10],intb[10],charx[10],intn）

{

intii,flag[10],tnum=0,timer=10000;

inti,temp=10000,temp1;

floatrt[10],gt[10];

floatxx;

charzm[10];

for（i=0;i

{

flag[i]=0;

}

for（i=0;i

{

if（timer>a[i]）

{

timer=a[i];

}

}

while（n-tnum）

{

ii=-1,temp1=10000;//标识下当前时刻是否有进程

for（i=0;i

{

if（timer>a[i]&&flag[i]==0）//判断现在时间与到达的程序

{

//cout<<"af"<

if（temp1>b[i]）//找出最小执行时间的程序

{

temp1=b[i];

ii=i;//保存该序号

//cout<<""<

}

}

}

if（ii!

=-1&&flag[ii]==0）

{

//cout<<"asdsdggsg"<

zm[tnum]=x[ii];

gt[tnum]=a[ii];

rt[tnum]=b[ii];

timer=timer+b[ii];

flag[ii]=1;

tnum=tnum+1;

}

else

{

timer=timer+1;

}

}

//cout<<"dfagaggga"<

for（i=0;i

{

cout<

}

cout<

for（i=0,xx=gt[i];i

{

xx+=rt[i];

cout<

}

cout<

for（i=0,xx=gt[i];i

{

xx+=rt[i];

cout<

}

cout<

for（i=0,xx=gt[i];i

{

xx+=rt[i];

cout<

（2）<<（xx-gt[i]）/rt[i]<<"";

}

}

三：

voidFPF:

:

getSort（）

{

while

（1）

{

inti=0;

for（i=0;i

if（process[i].flag==false&&process[i].arriTime

process[i].rp=（now-process[i].arriTime+process[i].serriTime）/process[i].serriTime;

intrpMax=0;

for（i=1;i

if（process[rpMax].rp

rpMax=i;

elseif（process[rpMax].rp==process[i].rp&&process[rpMax].arriTime>process[i].arriTime）

rpMax=i;

if（process[rpMax].flag==true）break;

if（getTime（rpMax）==0）break;

}

}

实验四：

voidFPF:

:

getSort（）

{

qWork.push（process[hav]）;

now=qWork.front（）.arriTime;

while（!

qWork.empty（））

{

Processp=qWork.front（）;

if（p.serriTime<=（T+moreTime））

{

intn=getTime（p）;

finishProcess[finish]=p;

finish++;

qWork.pop（）;

isNewProcess（）;

if（n==0）break;

}

else

{

now=now+T;

isNewProcess（）;

qWork.pop（）;

p.serriTime=p.serriTime-T;

qWork.push（p）;

}

}

}

实验五：

voidFPF:

:

getSort（）

{

qWork[qhav].push（process[hav]）;

now=qWork[qhav].front（）.arriTime;

while（!

qWork[qhav].empty（））

{

Processp=qWork[qhav].front（）;

if（（T[qhav]-p.serriveTime）>=p.serriTime）

{

if（hav+1process[hav+1].arriTime）

isNewProcess（）;

elseif（hav+1

{

now=p.serriTime+now;

p.finishTime=now;

finishProcess[finish]=p;

finish++;

hav++;

qWork[qhav].pop（）;

qhav=0;

now=process[hav].arriTime;

process[hav].flag=true;

qWork[qhav].push（process[hav]）;

}

else//不被抢占,完成p进程

{

now=now+p.serriTime;

p.finishTime=now;

qWork[qhav].pop（）;

finishProcess[finish]=p;

finish++;

while（qhav<4&&qWork[qhav].empty（））

{

qhav++;

}

if（qhav==4&&hav+1

{

hav++;

qhav=0;

now=process[hav].arriTime;

process[hav].flag=true;

qWork[qhav].push（process[hav]）;

}

}

}

else

{

if（hav+1process[hav+1].arriTime）

isNewProcess（）;

else

{

p.serriTime=p.serriTime-T[qhav]+p.serriveTime;

now=now+（T[qhav]-p.serriveTime）;

p.serriveTime=0;

qWork[qhav].pop（）;

qWork[qhav+1].push（p）;

if（now==process[hav+1].arriTime）

newProcess（）;

while（qWork[qhav].empty（）&&qhav<4）

{

qhav++;

}

}

}

}

}

三．实验程序或内容：

实验一：

#include

#include

usingnamespacestd;

classProcess

{

public:

    charprocessName;

    intarriveTime;

    floatserviceTime;

    intstartTime;

    intfinishTime;

    floatturnaroundTime;

    floattimeWithWeight;

    Process*next;

    Process（）{

        next=NULL,

        arriveTime=0;

        serviceTime=0;

        startTime=0;

        finishTime=0;

        turnaroundTime=0;

        timeWithWeight=0;

    }

};

classFCFS

{

protected:

    Process*head;

    Process*current;

    voidtimesSort（intnum）;

    intprocessNum;

public:

    FCFS（）;

    voidcreateList（）;

    voidgetTimes（）;

    voiddisplay（）;

    intisOhterProcess（）;

};

FCFS:

:

FCFS（）

{

    head=newProcess（）;

    current=newProcess（）;

    head->next=current;

}

voidFCFS:

:

createList（）

{

    intgetNum,i=0;

    cin>>getNum;

    processNum=getNum;

    cin>>current->processName;

    for（i=1;i

    {

        Process*q=newProcess（）;

        cin>>q->processName;

        if（i==getNum）break;

        else

        {  

            current->next=q;

            current=q;

        }

    }

    current=head->next;

    cin>>current->arriveTime;

    Process*p=current;

    for（i=1;i

    {

        p=current->next;

        cin>>p->arriveTime;

        if（p->next）

        {  

            current->next=p;

            current=p;

        }

        elsebreak;

    }

    current=head->next;

    cin>>current->serviceTime;

    p=current;

    for（i=1;i

    {

        p=current->next;

        cin>>p->serviceTime;

        if（p->next）

        {  

            current->next=p;

            current=p;

        }

        elsebreak;

    }

    timesSort（getNum）;

}

voidFCFS:

:

timesSort（intnum）

{

    inti=0,j=0;

    for（i=0;i<=num;i++）

    {

        Process*h=head;

        Process*p=h->next;

        Process*q=p->next;

        for（j=0;j<=num;j++）

        {

            if（p->arriveTimearriveTime）

            {

                if（q->next）{

                    h=p;

                    p=q;

                    q=q->next;

                }

            }

            else

            {

                h->next=q;

                p->next=q->next;

                q->next=p;

                if（q->next）{

                    h=p;

                    p=q;

                    q=q->next;

                }

            }

        }

    }

}

voidFCFS:

:

getTimes（）

{

    current=head->next;

    current->startTime=current->arriveTime;

    current->finishTime=current->startTime+current->serviceTime;

    current->turnaroundTime=current->finishTime-current->arriveTime;

    current->timeWithWeight=current->turnaroundTime/current->serviceTime;

    while（current->next）

    {

        Process*p=current->next;

        p->startTime=current->finishTime;

        p->finishTime=p->startTime+p->serviceTime;

        p->turnaroundTime=p->finishTime-p->arriveTime;

        p->timeWithWeight=p->turnaroundTime/p->serviceTime;

        current=current->next;

        if（current->next==NULL）break;

    }

}

intFCFS:

:

isOhterProcess（）

{

    cout<<"isotherprocess?

"<

    Process*p=newProcess（）;

    cin>>p->arriveTime>>p->serviceTime;

    current=head->next;

    while（current->next）

    {

        current=current->next;

    }

    current->next=p;

    if（p->arriveTime>current->finishTime）

        p->startTime=p->arriveTime;

    else

        p->startTime=current->finishTime;

    p->finishTime=p->startTime+p->serviceTime;

    p->turnaroundTime=p->finishTime-p->arriveTime;

    p->timeWithWeight=p->turnaroundTime/p->serviceTime;

    return0;

}

voidFCFS:

:

display（）

{

    current=head->next;

    while

（1）

    {

        cout<processName<<"";

        if（current->next）

            current=current->next;

        elsebreak;

    }

    cout<

    current=head->next;

    while

（1）

    {

        cout<finishTime<<"";

        if（current->next）

            current=current->next;

        elsebreak;

    }

    cout<

    current=head->next;

    while

（1）

    {

        cout<turnaroundTime<<"";

        if（current->next）

            current=current->next;

        elsebreak;

    }

    cout<

    current=head->next;

    while

（1）

    {

        cout<

（2）<timeWithWeight<<"";

        if（current->next）

            current=current->next;

        elsebreak;

    }

    cout<

}

intmain（）

{

    FCFSfcfs;

    fcfs.createList（）;

    fcfs.getTimes（）;

    fcfs.display（）;

    return0;

}

实验二：

#include

#include

usingnamespacestd;

void SJF（inta[10],intb[10],charx[10],intn）

{

    intii,flag[10],tnum=0,timer=10000;

    inti,temp=10000,temp1;

    floatrt[10],gt[10];

    floatxx;

    charzm[10];

    for（i=0;i

    {

        flag[i]=0;

    }

    for（i=0;i

    {

        if（timer>a[i]）

        {

            tim