带权周转时间_什么是平均带权周转时间

调度顺InitialQueue(Q, ProcessTable, processnum);序是abcde

周转时间:

a:4

b:2+7=9 (a运行时间4,所以b的等待时间为2,运行时间为7)

d:7+3=10 (a+b+c运行时间是15,所以d等待时间是7,运行时间是3)

e:8+2=10 (前4个运行时间是18,e的等待时间是8,运行时间是2)

所以平均周转时间:

(4+9+10+10+10)/5=8.6

调度顺序是:abedc

理由-a先到,运行时间4,运行结束后只有b到达,所以b运行,b运行结束后总时间为11,此时cde都到达出于等待中,所以调度最短服务时间的e,然后是次短的d,c

周转时间:(跟上面一样,等待时间+运行时间)

a:4

b:2+7=9

e:1+2=3 (b运行完时间是11,而e在10才来,所以等待时间是1)

c:11+4=15 (abed运行结束后时间是16,c等待了11)

所以平均周转时间:

(4+9+3+8+15)/5=7.8

带权:

(4qa+9qb+3qc+8qd+15qe)/5

作系统中,有五个作业同时到达响应比怎么算

A在4完成.（B,C,D,E）的响应比为（2,1.4,1,5,1）

B在7完成.（C,D,E）的响应比为（{int processID; //进程ID2,3,1.75）

其后依次D,C,E完成时间9,14,18

每个进程的带权周转时间为（1,2,2.4,3,3.5）,那么平均值就是2.38

跪求作系统帝！！关于一个SJF算法的问题！！

非抢占式SJF算法

0时刻A执行，3个时间，周转时间3.

3时刻B等了1个时间，而C还没到执行B，6个时间，到达时间按9，周转时间7.

9时刻CDE都到了等待。E的工作时间最短，执行E，2个时间到达11，周转时间3.

11时刻CD在等待。C需求时间短，C执行，4个时间，到达15，周转时间11.

15时刻D执行，5个时间，到达20整个完【1】安全，因为存在安全序列；(安全序列有多个，只要证明存在一个即安全)成，周转时间是14.

平均周转时间=(3+7+3+11+14)/5=7.6

带权平均周转时间=（void InitialQueue(LinkQueue& Q, PCBNode ProcessTable,const int processnum)3/3+7/6+3/2+11/4+14/5）/5=1.84

计算在单道程序环境下，采用先来先服务调度算法和最短作业优先调度算法的平均周转时间

答:(1)先来先服务调度：

顺序： 1．Tsl：10：00 Tel：12：00 T1：2．00 Twl:0

2．Ts2：10：20 Te2：13：00 T2：1．00 Tw2:1．70

3．Ts3：10：40 Te3：13：30 T3: 0．50 Tw3：2．30

4．Ts4：10：50 Te4：13：50 T4: 0．30 Tw4：2．70

平均周如果知道权值的话则分别乘以权值即可转时间：0．25(2+2．7+2，8+3)=2．625 h

平均带权周转时间: 0．25(4+0+1．7／1+2．3／0．5+2．7／0．3)=4．825

(2)最短作业优先调度:

2．Ts3：10：40 Te3：11：40 T3: 0．5 Tw3：0．5

3．Ts2；10，20 Te2：12：40 T2: 1 Tw2: 1．3

4．Tsl：10：00 Tel: 14：40 T1：2 ProcessTable[q->ID].finishTime = ProcessTable[p->ID].finishTime + ProcessTable[q->ID].reqTime;Twl：2．7

调度顺序为1432

平均周转时间：0．25(0．3+1+2．3+4．7) =2．075 h

平均带权周转时间: 0．25(4+0+1+1．3+2．7／2)=1．25

作系统问题

1.

【先来先服务】

作业执行顺序：A、B、C、D

平均周转时间：t=1.725

带权周转时间：t=设你的系统是win7,而你参照的代码是在xp上面写的【就是调用xp的底层的接口】，有些会出现这种问题。。。你就行你安装一个不符合这个系统版本的软件，不是也是会提示类似的错误？7.125

【短作业优先】QueueNode p;

作业执行顺序：C、D、B、A

平均周转时间：t=1.55

带权周转时间：t=5.15

时间的位数保留看你自己了，一般是整数。

【2】不应该满足，否则不存在安全序列。

多说一句哈，一般情况下，这两个题是OS必考送分内容，LZ自己还是多注意一下吧。

哪位大神用先来先服务调度，求周转时间和平均周转时间来帮我编程

#includep = q;

#include

#include

#include

using namespace std;

STATUS status; //进程状态

int priorityNum; //优先数

int reqTime; //总的需要运行时间

int remainTime; //剩下需要运行时间

int arriveTime; //进入就绪队列时间

int startTime; //开始运行时间

int totalTime; //周转时间

float weightTotalTime; //带权周转时间

struct QueueNode

{int ID; //进程ID

struct QueueNode next; //队列中下一个进程指针

struct LinkQueue

{QueueNode head;//队首

void Fcfs(LinkQueue& Q, int& totalTimeSum, int& weightTotalTimeSum,PCBNode ProcessTable);

bool RR_Run(LinkQueue& Q,QueueNode q, QueueNode p, const int Round,int& currentTime,PCBNode ProcessTable);

//分配时间片给q所指进程,p为刚退出的进程

void RoundRobin(LinkQueue& Q,const int Round, int& totalTimeSum, int& weightTotalTimeSum,PCBNode ProcessTable);

//时间片轮转调度,调用RR_Run(),时间片大小设为Round

void InitialQueue(LinkQueue& Q,PCBNode ProcessTable,const int processnum);

//初始化就绪队列

void Input(PCBNode ProcessTable, const int processnum);

//从input.txt文件输入数据

int main()

{LinkQueue Q;//就绪队列

Q.head = NULL;

const int processnum = 16;//进程数

const int Round = 1; //时间片大小

int totalTimeSum = 0; //周转时间

int WeightTotalTimeSum = 0;//带权周转时间

PCBNode ProcessTable=new PCBNode[processnum]; //进程表

Input(ProcessTable, processnum);

RoundRobin(Q, Round, totalTimeSum,WeightTotalTimeSum,ProcessTable);

cout<<"时间片轮调度的平均周转时间为:"<

Input(ProcessTable, processnum);

Fcfs(Q, totalTimeSum,WeightTotalTimeSum,ProcessTable);

cout<<"先来先服务的平均带权周转时间为:"<

delete [] ProcessTable;

return 0;

}void RoundRobin(LinkQueue& Q,const int Round, int& totalTimeSum, int& weightTotalTimeSum,PCBNode ProcessTable)

{totalTimeSum = 0; //总的周转时间

weightTotalTimeSum = 0;//平均周转时间

QueueNode q;

QueueNode r;

bool finish = false;//调用RR_Run()后,该进程是否已经做完退出

p = Q.head;

q = p->next;

while (q != NULL)//从队首开始依次分配时间片

{do

{cout<<""<

cout<<"在时间片"<<(currentTime+1)/Round<<"内,活动进程为: "<ID<

cout<<"进程"<ID<<" 现在需要的时间片为: "<ID].remainTime<

cout<

if (!finish)//若是进程在本时间片内做完,则跳出do…while循环

{if (q->next == NULL)

}else

{r = q->next;

}}

{totalTimeSum += ProcessTable[q->ID].totalTime;

weightTotalTimeSum += ProcessTable[q->ID].weightTotalTime;

delete q; //从队列中删除q进程

q = p;

}}while (!finish && (ProcessTable[r->ID].arriveTime > currentTime + Round));

//下一个进程很晚才来,则继续给当前进程分配时间片

q = q->next;

if (q == NULL && Q.head->next!=NULL)

{p = Q.head;

q = p->next;

}}

delete Q.head;

Q.head = NULL;

}bool RR_Run(LinkQueue& Q,QueueNode q, QueueNode p, const int Round,int& currentTime,PCBNode ProcessTable)

{ProcessTable[q->ID].finishTime = currentTime + ProcessTable[q->ID].remainTime;

ProcessTable[q->ID].totalTime += ProcessTable[q->ID].remainTime;

ProcessTable[q->ID].weightTotalTime = ProcessTable[q->ID].totalTime/ProcessTable[q->ID].reqTime;

currentTime = ProcessTable[q->ID].finishTime;

p->next = q->next;

cout<

cout<<"进程"<ID<<"完成!"<

return true;

}else//此时间片内做不完

{ProcessTable[q->ID].remainTime = ProcessTable[q->ID].remainTime - Round;

ProcessTable[q->ID].totalTime += Round;

return false;

}}

