目录
实验内容
实验目的
用高级语言编写和调试一个进程调度程序,以加深对进程的概念及进程调度算法的理解。
实验内容
1、设计简单的进程PCB 结构,完成进程信息记录;
2、设计一个有 N个进程并发执行的进程调度程序(以下三选一)
1)编写并调试一个模拟的进程调度程序,采用“最高优先数优先”调度算法对五个进程进行调度。“最高优先数优先”调度算法的基本思想是把CPU分配给就绪队列中优先数最高的进程。静态优先数是在创建进程时确定的,并在整个进程运行期间不再改变。动态优先数是指进程的优先数在创建进程时可以给定一个初始值,并且可以按一定原则修改优先数。例如:在进程获得一次CPU后就将其优先数减少1。或者进程等待的时间超过某一时限时增加其优先数的值,等等。
2)编写并调试一个模拟的进程调度程序,采用“轮转法”调度算法对五个进程进行调度。轮转法可以是简单轮转法、可变时间片轮转法,或多队列轮转法。简单轮转法的基本思想是:所有就绪进程按 FCFS排成一个队列,总是把处理机分配给队首的进程,各进程占用CPU的时间片相同。如果运行进程用完它的时间片后还为完成,就把它送回到就绪队列的末尾,把处理机重新分配给队首的进程。直至所有的进程运行完毕。
3)编写并调试一个模拟的进程调度程序,采用“短进程优先”调度算法对五个进程进行调度。
3、完成设计的调度算法的测试
使用下表进程(几乎同时到达)作为测试数据完成设计的调度算法的测试,输出各个进程的周转时间和带权周转时间,计算并输出平均周转时间和平均带权周转时间。
参考进程信息
进程名 | 到达时间 | 运行时间 | 优先级 |
---|---|---|---|
A | 0 | 3 | 2 |
B | 1 | 6 | 1 |
C | 2 | 4 | 3 |
D | 2 | 5 | 4 |
E | 2 | 2 | 5 |
实验代码
参考源码
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#define getpch(type) (type*)malloc(sizeof(type))
#define NULL 0
struct pcb{ /* 定义进程控制块PCB */
char name[10];
char state;
int super;
int ntime;
int rtime;
struct pcb* link;
}*ready=NULL,*p;
typedef struct pcb PCB;
void sort(){ /* 建立对进程进行优先级排列函数 */
PCB*first, *second;
int insert=0;
/*优先级最大者,插入队首*/
if((ready==NULL)||((p->super)>(ready->super))){
p->link=ready;
ready=p;
}
else{ /* 进程比较优先级,插入适当的位置中 */
first=ready;
second=first->link;
while(second!=NULL){
if((p->super)>(second->super))/*若插入进程比当前进程优先数大,*/
{ /*插入到当前进程前面*/
p->link=second;
first->link=p;
second=NULL;
insert=1;
}
else /*向后移动指针*/
{
first=first->link;
second=second->link;
}
}
/*插入进程优先数最低,则插入到队尾*/
if(insert==0) first->link=p;
}
}
void input() /* 建立进程控制块函数*/
{
int i,num;
system("dir");
//clrscr(); /*清屏*/
printf("\n 请输入进程数 ");
scanf("%d",&num);
for(i=0;i<num;i++){
printf("\n进程号No.%d:\n",i);
p=getpch(PCB);
printf("\n输入进程名:");
scanf("%s",p->name);
printf("\n输入进程优先数:");
scanf("%d",&p->super);
printf("\n输入进程运行时间:");
scanf("%d",&p->ntime);
printf("\n");
p->rtime=0;p->state='w';
p->link=NULL;
sort(); /*调用sort函数*/
}
}
int space(){
int l=0; PCB* pr=ready;
while(pr!=NULL)
{
l++;
pr=pr->link;
}
return(l);
}
void disp(PCB * pr) /*建立进程显示函数,用于显示当前进程*/
{
printf("\n qname \t state \t super \tndtime \t runtime \n");
printf("|%s\t",pr->name);
printf("|%c\t",pr->state);
printf("|%d\t",pr->super);
printf("|%d\t",pr->ntime);
printf("|%d\t",pr->rtime);
printf("\n");
}
void check() /* 建立进程查看函数 */
{
PCB* pr;
printf("\n ****当前正在运行的进程是:%s",p->name); /*显示当前运行进程*/
disp(p);
pr=ready;
printf("\n ****当前就绪队列状态为:\n"); /*显示就绪队列状态*/
while(pr!=NULL)
{
disp(pr);
pr=pr->link;
}
}
void destroy() /*建立进程撤消函数(进程运行结束,撤消进程)*/
{
printf("\n进程[%s]已完成.\n",p->name);
free(p);
}
void running() /* 建立进程就绪函数(进程运行时间到,置就绪状态*/
{
(p->rtime)++;
if(p->rtime==p->ntime)
destroy(); /* 调用destroy函数*/
else
{
(p->super)--;
p->state='w';
sort(); /*调用sort函数*/
}
}
void main() /*主函数*/
{
int len, h=0;
char ch;
input();
len=space();
while((len!=0)&&(ready!=NULL))
{
ch=getchar();
h++;
printf("\n The execute number:%d\n",h);
p=ready;
ready=p->link;
p->link=NULL;
p->state='R';
check();
running();
printf("\n按任一键继续......");
ch=getchar();
}
printf("\n\n进程已经完成.\n");
ch=getchar();
}
短进程优先算法–无优先级
//短进程优先调度算法
#include <stdlib.h>
#include <stdio.h>
//定义一个结构体:PCB
struct pcb{
char name[10];
float arrivetime;
float servicetime;
float starttime;
float finishtime;
float zztime;
float dqzztime;
};
//***输入进程信息,将N个进程的信息写入pcb型数组***
void input(pcb *p,int N)
{
int i;
printf("\n");
for(i=0; i <= N-1; i++)
{
printf("请输入进程%d的进程名:", i+1);
scanf("%s", &p[i].name);
printf("请输入进程到达时间:");
scanf("%f", &p[i].arrivetime);
printf("请输入进程运行时间:");
scanf("%f", &p[i].servicetime);
printf("\n");
}
}
//***优先级排序***
void sort(pcb *p, int N)
{
/*
1、对pcb型数组中的元素进行一个简单的排序
找到优先级最高的进程
并把其他进程也进行简单排序,方便后续工作
*/
//排序: N次循环,每次找到从i到N-1中优先级最高的进程,放到p[i]
for(int i=0;i<=N-1;i++)
{
//循环比较剩余的变量 //排序后:从0~N-1 arrivetime增加 , arrivetime相同时, servicetime短的优先
for(int j=i+1;j<N;j++)
{
if(p[i].arrivetime>p[j].arrivetime || (p[i].arrivetime==p[j].arrivetime && p[i].servicetime>p[j].servicetime) )
{
//p[j]的优先级高于p[i],因此把p[j]放到p[i]
pcb temp;
temp = p[i];
p[i] = p[j];
p[j] = temp;
}
}
}
/*
2、每个进程运行完成之后,找到当前时刻已经到达的最短进程
P[0]优先级最高,p[0].finishtime=p[0].arrivetime+p[0].servicetime
m!=0时:p[m].finishtime=p[m-1].finishtime+p[m].servicetime
*/
for(int m=0; m<N-1; m++)
{
if(m == 0)
p[m].finishtime = p[m].arrivetime + p[m].servicetime;
else
p[m].finishtime = ((p[m-1].finishtime >= p[m].arrivetime)? p[m-1].finishtime: p[m].arrivetime) + p[m].servicetime;
//(1)找到p[m].finishtime时刻哪些进程已经到达
int i=0; //i统计 p[m].finishtime时刻有几个进程已经到达
//从下一个进程p[m+1]开始寻找
for(int n = m+1; n <= N-1; n++)
{
if(p[n].arrivetime <= p[m].finishtime)
i++;
else
break;
/*由于在第1步已经对进程按照到达时间进行了排序
故:当p[n].arrivetime > p[m].finishtime时,
说明p[n]进程和其后面的其他进程都未到达。
i的值为p[m].finishtime时刻已经到达的进程数目。
*/
}
//(2)找到p[m].finishtime时刻已经到达的最短进程
float min = p[m+1].servicetime; //next进程服务时间为p[m+1].servicetime (初值)
int next = m+1; //next进程为m+1 (初值)
//p[m+1]至p[m+i]这i个已到达进程中找到最短进程
for(int k = m+1; k < m+i; k++) //k为m+1 ~ m+i-1
{
//min的初值是p[m+1].servicetime, k+1为m+2 ~m+i
if(p[k+1].servicetime < min)
{
min = p[k+1].servicetime;
next = k+1;
}
}
//(3)把最短进程放在p[m+1]进程处
pcb temp;
temp=p[m+1];
p[m+1]=p[next];
p[next]=temp;
}
}
//***运行***
void run(pcb *p, int N)
{
int k;
//计算各进程的开始时间和结束时间
for(k=0; k <= N-1; k++)
{
if(k==0) //第1个进程
{
p[k].starttime = p[k].arrivetime; //第1个进程到达之后即可执行
p[k].finishtime = p[k].starttime + p[k].servicetime;
}
else
{
p[k].starttime = (p[k-1].finishtime >= p[k].arrivetime)? p[k-1].finishtime: p[k].arrivetime;
p[k].finishtime = p[k].starttime + p[k].servicetime;
}
}
//计算各进程的周转时间和带权周转时间
for(k=0; k<=N-1; k++)
{
p[k].zztime = p[k].finishtime - p[k].arrivetime;
p[k].dqzztime = p[k].zztime / p[k].servicetime;
}
}
//***显示***
void Print(pcb *p, int N)
{
int k;
printf("调用最短进程优先算法以后进程运行的顺序是: ");
printf("%s",p[0].name);
for(k=1;k<N;k++)
{
printf("-->");
printf("%s", p[k].name);
}
printf("\n");
printf("具体进程调度信息:\n");
printf("进程名 到达时间 服务时间 开始时间 结束时间 周转时间 带权周转时间\n");
for(k=0; k<=N-1; k++)
{
printf("%4s", p[k].name);
//%m.nf:输出共占m列,其中有n位小数,如数值宽度小于m左端补空格
printf("%10.3f", p[k].arrivetime);
printf("%10.3f", p[k].servicetime);
printf("%10.3f", p[k].starttime);
printf("%10.3f", p[k].finishtime);
printf("%10.3f", p[k].zztime);
printf("%10.3f\n", p[k].dqzztime);
}
}
//***短进程优先***
void sjff(pcb *p,int N)
{
sort(p, N);
run(p, N);
Print(p, N);
int k;
float Attime = 0; // 平均周转时间
float AQttime = 0; //平均带权周转时间
for(k=0; k<=N-1; k++)
{
Attime += p[k].zztime;
AQttime += p[k].dqzztime;
}
Attime = Attime/N;
AQttime = AQttime/N;
printf("调用短进程优先算法的平均周转时间为:");
printf("%.3f\n", Attime);
printf("调用短进程优先算法的平均带权周转时间为:");
printf("%.3f\n", AQttime);
}
//***主函数***
int main()
{
//定义一个pcb型数组a
pcb a[100];
int N; //进程数目
printf("\n");
printf("\n");
printf("<<----------******短进程优先调度算法******---------->>");
printf("\n");
printf("请输入进程数目:");
scanf("%d", &N);
input(a, N);
sjff(a, N);
return 0;
}
短进程优先算法–无优先级 运行结果
短进程优先调度–有优先级
//短进程优先调度算法
#include<stdio.h>
#include<stdlib.h>
#define MAX 10
/* 定义进程控制块PCB */
struct pcb{
char name[10]; //进程名
int super; //进程优先级
int need_time; //运行时间
float come_time; //到达时间
float start_time; //开始运行时间
float end_time; //结束运行时间
int run_flag; //调度标志
int order; //运行次序
}p[MAX];
/* 建立进程控制块函数 输入进程信息*/
int input(){
int i,num;
printf("\n请输入进程数:");
scanf("%d",&num);
for(i=0;i<num;i++){
printf("\n******************************");
printf("\n进程号:%d\n",i);
printf("请输入进程名:");
scanf("%s",&p[i].name);
printf("请输入进程到达时间:");
scanf("%f",&p[i].come_time);
printf("请输入进程运行时间:");
scanf("%d",&p[i].need_time);
printf("请输入进程优先级:");
scanf("%d",&p[i].super);
p[i].start_time = 0;
p[i].end_time = 0;
}
printf("\n");
return num;
}
/* 显示 */
void print(int num){
int k;
float turn_round_time=0,f1,w=0;
float s1=0;
float s2=0;
printf("调用最短进程优先算法以后进程运行的顺序是: ");
printf("%s",p[0].name);
for(k=1;k<num;k++){
printf("-->");
printf("%s",p[k].name);
}
printf("\n");
printf("具体进程信息调度信息:\n");
printf("进程名 到达时间 运行时间 开始时间 结束时间 优先级 周转时间 带权周转时间\n");
for(k=0;k<num;k++){
f1=p[k].end_time - p[k].come_time;
turn_round_time += f1;
w += (f1 / p[k].need_time);
s1 = (float)p[k].need_time;
s2 = f1;
printf("%4s",p[k].name);
printf("%10.2f",p[k].come_time);
printf("%10d",p[k].need_time);
printf("%10.2f",p[k].start_time);
printf("%10.2f",p[k].end_time);
printf("%10d",p[k].super);
printf("%10.2f",f1);
printf("%10.2f",s2 / s1);
printf("\n");
}
printf("平均周转时间=%5.2f\n",turn_round_time/num);
printf("平均带权周转时间=%5.2f\n",w/num);
}
/* 短进程优先 */
void sjff(int counter){
float tmp_time = 0;
int i=0,j=1;
int num_schedul, tmp_counter;/* 正在被调度执行的进程编号和已经调度完成的进程个数*/
float run_time;
run_time = (float)p[i].need_time;
/* 从到达时间最早且相同的进程中查找第一个被调度的进程 */
while((j<counter)&&(p[i].come_time==p[j].come_time)){
if(p[j].need_time<p[i].need_time){
run_time = (float)p[j].need_time;
i=j;
}
j++;
}
/* 对第一个被调度的进程求相应的参数 */
num_schedul = i;
p[num_schedul].start_time = p[num_schedul].come_time;
p[num_schedul].end_time = p[num_schedul].start_time + p[num_schedul].need_time;
p[num_schedul].run_flag = 1;
tmp_time = p[num_schedul].end_time;
p[num_schedul].order = 1;
tmp_counter = 1;
/* 循环查找下一个被调度的进程,直到所有的tasks[j].run_flag ==1*/
while(tmp_counter<counter){
for(j=0;j<counter;j++){
if((p[j].come_time<=tmp_time)&&(!p[j].run_flag)){
run_time=(float)p[j].need_time;
num_schedul = j;
break;
}
}
/* 找到到“目前”为止,最短的进程,即run_time最小的进程 */
for(j=0;j<counter;j++){
if((p[j].come_time<=tmp_time)&&(!p[j].run_flag)){
if(p[j].need_time<run_time){
run_time=(float)p[j].need_time;
num_schedul=j;
}
}
}
/* 对找到的下一个被调度的进程求相应的参数 */
p[num_schedul].start_time=tmp_time;
p[num_schedul].end_time=p[num_schedul].start_time + p[num_schedul].need_time;
p[num_schedul].run_flag=1;
tmp_time=p[num_schedul].end_time;
tmp_counter++;
p[num_schedul].order=tmp_counter;
}
}
/* 主函数 */
int main(){
int counter = 0;
printf("\n");
printf("<<----------******短进程优先调度算法******---------->>");
counter = input();
sjff(counter);
print(counter);
return 0;
}
短进程优先调度–有优先级 运行结果
进程调度综合算法
包括先来先服务调度,短进程优先调度,优先级调度,响应比高优先调度
#include<stdio.h>
#define MAX 10
struct task_struct{
char name[10]; /* 进程名称 */
int number; /* 进程编号 */
float come_time; /* 到 达 时 间 */
float run_begin_time; /* 开始运行时间 */
float run_time; /* 运行时间 */
float run_end_time; /* 运行结束时间 */
int priority; /* 优先级 */
int order; /* 运行次序 */
int run_flag; /* 调度标志 */
}tasks[MAX];
int counter; /* 实际进程个数 */
int fcfs(); /* 先来先服务 */
int ps(); /* 优先级调度 */
int sjf(); /* 短作业优先 */
int hrrn(); /* 响应比高优先 */
int pinput(); /* 进程参数输入 */
int poutput(); /* 调度结果输出 */
void main()
{
int option;
pinput();
printf(" 请选择调度算法(0~4):");
printf("1. 先来先服务:");
printf("2. 优先级调度:");
printf(" 3. 短作业优先:");
printf(" 4. 响应比高优先:");
printf(" 0. 退 出:");
scanf("%d",&option);
switch (option){
case 0:
printf(" 运行结束\n");
break;
case 1:
printf(" 对进程按先来先服务调度\n");
fcfs();
poutput();
break;
case 2:
printf(" 对进程按优先级调度\n");
ps();
poutput();
break;
case 3:
printf(" 对进程按短作业优先调度\n");
sjf();
poutput();
break;
case 4:
printf(" 对进程按响应比高优先调度\n");
hrrn();
poutput();
break;
}
}
/* FCFS 非抢占式先来先服务*/
/*
该程序段默认进程已经按到达先后顺序排成了队列
如果考虑输入为乱序,
还需要根据come_time对进程进行排队,形成一个先来后到的队列
*/
int fcfs() {
float time_temp=0; int i;
int number_schedul; time_temp=tasks[0].come_time;
for(i=0;i<counter;i++){
tasks[i].run_begin_time=time_temp; tasks[i].run_end_time=tasks[i].run_begin_time+tasks[i].run_time; tasks[i].run_flag=1;
time_temp=tasks[i].run_end_time; number_schedul=i; tasks[number_schedul].order=i+1;
}
return 0;
}
/* 非抢占式优先级调度 */
/*
默认tasks[0]是最早到达的进程,进程已按到达先后顺序排成了队列
*/
int ps(){
float temp_time=0; int i=0,j;
int number_schedul,temp_counter; /* 正在被调度执行的进程编号和已经调度完成的进程个数 */
int max_priority;
max_priority=tasks[i].priority; j=1;
/* 从到达时间最早且相同的进程中遍历,查找第一个被调度的进程 */
while((j<counter)&&(tasks[i].come_time==tasks[j].come_time))/* 寻找到达时间相同优先级最高的进程 */
{
if (tasks[j].priority>tasks[i].priority){
max_priority=tasks[j].priority; i=j;
}
j++;
}
/* 对第一个被调度的进程求相应的参数 */
number_schedul=i;
tasks[number_schedul].run_begin_time=tasks[number_schedul].come_time; tasks[number_schedul].run_end_time=tasks[number_schedul].run_begin_time+tasks[number_schedul].run_time;
tasks[number_schedul].run_flag=1; temp_time=tasks[number_schedul].run_end_time; tasks[number_schedul].order=1;
temp_counter=1;
/* 循环查找下一个被调度的进程,直到所有的 tasks[j].run_flag ==1 */
while (temp_counter<counter){
max_priority=0;
for(j=0;j<counter;j++){
if((tasks[j].come_time<=temp_time)&&(!tasks[j].run_flag)){
if (tasks[j].priority>max_priority){
max_priority=tasks[j].priority; number_schedul=j;
}
}
}
/* 对找到的下一个被调度的进程求相应的参数 */
tasks[number_schedul].run_begin_time=temp_time;
tasks[number_schedul].run_end_time=tasks[number_schedul].run_begin_time+tasks[number_schedul].run_time;
tasks[number_schedul].run_flag=1;
temp_time=tasks[number_schedul].run_end_time; temp_counter++;
tasks[number_schedul].order=temp_counter;
}
return 0;
}
/* 非抢占式短作业优先 */
/*
默认tasks[0] 是最早到达的进程,进程已按到达先后顺序排成了队列
*/
int sjf(){
float temp_time=0;
int i=0,j;
int number_schedul,temp_counter; /* 正在被调度执行的进程编号和已经调度完成的进程个数*/
float run_time; /* 借助该局部变量可以帮助找到执行时间 run_time 最短进程 */
run_time=tasks[i].run_time;
j=1;
/* 从到达时间最早且相同的进程中查找第一个被调度的进程 */
while ((j<counter)&&(tasks[i].come_time==tasks[j].come_time)){
if (tasks[j].run_time<tasks[i].run_time){
run_time=tasks[j].run_time;
i=j;
}
j++;
}
/* 对第一个被调度的进程求相应的参数 */
number_schedul=i;
tasks[number_schedul].run_begin_time=tasks[number_schedul].come_time;
tasks[number_schedul].run_end_time=tasks[number_schedul].run_begin_time+tasks[number_schedul].run_time;
tasks[number_schedul].run_flag=1; temp_time=tasks[number_schedul].run_end_time; tasks[number_schedul].order=1;
temp_counter=1;
/* 循环查找下一个被调度的进程,直到所有的tasks[j].run_flag ==1*/
while (temp_counter<counter){ /* 找到在上一个进程执行期间(到“目前”为止)到达时间最晚的一个进程 */
for(j=0;j<counter;j++){
if((tasks[j].come_time<=temp_time)&&(!tasks[j].run_flag)){
run_time=tasks[j].run_time;number_schedul=j;
break;
}
}
/* 找到到“目前”为止,最短的进程,即 run_time 最小的进程 */
for(j=0;j<counter;j++){
if((tasks[j].come_time<=temp_time)&&(!tasks[j].run_flag)){
if(tasks[j].run_time<run_time){
run_time=tasks[j].run_time;
number_schedul=j;
}
}
}
/* 对找到的下一个被调度的进程求相应的参数 */
tasks[number_schedul].run_begin_time=temp_time;
tasks[number_schedul].run_end_time=tasks[number_schedul].run_begin_time+tasks[number_schedul].run_time;
tasks[number_schedul].run_flag=1;
temp_time=tasks[number_schedul].run_end_time; temp_counter++;
tasks[number_schedul].order=temp_counter;
}
return 0;
}
/* 非抢占式响应比高优先 */
/*
默认tasks[0] 是最早到达的进程,进程已按到达先后顺序排成了队列
*/
int hrrn(){
int j,number_schedul,temp_counter;
float temp_time,respond_rate,max_respond_rate;
/*
第一个进程被调度,系统刚开始运行时,同时到达的进程响应比都为0(按该程序所采用的等待时间 /运行时间这个公式算)
因此按队列顺序必然是第一个进程最先被调度
*/
tasks[0].run_begin_time=tasks[0].come_time;
tasks[0].run_end_time=tasks[0].run_begin_time+tasks[0].run_time;
temp_time=tasks[0].run_end_time;
tasks[0].run_flag=1;
tasks[0].order=1;
temp_counter=1;
/* 调度其他进程 */
while(temp_counter<counter){
max_respond_rate=0;
/* 找响应比高的进程 */
for(j=1;j<counter;j++){
if((tasks[j].come_time<=temp_time)&&(!tasks[j].run_flag)){
respond_rate=(temp_time-tasks[j].come_time)/tasks[j].run_time;
if (respond_rate>max_respond_rate){
max_respond_rate=respond_rate;
number_schedul=j;
}
}
}
tasks[number_schedul].run_begin_time=temp_time;
tasks[number_schedul].run_end_time=tasks[number_schedul].run_begin_time+tasks[number_schedul].run_time;
temp_time=tasks[number_schedul].run_end_time;
tasks[number_schedul].run_flag=1;
temp_counter+=1; tasks[number_schedul].order=temp_counter;
}
return 0;
}
/* 进程参数输入 */
int pinput(){
int i;
printf("please input the 进程数:"); scanf("%d",&counter);
for(i=0;i<counter;i++){
printf("******************************************\n");
printf("please input the process of %d th :\n",i+1);
printf("please input the 进程名:");
scanf("%s",tasks[i].name);
printf("please input 进程编号:");
scanf("%d",&tasks[i].number);
printf("please input the 到达时间:");
scanf("%f",&tasks[i].come_time);
printf("please input the 运行时间:");
scanf("%f",&tasks[i].run_time);
printf("please input the 优先级:");
scanf("%d",&tasks[i].priority);
tasks[i].run_begin_time=0;
tasks[i].run_end_time=0;
tasks[i].order=0;
tasks[i].run_flag=0;
}
return 0;
}
/* 调度结果输出 */
int poutput() {
int i;
float turn_round_time=0,f1,w=0;
float s1=0;
float s2=0;
for(i=0;i<counter;i++){
f1=tasks[i].run_end_time-tasks[i].come_time;
turn_round_time+=f1; w+=(f1/tasks[i].run_time);
s1=tasks[i].run_time;
s2=f1;
printf("进程名\t进程编号\t到达时间\t运行时间\t运行开始时间\t运行结束时间\n");
printf(" %s\t%d\t%.2f\t%.2f\t%.2f\t%.2f\n",tasks[i].name,tasks[i].number,tasks[i].come_time,tasks[i].run_time,tasks[i].run_begin_time,tasks[i].run_end_time);
printf("优先级\torder\t周转时间\t带权周转时间\n");
printf("%d\t%d\t%.2f\t%.2f\n",tasks[i].priority,tasks[i].order, f1,s2/s1);
}
printf("平均周转时间=%5.2f\n",turn_round_time/counter);
printf("平均带权周转时间=%5.2f\n",w/counter);
return 0;
}