2.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 ();

}