模拟进程调度

举报
兔老大 发表于 2021/04/20 01:18:57 2021/04/20
【摘要】 功能 data.h #ifndef _Data_h_#define _Data_h_ #include <stdio.h>#include <stdlib.h>#include <string.h> #define ElemType PCB#define Status int#define OK 1#define ERROR 0#de...

功能

data.h


  
  1. #ifndef _Data_h_
  2. #define _Data_h_
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <string.h>
  6. #define ElemType PCB
  7. #define Status int
  8. #define OK 1
  9. #define ERROR 0
  10. #define TimeSlice 1
  11. #define Infinity 10 //INT_MAX
  12. #define NAME_MAXSIZE 20
  13. typedef enum
  14. {
  15. Ready,Running,Block
  16. }ProState;
  17. typedef enum
  18. {
  19. FCFS, SPF //先来先服务,短进程优先
  20. }PriorityRule;
  21. typedef struct
  22. {
  23. char Name[NAME_MAXSIZE]; //进程名
  24. int Priority; //优先数
  25. int ArrivalTime; //到达时间 以时间片为单位
  26. int NeedRunningTime; //运行时间 以时间片为单位
  27. int StartTime; //开始执行时间
  28. int FinishTime; //完成时间
  29. int TimeUsedCPU; //已用CPU时间 以时间片为单位
  30. ProState ProcessState; //进程状态
  31. }PCB;
  32. typedef struct Node
  33. {
  34. ElemType data;
  35. struct Node * Next;
  36. }LNode,*LinkList;
  37. #endif

 ChainList.h


  
  1. #ifndef _ChainList_h_
  2. #define _ChainList_h_
  3. #include "Data.h"
  4. //功能:链表初始化
  5. Status Init(LinkList *L);
  6. //功能:赋值运算,将e2赋值给e1
  7. void Assignment(ElemType *e1, ElemType e2);
  8. //功能:获取第i个结点元素
  9. Status GetElemt_L(LinkList L,int i,ElemType *e);
  10. //功能:链表根据优先级插入元素
  11. Status ListInsert_L(LinkList L,ElemType e);
  12. //功能:链表删除头结点
  13. Status ListDelete_L(LinkList L,ElemType *e);
  14. #endif

ProPCB.h


  
  1. #ifndef _ProPCB_h_
  2. #define _ProPCB_h_
  3. #include "ChainList.h"
  4. //功能:将e插入链表Q
  5. Status GetProcess(LinkList Q,ElemType e); //上就绪队列
  6. //功能:根据不同的优先级规则,返回优先数
  7. int GetPriority(ElemType *e, PriorityRule PR); //根据不同的规则PR 设置优先数
  8. //功能:将链表Q的头结点数据放到e指向的内存,并删除
  9. Status OutProsess(LinkList Q,ElemType *e); //下就绪队列
  10. //功能:CPU运行pcb指向的进程,并输出所有进行进程状态
  11. Status CPURunPro(LinkList Q, PCB *pcb); //CPU运行PCB
  12. //功能:打印所有PCB信息
  13. void PrintProQueue(LinkList Q, PCB *pcb); //打印运行后PCB信息
  14. //功能:当一个进程结束,打印进程信息
  15. void PrintProResult(PCB *pcb);
  16. #endif

