【OS课程设计三】模拟进程调度

一、设计目的

1、理解PCB
2、理解进程的并发执行
3、理解进程的FCFS、动态优先权和时间片轮转三种调度算法,并模拟实现这三种算法
二、设计要求
1、PCB在本设计中的基本结构
Typedef struct node
{
Char name[10];/*进程标识符*/
Int prin;/*进程的优先级*/
Int round;/*进程轮转的时间片*/
Int needtime;/*进程还需要的cpu时间*/
Int waittime;/*进程进入系统后等待cpu的时间*/
Char state;/*进程的状态*/
Struct node *next;/*链接指针*/
}PCB
设计三个队列:就绪、完成、运行,其中运行队列中应该只有一个进程。
创建进程,就是用户输入进程的标识符和运行所需时间,系统为其生成一个PCB,存放进程的信息,将新生成的PCB插入就绪队列。进程任务结束,系统将其PCB插入完成队列,该进程就消亡。
2、动态优先权调度算法模拟:
优先权= 1 + 等待时间/需要服务时间----最高响应比优先
(1) 输入一批作业的进程标识和估计运行时间,将其PCB插入就绪队列
(2) 当就绪队列非空、CPU空闲时,计算出每个就绪进程的优先权
(3) 将优先权最高的进程从就绪队列移入运行队列,状态改为运行
(4) 在屏幕上输出当前所有进程的状态和优先权信息(已完成进程不需此项)
(5) 让运行进程执行足够的服务时间
(6) 将运行进程移入完成队列
(7) 提示可以输入新的作业,如果有新作业输入,则转向(1) ,否则转向(2)
(8) 如果就绪队列为空,则结束
3、时间片轮转调度算法模拟
输入一批作业的进程标识和估计运行时间,由其PCB组成就绪队列。时间片轮转调度,系统要给就绪队列的第一个进程分配一个时间片,大小等于n (个时钟周期),再将它移入运行队列。注意,时间片的大小要比大多数进程的估计运行时间短。当时间片结束的时候,要将没有运行完的进程从运行队列移到就绪队列的末尾,再次进行调度。在每次调度时将所有进程的当前情况显示出来。
4、FCFS调度算法模拟
按一定的顺序输入一批作业的进程标识和估计运行时间,由其PCB按照进程标识输入的顺序组成就绪队列。当就绪队列非空、CPU空闲时,将就绪队列的第一个进程从就绪队列移入运行队列,状态改为运行。以后个步骤类似于2。

 

linked_list.h

Code:
  1. /*====================================================================  
  2.                            Linked_Queue.h  
  3.                                                 marcusxing 2009/12/5         
  4. ====================================================================*/  
  5.   
  6. #ifndef _LINKED_QUEUE_H_   
  7. #define _LINKED_QUEUE_H_   
  8.   
  9.     typedef struct node_pcb   
  10.     {   
  11.         char name[10];               /*进程标识符*/  
  12.         int pri;                     /*进程的优先级*/  
  13.         int round;                   /*进程轮转的时间片*/  
  14.         int need_time;               /*进程还需要的cpu时间*/  
  15.         int wait_time;               /*进程进入系统后等待cpu的时间*/  
  16.         char state;                  /*进程的状态*/  
  17.         struct node_pcb *next;       /*链接指针*/  
  18.     }PCB;   
  19.   
  20.     typedef struct type_linked_queue   
  21.     {   
  22.         PCB *tail;                   /*尾指针*/  
  23.         PCB *head;                   /*头指针*/  
  24.         PCB *max_pri;                /*最大优先级长度*/  
  25.         int size;                    /*队列长度*/  
  26.     }Linked_Queue;   
  27.        
  28.     void Init_Linked_Queue(Linked_Queue *linked_queue);   
  29.     int Is_Empty(Linked_Queue *linked_queue);   
  30.     int En_Queue(Linked_Queue *linked_queue,const char *name,int need_time);   
  31.     int En_Queue_Copy(Linked_Queue *linked_queue,PCB *copy_pcb);   
  32.     int De_Queue(Linked_Queue *linked_queue,PCB *ret_pcb);   
  33.     int De_Queue_Max_Pri(Linked_Queue *linked_queue,PCB *ret_pcb);   
  34.     void Destroy_Linked_Queue(Linked_Queue *linked_queue);   
  35.     void Disp_Linked_Queue(Linked_Queue *linked_queue,const char*queue_name);   
  36.   
  37. #endif   

