| 网站首页 | 业界新闻 | 小组 | 威客 | 人才 | 下载频道 | 博客 | 代码贴 | 在线编程 | 编程论坛
欢迎加入我们,一同切磋技术
用户名:   
 
密 码:  
共有 3448 人关注过本帖
标题:时间片轮转调度算法,帮看下
只看楼主 加入收藏
米小兔
Rank: 1
等 级:新手上路
帖 子:61
专家分:0
注 册:2012-7-14
结帖率:0
收藏
已结贴  问题点数:10 回复次数:41 
时间片轮转调度算法,帮看下
自己又用C++修改了一个代码,可是执行出来的效果,不是我想要的。看哪位大神能给我下面写的修改正确啊,憋死了。。。。还是自己没学好吧。

include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <iostream.h>

typedef struct node
{
char name[10];     
int prio;         
int round;         
int cputime;      
int needtime;
int gettime;   
int count;         
char state;        
struct node *next;
}PCB;
PCB *finish,*ready,*tail,*run; //队列指针
int N;     //进程数

void firstin()
{
run=ready;      //就绪队列头指针赋值给运行头指针
run->state='R'; //进程状态变为运行态
ready=ready->next; //就绪队列头指针后移到下一进程
}

void interrupt()//第一个CPU占用时间等于下一个进程的到达时间
{
if(ready->cputime==(ready->next)->gettime)
{
    ready=ready->next;
    ready->state='W';
}

}

//输出标题函数
void prt1(char a)
{
if(toupper(a)=='P')  //优先级法
  cout<<" "<<endl;
cout<<"进程名 到达的时间 占用CPU时间 到完成还要的时间 轮转时间片 状态"<<endl;
}

//进程PCB输出
void prt2(char a,PCB *q)
{
if(toupper(a)=='P')  //优先级法的输出
  cout<<q->name<<"       "<<q->gettime<<"       "<<q->cputime<<"           "<<q->needtime<<"               "<<q->round<<"         "<<q->state<<endl;
}
//输出函数
void prt(char algo)
{
PCB *p;
prt1(algo);  //输出标题
if(run!=NULL)  //如果运行指针不空
  prt2(algo,run);  //输出当前正在运行的PCB
p=ready;  //输出就绪队列PCB
while(p!=NULL)
{
  prt2(algo,p);
  p=p->next;
}
p=finish;   //输出完成队列的PCB
while(p!=NULL)
{
  prt2(algo,p);
  p=p->next;
}
getchar();  //按住任意键继续
}
//时间片轮转的插入算法
void insert(PCB *q)
{
PCB *p1,*s,*r;
s=q;  //待插入的PCB指针
p1=ready;  //就绪队列头指针
r=p1;  //*r做p1的前驱指针
while(p1!=NULL)
  if(p1->round<=s->round)
  {
   r=p1;
   p1=p1->next;
  }
  if(r!=p1)
  {
   r->next=s;
   s->next=p1;
  }
  else
  {
   s->next=p1;  //否则插入在就绪队列的头
   ready=s;
  }
}
//优先级创建初
void create(char alg)
{
PCB *p;
int i,gettime,time;
char na[10];
ready=NULL;  
finish=NULL;
run=NULL;   
cout<<"输入进程名,到达时间及其需要运行的时间:"<<endl;
for(i=1;i<=N;i++)
{
  p=new PCB;
  cin>>na;
  cin>>gettime;
  cin>>time;
  strcpy(p->name,na);
  p->cputime=0;
  p->gettime=gettime;
  p->needtime=time;
  if(gettime=0){p->state='W';}
  else {p->state='F';}
  p->round=0;
  if(ready!=NULL)  
   insert(p);
  else
  {
   p->next=ready;  
   ready=p;
  }
  cout<<"输入进程名,到达时间及其需要运行的时间:"<<endl;
}
prt(alg);  
run=ready;  
ready=ready->next;
run->state='R';
}
void timeslicecycle(char alg)
{cout<<"请输入时间片长度:";
int pertime;
cin>>pertime;
cout<<"输入时间片长度:"<<pertime<<endl;
while(run!=NULL)
{
  if(run->needtime>pertime)
    {
      run->cputime=run->cputime+pertime;
      run->needtime=run->needtime-pertime;
      run->round=run->round+pertime;
      run->state='W';
      interrupt();
      insert(run);
      interrupt();
      firstin();
    }
  else
   { int replace1,replace2;
     replace1=0;
     replace2=run->needtime;
     run->cputime=run->cputime+replace2;
     run->needtime=replace1;
     run->round=run->round+replace2;
     run->next=finish;
     finish=run;
     run->state='F';
     run=NULL;
     interrupt();
     if(ready!=NULL)
       firstin();
   }
  prt(alg);
}
}


//主函数
void main()
{
char algo='P';  //算法标记
cout<<"输入进程的个数:";
cin>>N;  //输入进程数
create(algo);  //创建进程
timeslicecycle(algo);  //优先级法调度
} //main()

这个代码,想要的结果,我打个比方,

输入进程的个数:4
输入进程名,到达时间及其需要运行的时间:
a 0 5
输入进程名,到达时间及其需要运行的时间:
b 1 3
输入进程名,到达时间及其需要运行的时间:
c 2 1
输入进程名,到达时间及其需要运行的时间:
d 3 6


进程名  到达的时间  占用cpu时间 到完成还要得时间 轮转时间片  状态
a       0            0           5               0           W
b       1            0           3               0           F
c       2            0           1               0           F
d       3            0           6               0           F
输入时间片长度:2
输入时间片长度为:2