实现


  
  1. #include "ChainList.h"
  2. extern int CPUUsedTime;
  3. //功能:链表初始化
  4. Status Init(LinkList *L)
  5. {
  6. *L = (LinkList)malloc(sizeof(LNode));
  7. (*L)->data.NeedRunningTime = -1;
  8. (*L)->Next = NULL;
  9. return OK;
  10. }
  11. //功能:赋值运算,将e2赋值给e1
  12. void Assignment(ElemType *e1, ElemType e2)
  13. {
  14. e1->ArrivalTime = e2.ArrivalTime;
  15. strcpy(e1->Name,e2.Name);
  16. e1->Priority = e2.Priority;
  17. e1->ProcessState = e2.ProcessState;
  18. e1->FinishTime = e2.FinishTime;
  19. e1->StartTime = e2.StartTime;
  20. e1->NeedRunningTime = e2.NeedRunningTime;
  21. e1->TimeUsedCPU = e2.TimeUsedCPU;
  22. }
  23. //链表中按照优先级:从大到小排序插入
  24. Status ListInsert_L(LinkList L,ElemType e) //这样修改应该不对 p = *L出错
  25. {
  26. LinkList p = L->Next, pre = L, s;
  27. while (p && e.Priority <= p->data.Priority)
  28. {
  29. pre = p;
  30. p = p->Next;
  31. }
  32. s = (LinkList)malloc(sizeof(LNode));
  33. Assignment(&s->data, e);
  34. s->Next = pre->Next;
  35. pre->Next = s;
  36. return OK;
  37. }
  38. //链表中头部删除
  39. Status ListDelete_L(LinkList L,ElemType *e)
  40. {
  41. LinkList p = L, q;
  42. q = p->Next;
  43. if(!q)
  44. return ERROR;
  45. p->Next = q->Next;
  46. Assignment(e, q->data);
  47. free(q);
  48. return OK;
  49. }

  
  1. #include "ProPCB.h"
  2. extern int CPUUsedTime;
  3. //功能:将e插入链表Q
  4. Status GetProcess(LinkList Q,ElemType e)
  5. {
  6. return ListInsert_L(Q, e);
  7. }
  8. //功能:根据不同的优先级规则,返回优先数
  9. int GetPriority(ElemType *e, PriorityRule PR)
  10. {
  11. if(PR == FCFS)
  12. return Infinity - e->ArrivalTime;
  13. else if(PR == SPF)
  14. return Infinity - e->NeedRunningTime;
  15. else
  16. printf("GetPriority Function ERROR!\n");
  17. return ERROR;
  18. }
  19. //功能:将链表Q的头结点数据放到e指向的内存,并删除
  20. Status OutProsess(LinkList Q,ElemType *e)
  21. {
  22. return ListDelete_L(Q ,e);
  23. }
  24. //上一次CPU运行时间增加1个时间片
  25. Status CPURunPro(LinkList Q,PCB *pcb)
  26. {
  27. if(pcb->StartTime == -1)
  28. pcb->StartTime = CPUUsedTime;
  29. pcb->ProcessState = Running;
  30. //PrintProQueue(Q, pcb);
  31. pcb->TimeUsedCPU += TimeSlice;
  32. return OK;
  33. }
  34. //功能:打印所有PCB信息
  35. void PrintProQueue(LinkList Q, PCB *pcb)
  36. {
  37. LinkList p = Q->Next;
  38. printf("进程名 优先数 到达时间 运行时间 已用CPU时间 完成时间 进程状态\n");
  39. if(pcb)
  40. printf(" %4s %2d %4d %4d %3d(+1) %3d %4s \n",
  41. pcb->Name,pcb->Priority,pcb->ArrivalTime,pcb->NeedRunningTime,
  42. pcb->TimeUsedCPU, pcb->FinishTime,pcb->ProcessState == Ready ? "就绪" : "运行");
  43. while (p)
  44. {
  45. printf(" %4s %2d %4d %4d %3d %3d %4s \n",
  46. p->data.Name,p->data.Priority,p->data.ArrivalTime,p->data.NeedRunningTime,
  47. p->data.TimeUsedCPU,p->data.FinishTime, p->data.ProcessState == Ready ? "就绪" : "运行");
  48. p = p->Next;
  49. }
  50. printf("-------------------------------------------------------------------------------\n");
  51. }
  52. //功能:当一个进程结束,打印进程信息
  53. void PrintProResult(PCB *pcb)
  54. {
  55. printf("进程名 到达时刻 运行时间 开始时刻 完成时刻 周转时间 带权周转时间 进程状态\n");
  56. if(pcb)
  57. printf(" %2s %3d %4d %4d %3d %4d %5.2lf %4s \n",
  58. pcb->Name,pcb->ArrivalTime,pcb->NeedRunningTime,pcb->StartTime,pcb->FinishTime,
  59. pcb->FinishTime-pcb->ArrivalTime,((pcb->FinishTime - pcb->ArrivalTime)*1.0)/pcb->NeedRunningTime,"完成");
  60. printf("-------------------------------------------------------------------------------\n");
  61. }

