处理机调度程序.txt

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

          PrintResult(pHeadNode,   1,   fp);   
    
          /*   处理机对进程队列按优先数顺次进行调度   */   
          printf("\n\n开始运行:\n");   
          fprintf(fp,   "\n\n开始运行:\n");   
          for   (iCounterPCB   =   0,   pCurrPCB   =   pHeadNode->ProceQueueHead;     
                          iCounterPCB   <   pHeadNode->PCBNumber;   iCounterPCB++)   
                  for   (iCounterTime   =   0;     
                          iCounterTime   <   pCurrPCB->NeedTime;   iCounterTime++)   
                  {   
                          pCurrPCB->UsedTime++;   /*   运行1次   */   
                          if   (pCurrPCB->UsedTime   ==   pCurrPCB->NeedTime)   
                          {   
                                  pCurrPCB->PCBStatus   =   END;   /*   设置为结束状态   */   
                                  pCurrPCB   =   pCurrPCB->pNextPCB;   /*   指向下1个进程PCB   */   
                                  iEndNum++;   
                          }   
                          PrintResult(pHeadNode,   1,   fp);   /*   打印当前进程队列状态   */   
                          /*   如果所有的进程都运行完则退出   */   
                          if   (iEndNum   ==   pHeadNode->PCBNumber)   break;   
                  }   
    
          printf("\n按优先数调度运行完毕!\n");   
          fprintf(fp,   "\n按优先数调度运行完毕!\n");   
  }   
    
  void   TimeSliceAttemper(QueueHeadNode   *pHeadNode,   FILE   *fp)   
  {   
          OSPCB   *pCurrPCB     
      =   pHeadNode->ProceQueueHead;   /*   当前运行的进程PCB的指针   */   
          int   iTimeSlice,   iTimeCounter,     
  iEndNum   =   0;       /*   完成运行进程的计数器         */   
            
          printf("请输入时间片:   ");     
          scanf("%d",   &iTimeSlice);   
          printf("\n\n开始运行:\n");   
          fprintf(fp,   "\n用户指定时间片为%d\n\n开始运行:\n",   iTimeSlice);   
          while   (TRUE)   /*   处理机对进程队列按时间片进行调度   */   
          {   
                  if   (pCurrPCB->UsedTime   <   pCurrPCB->NeedTime)   
                  {   
                          /*   按指定时间片运行iTimeSlice次   */   
                          for   (iTimeCounter   =   0;     
                                          iTimeCounter   <   iTimeSlice   &&     
                                          pCurrPCB->UsedTime   !=   pCurrPCB->NeedTime;   
                                          iTimeCounter++)   
                                  pCurrPCB->UsedTime++;   
                          if   (pCurrPCB->UsedTime   ==   pCurrPCB->NeedTime)   
                          {   
                                  pCurrPCB->PCBStatus   =   END;   /*   设置为结束状态   */   
                                  iEndNum++;                 /*   完成运行的进程计数器加1   */   
                          }   
                          PrintResult(pHeadNode,   2,   fp);   /*   打印当前进程队列状态   */   
                          /*   如果所有的进程都运行完则退出   */   
                          if   (iEndNum   ==   pHeadNode->PCBNumber)   break;   
                  }   
                  pCurrPCB   =   pCurrPCB->pNextPCB;   
          }   
    
          printf("\n按时间片调度运行完毕!\n");   
          fprintf(fp,   "\n按时间片调度运行完毕!\n");   
  }   
    
  void   SortQueueByPrioFlag(QueueHeadNode   *pHeadNode)   
  {   
          int   i,   j;   
          QueueHeadNode   TempHeadNode;   
          OSPCB   *pCurrPCB   =   pHeadNode->ProceQueueHead,   *pTemp;   
          OSPCB   **buff,   **p;   
    
          p   =   buff   =   (OSPCB   **)   
                  malloc(sizeof(OSPCB   *)   *   pHeadNode->PCBNumber);   
          if   (!buff)   
          {   
                  printf("Error,   the   memory   if   overflow!\n");   
                  exit(1);   
          }   
          do   /*   初始化索引缓冲   */   
          {   
                  *p++   =   pCurrPCB;   
                  pCurrPCB   =   pCurrPCB->pNextPCB;   
          }   while   (pCurrPCB   !=   pHeadNode->ProceQueueHead);   
    
          /*   跟据进程优先数对索引缓冲进行排序   */   
          for   (i   =   0;   i   <   pHeadNode->PCBNumber   -   1;   i++)   
          {   
                  p   =   &buff[i];   
                  for   (j   =   i   +   1;   j   <   pHeadNode->PCBNumber;   j++)   
                          if   ((*p)->PriorityFlag   <   buff[j]->PriorityFlag)   
                                  p   =   &buff[j];   
    
                  if   (p   !=   &buff[i])   
                  {   
                          pTemp   =   *p;   
                          *p   =   buff[i];   
                          buff[i]   =   pTemp;   
                  }   
          }   
    
          TempHeadNode.ProceQueueHead   =   NULL;   
          TempHeadNode.PCBNumber   =   0;   
          for   (i   =   0;   i   <   pHeadNode->PCBNumber;   i++)   
          {   
                  /*   在原队列中删除buff[i]指向PCB结点   */   
                  buff[i]->pPrevPCB->pNextPCB   =   buff[i]->pNextPCB;   
                  buff[i]->pNextPCB->pPrevPCB   =   buff[i]->pPrevPCB;   
                  buff[i]->pNextPCB   =   buff[i]->pPrevPCB   =   NULL;   
                  TempHeadNode.PCBNumber++;   
                  /*   将删除的PCB结点buff[i]加入新队列中   */   
                  AddToQueue(&TempHeadNode,   buff[i]);   
          }   
    
          /*   将新队列赋给原队列   */   
          pHeadNode->ProceQueueHead   =   TempHeadNode.ProceQueueHead;   
          free(buff);   
  }   
    
  void   DeleteQueue(QueueHeadNode   *pHeadNode)   
  {   
          OSPCB   *pDeletePCB;   
    
          while   (pHeadNode->PCBNumber--)   
          {   
                  pDeletePCB   =   pHeadNode->ProceQueueHead;   
                  pHeadNode->ProceQueueHead   =     
                          pHeadNode->ProceQueueHead->pNextPCB;   
                  free(pDeletePCB);   
          }   
  }   
    
  void   PrintResult(QueueHeadNode   *pHeadNode,   int   flag,   FILE   *fp)   
  {   
          int   iCounter;   
          OSPCB   *pCurrPCB   =   pHeadNode->ProceQueueHead;   
    
          if   (1   ==   flag)   
          {   
                  printf("\n进程名   要求运行时间   已运行时间       优先数           状态\n");   
                  fprintf(fp,   "\n进程名   要求运行时间   已运行时间       优先数           状态\n");   
          }   
          else   if   (2   ==   flag)   
          {   
                  printf("\n进程名   要求运行时间   已运行时间       状态\n");   
                  fprintf(fp,   "\n进程名   要求运行时间   已运行时间       状态\n");   
    
          }   
          for   (iCounter   =   0;   iCounter   <   pHeadNode->PCBNumber;   iCounter++)   
          {   
                  printf("PCB%-4d",   pCurrPCB->ProcName);   
                  printf("%9d",   pCurrPCB->NeedTime);   
                  printf("%12d",   pCurrPCB->UsedTime);   
                  fprintf(fp,   "PCB%-4d",   pCurrPCB->ProcName);   
                  fprintf(fp,   "%9d",   pCurrPCB->NeedTime);   
                  fprintf(fp,   "%12d",   pCurrPCB->UsedTime);   
                  if   (flag   ==   1)     
                  {   
                          printf("%9d",   pCurrPCB->PriorityFlag);   
                          fprintf(fp,   "%9d",   pCurrPCB->PriorityFlag);   
                  }   
                  switch   (pCurrPCB->PCBStatus)   
                  {   
                          case   READY:   
                                  printf("%s",   "             READY");   
                                  fprintf(fp,   "%s",   "             READY");   
                                  break;   
                          case   END:   
                                  printf("%s",   "             END");   
                                  fprintf(fp,   "%s",   "             END");   
                                  break;   
                          default:   
                                  break;   
                  }   
                  pCurrPCB   =   pCurrPCB->pNextPCB;   
                  printf("\n");   
                  fprintf(fp,   "\n");   
          }   
  }