进程调度模拟程序

//题目进程调度模拟程序

 #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 ();

    }

图