main:


  
  1. #include "ProPCB.h"
  2. /****************************
  3. * 实验01: 非抢占式静态优先权 *
  4. * ① 优先权始终保持不变 *
  5. * ② 一旦进入CPU便运行到结束 *
  6. * ③ FCFS只考虑到达时间进CPU *
  7. * ④ SPF认为到达时间相同 *
  8. ****************************/
  9. int CPUUsedTime = 0;
  10. void InputData(LinkList * pPCBdata, PriorityRule PR)
  11. {
  12. ElemType e = {{0},-1,-1,-1,-1,-1,0,Ready};
  13. e.ArrivalTime = 0;
  14. e.ProcessState = Ready;
  15. e.TimeUsedCPU = 0;
  16. strcpy(e.Name,"A");
  17. e.NeedRunningTime = 1;
  18. e.Priority = GetPriority(&e, PR);
  19. if(PR == SPF) e.ArrivalTime = 0;
  20. GetProcess(*pPCBdata,e);
  21. e.ArrivalTime = 1;
  22. e.ProcessState = Ready;
  23. e.TimeUsedCPU = 0;
  24. strcpy(e.Name,"B");
  25. e.NeedRunningTime = 100;
  26. e.Priority = GetPriority(&e, PR);
  27. if(PR == SPF) e.ArrivalTime = 0;
  28. GetProcess(*pPCBdata,e);
  29. e.ArrivalTime = 2;
  30. e.ProcessState = Ready;
  31. e.TimeUsedCPU = 0;
  32. strcpy(e.Name,"C");
  33. e.NeedRunningTime = 1;
  34. e.Priority = GetPriority(&e, PR);
  35. if(PR == SPF) e.ArrivalTime = 0;
  36. GetProcess(*pPCBdata,e);
  37. e.ArrivalTime = 3;
  38. e.ProcessState = Ready;
  39. e.TimeUsedCPU = 0;
  40. strcpy(e.Name,"D");
  41. e.NeedRunningTime = 100;
  42. e.Priority = GetPriority(&e, PR);
  43. if(PR == SPF) e.ArrivalTime = 0;
  44. GetProcess(*pPCBdata,e);
  45. }
  46. //void InputData1(LinkList * pPCBdata, PriorityRule PR)
  47. //{
  48. // ElemType e = {{0},-1,-1,-1,-1,-1,0,Ready};
  49. // e.ArrivalTime = 0;
  50. // e.ProcessState = Ready;
  51. // e.TimeUsedCPU = 0;
  52. // strcpy(e.Name,"A");
  53. // e.NeedRunningTime = 4;
  54. // e.Priority = GetPriority(&e, PR);
  55. // if(PR == SPF) e.ArrivalTime = 0;
  56. // GetProcess(*pPCBdata,e);
  57. //
  58. // e.ArrivalTime = 1;
  59. // e.ProcessState = Ready;
  60. // e.TimeUsedCPU = 0;
  61. // strcpy(e.Name,"B");
  62. // e.NeedRunningTime = 3;
  63. // e.Priority = GetPriority(&e, PR);
  64. // if(PR == SPF) e.ArrivalTime = 0;
  65. // GetProcess(*pPCBdata,e);
  66. //
  67. // e.ArrivalTime = 2;
  68. // e.ProcessState = Ready;
  69. // e.TimeUsedCPU = 0;
  70. // strcpy(e.Name,"C");
  71. // e.NeedRunningTime = 5;
  72. // e.Priority = GetPriority(&e, PR);
  73. // if(PR == SPF) e.ArrivalTime = 0;
  74. // GetProcess(*pPCBdata,e);
  75. //
  76. // e.ArrivalTime = 3;
  77. // e.ProcessState = Ready;
  78. // e.TimeUsedCPU = 0;
  79. // strcpy(e.Name,"D");
  80. // e.NeedRunningTime = 2;
  81. // e.Priority = GetPriority(&e, PR);
  82. // if(PR == SPF) e.ArrivalTime = 0;
  83. // GetProcess(*pPCBdata,e);
  84. //
  85. // e.ArrivalTime = 4;
  86. // e.ProcessState = Ready;
  87. // e.TimeUsedCPU = 0;
  88. // strcpy(e.Name,"E");
  89. // e.NeedRunningTime = 4;
  90. // e.Priority = GetPriority(&e, PR);
  91. // if(PR == SPF) e.ArrivalTime = 0;
  92. // GetProcess(*pPCBdata,e);
  93. //}
  94. int main(void)
  95. {
  96. LinkList PCBQueue; //InitPCBdata里面存放PCB初始数据
  97. ElemType e = {{0},-1,-1,-1,-1,-1,0,Ready};
  98. ElemType *pcb = NULL;
  99. PriorityRule PR;
  100. PR = FCFS; // SPF or FCFS
  101. //*********** 初始化就绪队列 *************//
  102. Init(&PCBQueue);
  103. InputData(&PCBQueue, PR);
  104. printf("初始数据如下:\n");
  105. PrintProQueue(PCBQueue, pcb);
  106. //*********** 进程根据优先级上CPU *************//
  107. printf("\n进程运行信息如下:\n");
  108. while (OutProsess(PCBQueue, &e))
  109. {
  110. //一次性运行完毕
  111. while(e.TimeUsedCPU < e.NeedRunningTime) //上完CPU的进程是否完毕
  112. {
  113. CPURunPro(PCBQueue, &e); //上CPU
  114. ++CPUUsedTime; //CPU时间增加
  115. }
  116. //*********** 当进程执行完毕时打印输出 *************//
  117. e.FinishTime = CPUUsedTime;
  118. PrintProResult(&e);
  119. }
  120. getchar();
  121. return 0;
  122. }

 

文章来源: fantianzuo.blog.csdn.net,作者:兔老大RabbitMQ,版权归原作者所有,如需转载,请联系作者。

原文链接:fantianzuo.blog.csdn.net/article/details/102887367

【版权声明】本文为华为云社区用户转载文章,如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@huaweicloud.com
  • 点赞
  • 收藏
  • 关注作者

评论(0

0/1000
抱歉,系统识别当前为高风险访问,暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称,即可参与社区互动!

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。