linked_queue.c

Code:
  1. /*====================================================================  
  2.                            Linked_Queue.c  
  3.                                                  marcusxing 2009/12/5         
  4. ====================================================================*/  
  5.   
  6. #include <stdio.h>   
  7. #include <string.h>   
  8. #include "Linked_Queue.h"   
  9.   
  10. extern Linked_Queue *ready_queue;   
  11.   
  12. static void Locate_Max_Pri(Linked_Queue *linked_queue);   
  13. static void Update_Ready_Queue_Pri();   
  14.   
  15. void Init_Linked_Queue(Linked_Queue *linked_queue)   
  16. {   
  17.     linked_queue->tail = linked_queue->head = linked_queue->max_pri = NULL;   
  18.     linked_queue->size = 0;   
  19. }   
  20.   
  21. int Is_Empty(Linked_Queue *linked_queue)   
  22. {   
  23.     return linked_queue->size == 0;   
  24. }   
  25.   
  26. int En_Queue(Linked_Queue *linked_queue,const char *name,int need_time)   
  27. {   
  28.     PCB *new_pcb = (PCB*)malloc(sizeof(PCB));   
  29.   
  30.     if(new_pcb != NULL)   
  31.     {   
  32.         strcpy(new_pcb->name,name);   
  33.         new_pcb->round = 3;   
  34.         new_pcb->need_time = need_time;   
  35.         new_pcb->wait_time = 0;   
  36.         new_pcb->state = 'r';   
  37.         new_pcb->pri = 1 + new_pcb->wait_time / need_time;   
  38.         new_pcb->next = NULL;   
  39.            
  40.         if(Is_Empty(linked_queue))   
  41.         {   
  42.             linked_queue->tail = linked_queue->head = linked_queue->max_pri = new_pcb;   
  43.         }   
  44.         else  
  45.         {   
  46.             linked_queue->tail->next = new_pcb;   
  47.             linked_queue->tail = new_pcb;   
  48.         }   
  49.         linked_queue->size++;   
  50.         Locate_Max_Pri(linked_queue);   
  51.   
  52.         return  1;   
  53.     }   
  54.     else  
  55.     {   
  56.         printf("allocated error!/n");   
  57.         return  0;   
  58.     }   
  59. }   
  60.   
  61. int En_Queue_Copy(Linked_Queue *linked_queue,PCB *copy_pcb)   
  62. {   
  63.     PCB *new_pcb = (PCB*)malloc(sizeof(PCB));   
  64.     if(new_pcb != NULL)   
  65.     {   
  66.         strcpy(new_pcb->name,copy_pcb->name);   
  67.         new_pcb->round = copy_pcb->round;   
  68.         new_pcb->need_time = copy_pcb->need_time;   
  69.         new_pcb->wait_time = copy_pcb->wait_time;   
  70.         new_pcb->state = copy_pcb->state;   
  71.         new_pcb->pri = copy_pcb->pri;   
  72.         new_pcb->next = copy_pcb->next;   
  73.            
  74.         if(Is_Empty(linked_queue))   
  75.         {   
  76.             linked_queue->tail = linked_queue->head = linked_queue->max_pri = new_pcb;   
  77.         }   
  78.         else  
  79.         {   
  80.             linked_queue->tail->next = new_pcb;   
  81.             linked_queue->tail = new_pcb;   
  82.         }   
  83.         linked_queue->size++;   
  84.         Locate_Max_Pri(linked_queue);   
  85.         return  1;   
  86.     }   
  87.     else  
  88.     {   
  89.         printf("allocated error!/n");   
  90.         return  0;   
  91.     }   
  92. }   
  93.   
  94. int De_Queue(Linked_Queue *linked_queue,PCB *ret_pcb)   
  95. {   
  96.     PCB *tmp;   
  97.     if(!Is_Empty(linked_queue))   
  98.     {   
  99.         strcpy(ret_pcb->name,linked_queue->head->name);   
  100.         ret_pcb->round = linked_queue->head->round;   
  101.         ret_pcb->need_time = linked_queue->head->need_time;   
  102.         ret_pcb->wait_time = linked_queue->head->wait_time;   
  103.         ret_pcb->state = linked_queue->head->state;   
  104.         ret_pcb->pri = linked_queue->head->pri;   
  105.         ret_pcb->next = linked_queue->head->next;   
  106.            
  107.         if(linked_queue->size == 1)   
  108.         {   
  109.             linked_queue->tail = linked_queue->head = linked_queue->max_pri = NULL;   
  110.         }   
  111.         else  
  112.         {   
  113.              tmp = linked_queue->head;   
  114.              linked_queue->head = linked_queue->head->next;   
  115.              free(tmp);   
  116.         }   
  117.         linked_queue->size--;   
  118.         Locate_Max_Pri(linked_queue);   
  119.         return 1;   
  120.     }   
  121.     else  
  122.     {   
  123.         printf("empty queue error/n");   
  124.         return 0;   
  125.     }   
  126. }   
  127.   
  128. int De_Queue_Max_Pri(Linked_Queue *linked_queue,PCB *ret_pcb)   
  129. {   
  130.     PCB *tmp;   
  131.     if(!Is_Empty(linked_queue))   
  132.     {   
  133.         strcpy(ret_pcb->name,linked_queue->max_pri->name);   
  134.         ret_pcb->round = linked_queue->max_pri->round;   
  135.         ret_pcb->need_time = linked_queue->max_pri->need_time;   
  136.         ret_pcb->wait_time = linked_queue->max_pri->wait_time;   
  137.         ret_pcb->state = linked_queue->max_pri->state;   
  138.         ret_pcb->pri = linked_queue->max_pri->pri;   
  139.         ret_pcb->next = linked_queue->max_pri->next;   
  140.            
  141.         if(linked_queue->size == 1)   
  142.         {   
  143.             linked_queue->tail = linked_queue->head = linked_queue->max_pri = NULL;   
  144.         }   
  145.         else  
  146.         {   
  147.             if(linked_queue->max_pri == linked_queue->head)   
  148.             {   
  149.                 linked_queue->head = linked_queue->head->next;   
  150.             }   
  151.             else  
  152.             {   
  153.                 tmp = linked_queue->head;   
  154.                 while(tmp->next != linked_queue->max_pri)   
  155.                 {   
  156.                     tmp = tmp->next;   
  157.                 }   
  158.                 if(linked_queue->max_pri == linked_queue->tail)   
  159.                 {   
  160.                     linked_queue->tail = tmp;      
  161.                 }   
  162.                 else  
  163.                 {   
  164.                     tmp->next = linked_queue->max_pri->next;   
  165.                 }   
  166.             }   
  167.             free(linked_queue->max_pri);   
  168.         }   
  169.         linked_queue->size--;   
  170.         Locate_Max_Pri(linked_queue);   
  171.         return 1;   
  172.     }   
  173.     else  
  174.     {   
  175.         printf("empty queue error/n");   
  176.         return 0;   
  177.     }          
  178.        
  179. }   
  180.   
  181. void Destroy_Linked_Queue(Linked_Queue *linked_queue)   
  182. {   
  183.     PCB *tmp = (PCB*)malloc(sizeof(PCB));   
  184.     while(!Is_Empty(linked_queue))   
  185.     {   
  186.         De_Queue(linked_queue,tmp);   
  187.     }   
  188.     free(tmp);   
  189. }   
  190.   
  191. void Disp_Linked_Queue(Linked_Queue *linked_queue,const char*queue_name)   
  192. {   
  193.     PCB *pcb;   
  194.     int size;   
  195.     if(!Is_Empty(linked_queue))   
  196.     {   
  197.         pcb = linked_queue->head;   
  198.         size = linked_queue->size;   
  199.         printf("=============%s=============/n",queue_name);   
  200.         while(size--)   
  201.         {   
  202.             printf("name:%s ",pcb->name);   
  203.             printf("wait_time:%d ",pcb->wait_time);   
  204.             printf("need_time:%d ",pcb->need_time);   
  205.             printf("pri:%d/n",pcb->pri);   
  206.             pcb = pcb->next;   
  207.         }   
  208.     }   
  209.     else  
  210.     {   
  211.         printf("%s is empty/n",queue_name);   
  212.     }   
  213. }   
  214.   
  215. static void Locate_Max_Pri(Linked_Queue *linked_queue)   
  216. {   
  217.     PCB *tmp;   
  218.     int i;   
  219.     int max_pri = 0;   
  220.   
  221.     if(linked_queue == ready_queue)   
  222.     {   
  223.         for(i = 0,tmp = linked_queue->head ; i < linked_queue->size ; i++,tmp = tmp->next)   
  224.         {   
  225.             tmp->pri = 1 + (int)(tmp->wait_time / tmp->need_time);   
  226.         }   
  227.            
  228.             tmp = linked_queue->head;   
  229.   
  230.         for(i = 0 ; i < linked_queue->size ; i++)   
  231.         {   
  232.             if(tmp->pri > max_pri)   
  233.             {   
  234.                 max_pri = tmp->pri;   
  235.                 linked_queue->max_pri = tmp;   
  236.             }   
  237.             tmp = tmp->next;   
  238.         }   
  239.     }   
  240. }   
  241.   

