处理机调度程序.txt

这也是一个处理机的调度程序

  #include   <time.h>   
  #include   <stdio.h>   
  #include   <conio.h>   
  #include   <stdlib.h>   
  #include   <string.h>   
    
  #define   TRUE                         1   
  #define   FALSE                       0   
  #define   MAXTIME                   10   /*   最大随机时间片   */   
  #define   MAXPRIO                   7     /*   最大随机优先数   */   
  #define   READY                       2     /*   进程就绪               */   
  #define   END                           4     /*   进程结束               */   
    
  typedef   int   status;   
  typedef   struct   PCBSTRU   
  {   
          int   ProcName;                             /*   进程名                       */   
          int   NeedTime;                             /*   要求运行的时间       */   
          int   UsedTime;                             /*   已运行的时间           */   
          int   PriorityFlag;                     /*   进程优先数标记       */   
          status   PCBStatus;                     /*   进程状态                   */   
          struct   PCBSTRU   *pPrevPCB;     /*   前一个PCB地址         */   
          struct   PCBSTRU   *pNextPCB;     /*   下一个PCB地址         */   
  }   OSPCB;   
  typedef   struct   PCBQUEUEHEAD   /*   进程队列头结构             */   
  {   
          OSPCB   *ProceQueueHead;     /*   进程队列头指针             */   
          int   PCBNumber;                     /*   进程队列当前PCB总数   */   
  }   QueueHeadNode;   
    
  void   CreateProcessQueue(QueueHeadNode   *pHeadNode,   int   iTotalNum);   
  OSPCB   *MakeNewPCBNode(int   CurrPCBNum);         /*   生成并返回新PCB   */   
  void   AddToQueue(QueueHeadNode   *,   OSPCB   *pNewPCB);   /*   PCB入队   */   
  void   AttemperProcess(QueueHeadNode   *pHeadNode);   
  /*   处理机对进程队列按优先数顺次进行调度   */   
  void   PriorityAttemper(QueueHeadNode   *pHeadNode,   FILE   *fp);   
  /*   根据PCB的优先数对PCB就绪队列进行降序排列   */   
  void   SortQueueByPrioFlag(QueueHeadNode   *);   
  /*   处理机对进程队列按时间片进行调度   */   
  void   TimeSliceAttemper(QueueHeadNode   *pHeadNode,   FILE   *fp);   
  void   DeleteQueue(QueueHeadNode   *pHeadNode);   /*   回收队列   */   
  /*   将运行结果打印在屏幕上,并写入"Result.txt"文件*/   
  void   PrintResult(QueueHeadNode   *pHeadNode,   int   flag,   FILE   *fp);   
    
  int   main()   
  {   
          QueueHeadNode   ProcHeadNode;   
          int   iTotalNum;   
    
          //clrscr();   
          printf("请输入需要运行的进程数目:   ");   
          scanf("%d",   &iTotalNum);   
    
          srand(time(NULL));   
          ProcHeadNode.PCBNumber   =   0;   
          ProcHeadNode.ProceQueueHead   =   NULL;   
          CreateProcessQueue(&ProcHeadNode,   iTotalNum);   
          AttemperProcess(&ProcHeadNode);   
          DeleteQueue(&ProcHeadNode);   
    
          getch();   
          return   0;   
  }   
    
  void   CreateProcessQueue(QueueHeadNode   *pHeadNode,   int   iTotalNum)   
  {   
          OSPCB   *pNewPCBNode;   
          int   iCounter;   
    
          for   (iCounter   =   0;   iCounter   <   iTotalNum;   iCounter++)   
          {   
                  pNewPCBNode   =   MakeNewPCBNode(pHeadNode->PCBNumber);   
                  pHeadNode->PCBNumber++;   
                  AddToQueue(pHeadNode,   pNewPCBNode);   
          }   
  }   
    
  OSPCB   *MakeNewPCBNode(int   iCurrPCBNum)   
  {   
          OSPCB   *pNewPCBNode   =   NULL;   
    
          if   (!(pNewPCBNode   =   (OSPCB   *)malloc(sizeof(OSPCB))))   
          {   
                  printf("Error,   the   memory   if   overflow!\n");   
                  exit(1);   
          }   
    
          /*   
          *   初始化新产生的PCB,   随机数(1～MAXTIME)作为要求运行时间,   
          *   随机数(1～MAXPRIO)作为优先数   
          */   
          pNewPCBNode->ProcName   =   iCurrPCBNum   +   1;   
          pNewPCBNode->NeedTime   =   rand()   %   MAXTIME   +   1;   
          pNewPCBNode->UsedTime   =   0;   
          pNewPCBNode->PriorityFlag   =   rand()   %   MAXPRIO   +   1;   
          pNewPCBNode->PCBStatus   =   READY;   
          pNewPCBNode->pPrevPCB   =   pNewPCBNode->pNextPCB   =   NULL;   
    
          return   pNewPCBNode;   
  }   
    
  void   AddToQueue(QueueHeadNode   *pHeadNode,   OSPCB   *pNewPCB)   
  {   
          static   OSPCB   *pCurrPCB   =   NULL;   
    
          if   (pHeadNode->ProceQueueHead   ==   NULL)   
          {   
                  pCurrPCB   =   pHeadNode->ProceQueueHead   =   pNewPCB;   
                  pNewPCB->pPrevPCB   =   pNewPCB->pNextPCB   =   
                                                          pHeadNode->ProceQueueHead;   
          }   
          else   
          {   
                  /*   新PCB后驱指针指向pCurrPCB   */   
                  pNewPCB->pPrevPCB   =   pCurrPCB;   
                  /*   新PCB后驱指针指向pCurrPCB的前驱,即第1个PCB   */   
                  pNewPCB->pNextPCB   =   pCurrPCB->pNextPCB;   
                  /*   使新PCB成为pCurrPCB的后驱   */   
                  pCurrPCB->pNextPCB   =   pNewPCB;   
                  /*   使第1个PCB成为新PCB的前驱   */   
                  pNewPCB->pNextPCB->pPrevPCB   =   pNewPCB;   
                  /*   当前指针向前一步   */   
                  pCurrPCB   =   pCurrPCB->pNextPCB;   
          }   
  }   
    
  void   AttemperProcess(QueueHeadNode   *pHeadNode)   
  {   
          char   strIns[10];   
          int   flag;   
          FILE   *fp   =   NULL;   
    
          if   ((fp   =   fopen("Result.txt",   "w"))   ==   NULL)   
          {   
                  printf("Error,   cannot   open   the   file   'Result.txt'!\n");   
                  exit(1);   
          }   
          fprintf(fp,   "*   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *\n");   
          fprintf(fp,   "*                             进     程     运     行     结     果                       *\n");   
          fprintf(fp,   "*           请设置字体为'Fixedsys',文本效果会更好           *\n");   
          fprintf(fp,   "*   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *   *\n");   
    
          printf("\n请输入调度算法:\n按'1'优先数调度,按'2'时间片轮转调度:   ");   
          gets(strIns);   gets(strIns);   
          flag   =   atoi(strIns);   
    
          printf("\n进程初始状态:\n");   
          fprintf(fp,   "\n进程初始状态:\n");   
          PrintResult(pHeadNode,   flag,   fp);   
          switch   (flag)   
          {   
                  case   1:   
                          printf("\n%30s\n",   "----按优先数调度----");   
                          fprintf(fp,   "\n%30s\n",   "----按优先数调度----");   
                          PriorityAttemper(pHeadNode,   fp);   
                          break;   
                  case   2:   
                          printf("\n%30s\n",   "----按时间片轮转调度----");   
                          fprintf(fp,   "\n%30s\n",   "----按时间片轮转调度----");   
                          TimeSliceAttemper(pHeadNode,   fp);   
                          break;   
                  default:   
                          break;   
          }   
    
          fclose(fp);   
         /* printf("\n请注意,   如果看不清结果,可以打开结果文档(Result.txt)查看.\n");   */
  }   
void   PriorityAttemper(QueueHeadNode   *pHeadNode,   FILE   *fp)   
  {   
          OSPCB   *pCurrPCB;   /*   当前运行的进程PCB的指针   */   
          int   iCounterPCB,   iCounterTime,     
                  iEndNum   =   0;   /*   完成运行进程的计数器   */   
    
          printf("首先,根据PCB的优先数对PCB就绪队列进行降序排列:\n");   
          fprintf(fp,   "首先,根据PCB的优先数对PCB就绪队列进行降序排列:\n");   
          SortQueueByPrioFlag(pHeadNode);