进程调度模拟程序.txt

时间轮转法

#define    NULL 0
#include   <stdio.h>
#include   <string.h>
#include   <malloc.h>
#include   <time.h>
//定义一个pcb的结构体

FILE *GroupFile[10];

typedef   struct index{ 
     char    name;   //指令
     int     time;  //指令执行时间
   }index;

struct pcb {
    char filename[10];  //进程名
 int id;             //作业编号
 int exetoIndex;     //当前正在执行指令
 char status;         //当前状态
 int wtime;           //等待时间
};

struct pcb jobpcb[100];    //pcb表


typedef  struct job{
     index idx[100];      //指令集
  int pcbnum;          //pcb编号  对应
   }job;

job   jobtab[100];        //作业表

char jobp[3][50];          //作业
//队列
struct Qnode
{
 int      pcbnum[100];     //pcb编号    
    int     head,tail; 
 };

struct  Qnode  Queue[5];    //5个队列  0E 1R  2I 3O  4W 

void  initqueue(struct Qnode *l);

//延迟
void delay(  ){
     
   long begin,end;
      time(&begin);
       do {
                time(&end);
    } while((end-begin)<=1);
}

//字符转化为数值
int  change(char *m){  
 int i,j=0;
    int len=strlen(m);
    for(i=0;i<len;i++)
      j=j*10+m[i]-'0';
   return j;
}

//申请 pcb

int  AllocPCB(){
       int i;
       for(i=0;i<3;i++)
         if(jobpcb[i].id ==-1)  break;
            if(i<3)
                  return i;
   return -1;
}
//申请job
int  AllocJob(){

  int i;

  for(i=0;i<3;i++)
         if(jobtab[i].pcbnum == -1)  break;
     if(i<3)
        return i;
   return -1;

}
//显示指令
void displayIndex(){
 int i,j;

    for(i=0;i<3;i++){
            printf("  Job       % d \n",i+1);
         for(j=0;j<10;j++)
                    printf("  %d    %c     % d \n",j+1, jobtab[i].idx[j].name,jobtab[i].idx[j].time);
 }

}