schedule.h

Code:
  1. /*====================================================================  
  2.                            schedule.h  
  3.                                                 marcusxing 2009/12/6         
  4. ====================================================================*/  
  5.   
  6. #ifndef _SCHEDULE_H_   
  7. #define _SCHEDULE_H_   
  8.   
  9.     void FCFS();   
  10.     void Time_Slice();   
  11.     void Priority_First();   
  12.   
  13. #endif   

schedule.c

Code:
  1. /*====================================================================  
  2.                              schedule.c  
  3.                                                 marcusxing 2009/12/6         
  4. ====================================================================*/  
  5.   
  6. #include <stdio.h>   
  7. #include "Linked_Queue.h"   
  8. #include "schedule.h"   
  9.   
  10. extern Linked_Queue *ready_queue;   
  11. extern Linked_Queue *finished_queue;   
  12. extern Linked_Queue *running_queue;   
  13.   
  14. static void Init_Queues();   
  15. static void Clear_Queues();   
  16. static void Input_Queues();   
  17.   
  18. void FCFS()   
  19. {   
  20.     Init_Queues();   
  21.     Input_Queues();   
  22.        
  23.     PCB *tmp_pcb = (PCB*)malloc(sizeof(PCB));   
  24.     printf("start schedule/n");   
  25.     Disp_Linked_Queue(ready_queue,"ready_queue");   
  26.        
  27.     while(!Is_Empty(ready_queue))   
  28.     {   
  29.         De_Queue(ready_queue,tmp_pcb);   
  30.         En_Queue_Copy(running_queue,tmp_pcb);   
  31.         running_queue->head->state = 'e';   
  32.         while(running_queue->head->need_time--)   
  33.         {   
  34.             sleep(1);   
  35.         }   
  36.         De_Queue(running_queue,tmp_pcb);   
  37.         tmp_pcb->state = 'f';   
  38.         En_Queue_Copy(finished_queue,tmp_pcb);   
  39.         Disp_Linked_Queue(ready_queue,"ready_queue");   
  40.     }   
  41.        
  42.     free(tmp_pcb);   
  43.     Clear_Queues();   
  44. }   
  45.   
  46. void Time_Slice()   
  47. {   
  48.     Init_Queues();   
  49.     Input_Queues();   
  50.        
  51.     PCB *tmp_pcb = (PCB*)malloc(sizeof(PCB));   
  52.     int round;   
  53.     int flag = 0;   
  54.     printf("start schedule/n");   
  55.     Disp_Linked_Queue(ready_queue,"ready_queue");   
  56.        
  57.     while(!Is_Empty(ready_queue))   
  58.     {   
  59.         De_Queue(ready_queue,tmp_pcb);   
  60.         En_Queue_Copy(running_queue,tmp_pcb);   
  61.         running_queue->head->state = 'e';   
  62.         round = running_queue->head->round;   
  63.         while(round--)   
  64.         {   
  65.             sleep(1);   
  66.             running_queue->head->need_time--;   
  67.             if(running_queue->head->need_time == 0)   
  68.             {   
  69.                 De_Queue(running_queue,tmp_pcb);   
  70.                 tmp_pcb->state = 'f';   
  71.                 En_Queue_Copy(finished_queue,tmp_pcb);   
  72.                 Disp_Linked_Queue(ready_queue,"ready_queue");   
  73.                 flag = 1;   
  74.                 break;   
  75.             }   
  76.         }   
  77.         if(flag)   
  78.         {   
  79.             flag = 0;   
  80.             continue;   
  81.         }   
  82.   
  83.         De_Queue(running_queue,tmp_pcb);   
  84.         tmp_pcb->state = 'r';   
  85.         En_Queue_Copy(ready_queue,tmp_pcb);   
  86.         Disp_Linked_Queue(ready_queue,"ready_queue");   
  87.     }   
  88.        
  89.     free(tmp_pcb);   
  90.     Clear_Queues();   
  91. }   
  92.   
  93. void Priority_First()   
  94. {   
  95.     Init_Queues();   
  96.     Input_Queues();   
  97.     int round,i;   
  98.     int flag = 0;   
  99.   
  100.     PCB *tmp_pcb = (PCB*)malloc(sizeof(PCB));   
  101.     PCB *tmp;   
  102.   
  103.     printf("start schedule/n");   
  104.     Disp_Linked_Queue(ready_queue,"ready_queue");   
  105.   
  106.     while(!Is_Empty(ready_queue))   
  107.     {   
  108.         De_Queue_Max_Pri(ready_queue,tmp_pcb);   
  109.         En_Queue_Copy(running_queue,tmp_pcb);   
  110.         running_queue->head->state = 'e';   
  111.         round = running_queue->head->round;   
  112.   
  113.         while(round--)   
  114.         {   
  115.             sleep(1);   
  116.             running_queue->head->need_time--;   
  117.   
  118.             for(i = 0,tmp = ready_queue->head ; i < ready_queue->size ; i++,tmp = tmp->next)   
  119.             {   
  120.                 tmp->wait_time++;   
  121.             }   
  122.   
  123.             if(running_queue->head->need_time == 0)   
  124.             {   
  125.                 De_Queue(running_queue,tmp_pcb);   
  126.                 tmp_pcb->state = 'f';   
  127.                 En_Queue_Copy(finished_queue,tmp_pcb);   
  128.   
  129.                 Disp_Linked_Queue(ready_queue,"ready_queue");   
  130.                 flag = 1;   
  131.                 break;   
  132.             }   
  133.         }   
  134.         if(flag)   
  135.         {   
  136.             flag = 0;   
  137.             continue;   
  138.         }   
  139.   
  140.         De_Queue(running_queue,tmp_pcb);   
  141.         tmp_pcb->state = 'r';   
  142.         En_Queue_Copy(ready_queue,tmp_pcb);   
  143.   
  144.         Disp_Linked_Queue(ready_queue,"ready_queue");   
  145.     }      
  146.   
  147.     free(tmp_pcb);   
  148.     Clear_Queues();   
  149. }   
  150.   
  151. static void Init_Queues()   
  152. {   
  153.     ready_queue = (Linked_Queue*)malloc(sizeof(Linked_Queue));   
  154.     finished_queue = (Linked_Queue*)malloc(sizeof(Linked_Queue));   
  155.     running_queue = (Linked_Queue*)malloc(sizeof(Linked_Queue));   
  156.        
  157.     Init_Linked_Queue(ready_queue);   
  158.     Init_Linked_Queue(finished_queue);   
  159.     Init_Linked_Queue(running_queue);   
  160. }   
  161.   
  162. static void Clear_Queues()   
  163. {   
  164.     Destroy_Linked_Queue(ready_queue);   
  165.     Destroy_Linked_Queue(finished_queue);   
  166.     Destroy_Linked_Queue(running_queue);   
  167.        
  168.     free(ready_queue);   
  169.     free(finished_queue);   
  170.     free(running_queue);   
  171. }   
  172.   
  173. static void Input_Queues()   
  174. {   
  175.     int proc_num,i,need_time;   
  176.     char proc_name[10];   
  177.        
  178.     printf("please enter the number of process:");   
  179.     scanf("%d",&proc_num);   
  180.     for(i = 0 ; i < proc_num ; i++)   
  181.     {   
  182.         printf("please enter the process's name and need time:");   
  183.         scanf("%s%d",proc_name,&need_time);   
  184.         En_Queue(ready_queue,proc_name,need_time);     
  185.     }   
  186. }   
  187.   