void Fcfs(LinkQueue& Q, int& totalTimeSum, int& weightTotalTimeSum,PCBNode ProcessTable)

{totalTimeSum = 0;

weightTotalTimeSum = 0;//平均周转时间

QueueNode q;

p = Q.head->next;

if (p !=NULL )

ProcessTable[p->ID].finishTime = ProcessTable[p->ID].arriveTime + ProcessTable[p->ID].reqTime;

}for(q=p->next; q!=NULL; q=q->next)

{if (ProcessTable[q->ID].arriveTime < ProcessTable[p->ID].finishTime)

{ProcessTable[q->ID].startTime = ProcessTable[p->ID].finishTime;

}else//下个进程到达时间较晚

{ProcessTable[q->ID].startTime = ProcessTable[q->ID].arriveTime;

ProcessTable[q->ID].finishTime = ProcessTable[q->ID].arriveTime + ProcessTable[q->ID].reqTime;

}for(q=Q.currentTime += Round;head->next; q!=NULL; q=q->next)

{ProcessTable[q->ID].totalTime = ProcessTable[q->ID].finishTime - ProcessTable[q->ID].arriveTime;

ProcessTable[q->ID].weightTotalTime = ProcessTable[q->ID].totalTime/ProcessTable[q->ID].reqTime;

totalTimeSum += ProcessTable[q->ID].totalTime;

weightTotalTimeSum += ProcessTable[q->ID].weightTotalTime;

}int t = 0;

for(q=Q.head->next; q!=NULL; q=q->next)

while ( tID].finishTime )