//创建进程程序
int  creatpcbline(){  
     char   line[10];
     int i,ll,jnum, pnum,  ln=0,   bpos, pos=0;
  char   buff[50];
        char   name [20];
        char   ch;
   
  for(i=0;i<3;i++){  
                ln=0;
       jnum=AllocJob();
    if(jnum == -1) return 0;
    pnum=AllocPCB();
    if(pnum == -1) return 0;
    jobtab[jnum].pcbnum=pnum;   
         strcpy(jobpcb[pnum].filename,"         ");     
    jobpcb[pnum].status='r';
    jobpcb[pnum].exetoIndex=0;
    jobpcb[pnum].id=jnum;
    jobpcb[pnum].wtime=0;
             int ln=strlen(jobp[i]);
    pos=0;
    while(pos<len){
              while(jobp[i][pos]==' ') pos++;
                            
        jobtab[jnum].idx[ln].name=jobp[i][pos++];///

        while(jobp[i][pos]==' ') pos++;
        
        bpos=0;
        
        while(jobp[i][pos]!=' ')
        
         buff[bpos++]=jobp[i][pos++];
        
        buff[bpos]='\0';
          
        jobtab[jnum].idx[ln].time=change(buff);/////
        
        if(pos<len) {pos++;ln++;
       }
    }
   }
  displayIndex();
}
/*初始化队列
void  initqueue(struct Qnode *l){ 
       l->head=0;
    l->tail=0;
 }

 

//插进入队列/
void insertqueue(struct Qnode *l,int pcbnum){
      l->pcbnum[l->tail++]=pcbnum;
      
}

//队列是否为空


int EmptyQueue( struct Qnode l){
      if(l.head==l.tail) return 1;
      return 0;
}

//删除队列
void outqueue(struct Qnode *l,int *pcbnum)
  {
    if (l->head>=l->tail ) *pcbnum=-1;
 else
     *pcbnum=l->pcbnum[l->head++];
 
 
 
}
//显示作业
void  display(){
       int i,j;
   
    for(i=0;i<5;i++){

        printf(" 队列       %d         ",i); 
     for(j=Queue[i].head;j<Queue[i].tail;j++)

     printf("pcb 编号     %d      \n\n  ",Queue[i].pcbnum[j]); 
    
   


    }

}

 

 

 

 


//作业入队列
void   JobEnQueueInit( int * total){

       int i,num ,Index=0;
   
    char cmd;
      
    for( i=0;i<3;i++){

     if(jobpcb[i].id>=0){
     cmd=jobtab[    jobpcb[i].id   ].idx[   Index  ].name;

     switch(cmd){
     case 'c':      insertqueue(&Queue[1],i);  jobpcb[i].status='r'; break;
                 case 'i':   insertqueue(& Queue[2],i);jobpcb[i].status='i'; break;

                 case 'o':   insertqueue(& Queue[3],i);jobpcb[i].status='o'; break;
                 case 'w':   insertqueue(& Queue[4],i);jobpcb[i].status='w'; break;
     case 'h':   jobpcb[i].status='h'; num=jobpcb[i].id;jobtab[num].pcbnum=-1;jobpcb[i].id=-1;
     }
     if(cmd== 'h') {jobpcb[i].wtime=0;  total--;}
     jobpcb[i].wtime=jobtab [ jobpcb[i].id   ].idx[Index].time;

                 (*total)++;


    

     }
    }


}

 


void   save (){


FILE *fp;

int i;
fp=fopen("pcbtable.txt","a");


fprintf(fp,"  文件名    作业编号     执行到指令数      所处状态       等待时间 \n" );

for(i=0;i<3;i++)

 fprintf(fp," \t %s  \t %d  \t %d  \t %c  \t %d \n" ,
              jobpcb[i].filename,jobpcb[i].id,jobpcb[i].exetoIndex,
    jobpcb[i].status,jobpcb[i].wtime );

fclose(fp);

 

 

}

 

 

 

 

 

//作业入队列
void   JobEnQueue( int pcbnum,int Index ,int *total){

           int num;
        char cmd;

 

     if(jobpcb[pcbnum].id>=0){
     cmd=jobtab[    jobpcb[pcbnum].id   ].idx[   Index  ].name;

     switch(cmd){
     case 'c':      insertqueue(&Queue[1],pcbnum);  jobpcb[pcbnum].status='r'; break;
                 case 'i':   insertqueue(& Queue[2],pcbnum);jobpcb[pcbnum].status='i'; break;

                 case 'o':   insertqueue(& Queue[3],pcbnum);jobpcb[pcbnum].status='o'; break;
                 case 'w':   insertqueue(& Queue[4],pcbnum);jobpcb[pcbnum].status='w'; break;
     case 'h':   jobpcb[pcbnum].status='h'; num=jobpcb[pcbnum].id;jobtab[num].pcbnum=-1;jobpcb[pcbnum].id=-1;
     }
     if(cmd== 'h') {
       jobpcb[pcbnum].wtime=0; 
       printf(" \n\t\t作业    %d      完成\n", pcbnum+1, jobpcb[ pcbnum].status);
       (*total)--;
     }
     else jobpcb[pcbnum].wtime=jobtab [ jobpcb[pcbnum].id   ].idx[Index].time;
     
     printf(" \n\t\t作业      %d  \n ", pcbnum+1);
     printf("\t\t\t\t所处状态  ：    %c  \n",jobpcb[ pcbnum].status);
           printf("\t\t还需要时间   %d  秒\n",jobpcb[ pcbnum].wtime);

     
           
     }
    


}

//得到队列的首元素

int  GetHead(struct Qnode l){
 return l.pcbnum[l.head];
}
//执行
void   run (){

 int i, flag=0, time=10, pcbnum, Index=0, exenum, num, quenum;
    char cmd;
    int j,m,n;
 int total=0;

 
 JobEnQueueInit( &total );


 save();
 while(  total!=0  ){  
   if( !EmptyQueue(  Queue[1])  ){
    
    
                outqueue(&Queue[1],&pcbnum);
       insertqueue(&Queue[0], pcbnum);    
       


   }
            else  pcbnum=GetHead(Queue[0]);
   
            delay();
            jobpcb[ pcbnum].status='e';          
            printf(" \n\t\t作业    %d    \n",pcbnum+1);
    
   printf("  \t\t\t所处状态: %c \t执行了 %d 秒\n", jobpcb[ pcbnum].status, time);
           
  
   for(i=0;i<3;i++){ 

                                      if(jobpcb[i].id>=0){

 


                          //所有的作业除在就绪队列获执行结束的外等待时间 都间时间片    
              if( jobpcb[i].status!='r'&&jobpcb[i].status!='h')   jobpcb[i].wtime=jobpcb[i].wtime-time;
                                

      if(jobpcb[i].wtime<=0){  //查找所有的队列 所在位置
        for(j=0;j<5;j++){ 
          for(m=Queue[j].head;m<Queue[j].tail;m++){

                if(Queue[j].pcbnum[m]==i) {flag=1;break; }
               }
             if(flag==1) break;
        }
     
              if(flag==1){ //删除该指令

                 for(n=m;n<Queue[j].tail;n++) Queue[j].pcbnum[n]=Queue[j].pcbnum[n+1];
                 Queue[j].tail--;      
                 jobpcb[i].exetoIndex++;
                 Index=jobpcb[i].exetoIndex;
                 JobEnQueue( i,Index,&total );
      
        } 
          


      }
                    
                              
   }
                                }
             

     if( !EmptyQueue(  Queue[1])  ){
    
    
                outqueue(&Queue[0],&pcbnum);
       if(jobpcb[pcbnum].wtime>0){
        insertqueue(&Queue[1], pcbnum);    
           jobpcb[pcbnum].status='r';
       }

   }

 

 

 

 


            printf(" \n\n\t\t 还有\t %d  个作业没有完成  \n",total ); 
             save();
 } 

 

}

 

 

//初始化
void InitFile(){

 int i;

 

strcpy (jobp[0]," c 20  i 20 o 15 h 0 ");////////////////////////改
strcpy (jobp[1]," i 10 c 20 c 10 h 0 ");
strcpy (jobp[2]," c 30 i 20 c 5 h 0 ");
 for(i=0;i<100;i++){
  jobpcb[i].exetoIndex=0;
  strcpy(jobpcb[i].filename,"         ");
        jobpcb[i].id=-1;
  jobpcb[i].status='r';
  jobpcb[i].wtime=0;
 }

 for(i=0;i<100;i++)
  jobtab[i].pcbnum=-1;
  
    
  for(i=0;i<5;i++)
     
                initqueue(&Queue[i]);

 

  //GroupFile[0]=fopen("1.txt","r");


  //GroupFile[1]=fopen("2.txt","r");

  //GroupFile[2]=fopen("3.txt","r");

}


void main(){

         InitFile();
         creatpcbline();
         run ();

    }