main.c

Code:
  1. /*====================================================================  
  2.                                main.c  
  3.                                                 marcusxing 2009/12/6         
  4. ====================================================================*/  
  5.   
  6. #include "Linked_Queue.h"   
  7. #include "schedule.h"   
  8. #include <stdio.h>   
  9.   
  10. Linked_Queue *ready_queue;   
  11. Linked_Queue *finished_queue;   
  12. Linked_Queue *running_queue;   
  13.   
  14. int main()   
  15. {   
  16.     printf("welcome to my OS big work NO 1/n");   
  17.     printf("select a schedule style:/n");   
  18.     printf("1:FCFS/n");   
  19.     printf("2:Time Slice/n");   
  20.     printf("3:Priority First/n");   
  21.   
  22.     int index;   
  23.     scanf("%d",&index);   
  24.   
  25.     switch(index)   
  26.     {   
  27.         case 1:   
  28.             FCFS();   
  29.             break;   
  30.         case 2:   
  31.             Time_Slice();   
  32.             break;   
  33.         case 3:   
  34.             Priority_First();   
  35.             break;   
  36.         default:   
  37.             printf("**!/n");   
  38.             break;   
  39.     }   
  40.   
  41.     return 0;   
  42. }   
  43.   

  • 0
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
一、课程设计目的 1、要求学生设计一个模拟进程调度算法 2、理解进程控制块的结构 3、理解进程运行的并发性 4、掌握进程调度三种基本算法 二、课程设计题目描述和要求 设计题目描述 在多道程序运行环境下,进程数目一般多于处理机数目,使得进程要通过竞争来使用处理机。这就要求系统能按某种算法,动态地把处理机分配给就绪队列中的一个进程,使之运行,分配处理机的任务是由进程调度程序完成的。一个进程被创建后,系统为了便于对进程进行管理,将系统中的所有进程按其状态,将其组织成不同的进程队列。于是系统有运行进程队列、就绪进程队列和各种事件的进程等待队列。进程调度的功能就是从就绪队列中挑选一个进程到处理机上运行。进程调度算法有多种,常用的有优先级调度算法、先来先服务算法、时间片轮转算法。 进程是程序在处理机上的执行过程。进程存在的标识是进程控制块(PCB),进程控制块结构如下: Typeedef struct node { Char name[10]; /*进程标识符*/ Int prio; /*进程优先数*/ Int cputime /*进程占用CPU时间*/ Int neentime /*进程到完成还需要的时间*/ Char state; /*进程的状态*/ Struct node *next; /*链指针*/ }PCB; 系统创建一个进程,就是由系统为某个程序设置一个PCB,用于对该进程进行控制和管理。进程任务完成,由系统收回其PCB,该进程便消亡。每个进程可以有个状态:运行态、就绪态和完成状态。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值