{cout<<"时刻"<ID<<"活动"<

t++;

}if (q->next != NULL)

{cout<<"时刻"<ID<<"结束活动,开始下一个进程."<

cout<<"进程"<ID<<"的周转时间为: "<ID].totalTime<

cout<<"进程"<ID<<"的带权周转时间为: "<ID].weightTotalTime<

}else

{cout<<"时刻"<ID<<"结束活动."<

cout<<"进程"<ID<<"的周转时间为: "<ID].totalTime<

cout<<"进程"<ID<<"的带权周转时间为: "<ID].weightTotalTime<

}}

cout<<"所有进程结束活动."<

p = Q.head;

for(q=p->next; q!=NULL; q=q->next)

{delete p;

}}

{//初始化

for (int i=0;i

{ProcessTable[i].processID=i;

ProcessTable[i].reqTime=ProcessTable[i].remainTime;

ProcessTable[i].finishTime=0;

ProcessTable[i].startTime=0;

ProcessTable[i].status=WAIT;

ProcessTable[i].totalTime=0;

ProcessTable[i].weightTotalTime=0;

Q.head->next = NULL;

QueueNode p;

QueueNode q;

for (i=0;i

{p = new QueueNode;

p->ID = i;

p->next = NULL;

if (i == 0)

{Q.head->next = p;

}else

q = p;

}}

{FILE fp; //读入线程的相关内容

if((fp=fopen("input.txt","r"))==NULL)

{cout<<"can not open file!"<

exit(0);

}for(int i=0;i

{fscanf(fp,"%d %d %d",&ProcessTable[i].arriveTime,&ProcessTable[i].remainTime,&ProcessTable[i].priorityNum);

}fclose(fp);

}建议输入数据:input.txt

0 4 0

1 35 1

2 10 2

3 5 3

6 9 4

7 21 5

9 35 6

11 23 7

12 42 8

13 1 9

14 7 10

20 5 11

23 3 12

24 22 13

25 31 14

26 1 15

短作业优先算法中的运行时间怎么计算

1.先来先服务调度算法（FCFS）:就是按照各个作业进入系统的自然次序来调度作业。这种调度算法的优点是实现简单，公平。其缺点是没有考虑到系统中各种资源的综合使用情况，往往使短作业的用户不满意，因为短作业等待处理的时间可能比实际运行时间长得多。

2.短作业优先调度算法(SPF): 就是优先调度并处理短作业，所谓短是指作业的运行时间短。而在作业未投入运行时，并不能知道它实际的运行时间的长短，因此需要用户在提交作业时同时提交作业运行时间的估计值。

3.响应比优先算法(HRN)：FCFS可能造成短作业用户不满，SPF可能使得长作业用户不满，于是提出HRN，选择响应比的作业运行。响应比=1+作业等待时间/作业处理时间。

4. 基于优先数调度算法(HPF)：每一个作业规定一个表示该作业优先级别的整数，当需要将新的作业由输入井调入内存处理时，优先选择优先数的作业。

5.均衡调q->next = p;度算法，即多级队列调度算法

基本概念：

作业周转时间（Ti）＝完成时间(Tei)－提交时间(Tsi)

作业平均周转时调度顺序为1234间(T)＝周转时间/作业个数

作业带权周转时间（Wi）＝周转时间/运行时间

响应比＝（等待时间＋运行时间）/运行时间

一道关于作系统高响应比的题目求助！！！

A在4完成。（B,C,D,E）的响应比为（2，1.4，1，5，1）

B在7完成。（C,D,E）int finishTime; //结束运行时间的响应比为（2, 3, 1.75）

每个进程的带权周转时间为（1，2，2.4，3， 3.5），那么平均值就是2.38

作系统中基于时间片段的轮转调度算法，中时间片大小如何确定的