进程名  到达的时间  占用cpu时间 到完成还要得时间 轮转时间片  状态
b       1            0           3               0           R
c       2            0           1               0           W
a       0            2           3               2           W
d       3            0           6               0           F

进程名  到达的时间  占用cpu时间 到完成还要得时间 轮转时间片  状态
c       2            0           1               0           R
a       0            2           3               2           W
d       3            0           6               0           W
b       1            2           1               2           W

进程名  到达的时间  占用cpu时间 到完成还要得时间 轮转时间片  状态
a       0            2           3               2           R
d       3            0           6               0           W
b       1            2           1               2           W
c       2            1           0               1           F

进程名  到达的时间  占用cpu时间 到完成还要得时间 轮转时间片  状态
d       3            0           6               0           R
b       1            2           1               2           W
c       2            1           0               1           F
a       0            4           1               4           W

进程名  到达的时间  占用cpu时间 到完成还要得时间 轮转时间片  状态
b       1            2           1               2           R
c       2            1           0               1           F
a       0            4           1               4           W
d       3            2           4               2           W

进程名  到达的时间  占用cpu时间 到完成还要得时间 轮转时间片  状态
a       0            4           1               4           R
d       3            2           4               2           W
b       1            3           0               3           F
c       2            1           0               1           F

进程名  到达的时间  占用cpu时间 到完成还要得时间 轮转时间片  状态
d       3            2           4               2           R
a       0            5           0               5           F
b       1            3           0               3           F
c       2            1           0               1           F

进程名  到达的时间  占用cpu时间 到完成还要得时间 轮转时间片  状态
d       3            4           2               4           R
a       0            5           0               5           F
b       1            3           0               3           F
c       2            1           0               1           F

进程名  到达的时间  占用cpu时间 到完成还要得时间 轮转时间片  状态
d       3            6           0               6           F
a       0            5           0               5           F
b       1            3           0               3           F
c       2            1           0               1           F

调度完成。。是这样一个意思
搜索更多相关主题的帖子: 时间 include count 
2013-04-10 16:21
米小兔
Rank: 1
等 级:新手上路
帖 子:61
专家分:0
注 册:2012-7-14
收藏
得分:0 
我去- - ,难道没有高手吗?高手都哪去了。。。求解答啊!头炸了!
2013-04-10 18:30
azzbcc
Rank: 19Rank: 19Rank: 19Rank: 19Rank: 19Rank: 19
来 自:江西财经大学
等 级:贵宾
威 望:81
帖 子:3293
专家分:12919
注 册:2012-11-4
收藏
得分:10 
那个状态是什么意思?


[fly]存在即是合理[/fly]
2013-04-10 18:40
米小兔
Rank: 1
等 级:新手上路
帖 子:61
专家分:0
注 册:2012-7-14
收藏
得分:0 
回复 3楼 azzbcc
R是运行态,W是就绪态,F是完成态
2013-04-10 18:50
azzbcc
Rank: 19Rank: 19Rank: 19Rank: 19Rank: 19Rank: 19
来 自:江西财经大学
等 级:贵宾
威 望:81
帖 子:3293
专家分:12919
注 册:2012-11-4
收藏
得分:0 
我先吃饭去啦,目前找到第一个错误
for(i=1;i<=N;i++)
{
  p=new PCB;
  cin>>na;
  cin>>gettime;
  cin>>time;
  strcpy(p->name,na);
  p->cputime=0;
  p->gettime=gettime;
  p->needtime=time;
  if(gettime=0){p->state='W';}
  else {p->state='F';}
  p->round=0;
  if(ready!=NULL)  
   insert(p);
  else
  {
   p->next=ready;  
   ready=p;
  }
  cout<<"输入进程名,到达时间及其需要运行的时间:"<<endl;
}


代码还没理解,可以说说你的思路么?回来再看

[ 本帖最后由 azzbcc 于 2013-4-10 20:12 编辑 ]


[fly]存在即是合理[/fly]
2013-04-10 18:55
azzbcc
Rank: 19Rank: 19Rank: 19Rank: 19Rank: 19Rank: 19
来 自:江西财经大学
等 级:贵宾
威 望:81
帖 子:3293
专家分:12919
注 册:2012-11-4
收藏
得分:0 
感觉用队列解决简单

额,原来就是队列


[fly]存在即是合理[/fly]
2013-04-10 19:00
米小兔
Rank: 1
等 级:新手上路
帖 子:61
专家分:0
注 册:2012-7-14
收藏
得分:0 
回复 5楼 azzbcc
思路就是基于时间片的轮转调度算法,我用手机不太方便打,这个您可以看下我上面举的那个例子。然后我的问题是在状态和时间片占用时间,cpu占用时间,还有随机到达时间,就是不是并发的进程,怎么调度,出问题了,我改了好多次,改不好了,哎,急,
2013-04-10 19:09
米小兔
Rank: 1
等 级:新手上路
帖 子:61
专家分:0
注 册:2012-7-14
收藏
得分:0 
2013-04-10 19:18
米小兔
Rank: 1
等 级:新手上路
帖 子:61
专家分:0
注 册:2012-7-14
收藏
得分:0 
求正解...我头炸了...
2013-04-10 19:56
米小兔
Rank: 1
等 级:新手上路
帖 子:61
专家分:0
注 册:2012-7-14
收藏
得分:0 
有人在看吗? 哇呜呜...
2013-04-10 20:01
快速回复:时间片轮转调度算法,帮看下
数据加载中...
 
   



关于我们 | 广告合作 | 编程中国 | 清除Cookies | TOP | 手机版

编程中国 版权所有,并保留所有权利。
Powered by Discuz, Processed in 0.016445 second(s), 7 queries.
Copyright©2004-2024, BCCN.NET, All Rights Reserved