精华内容
下载资源
问答
  • 实验一、进程调度实验报告
    2021-05-20 17:29:34

    广东技术师范学院实验报告

    学院:计算机科学学

    专业:

    计算机科学与

    技术(师范)

    班级:成绩:

    姓名:学号:组别:组员:

    实验地点:实验日期:指导教师签名:

    299e8ca3651aa6a014b42eaff1673ec6.png

    实验名称:实验一、进程调度实验

    一、实验目的

    用高级语言编写和调试一个进程调度程序,以加深对进程的概念及进程调度算法的理解

    二、实验类别

    综合性实验。综合高级语言编程、进程调度模型、进程调度算法及数据结构等多方面的知识

    三、实验内容和步骤

    1.编写并调试一个模拟的进程调度程序,采用“最高优先数优先”调度算法对五个进程进行调度。

    “最高优先数优先”调度算法的基本思想是把CPU分配给就绪队列中优先数最高的进程。

    静态优先数是在创建进程时确定的,并在整个进程运行期间不再改变。

    动态优先数是指进程的优先数在创建进程时可以给定一个初始值,并且可以按一定原则修改优先数。例如:在进程获得一次CPU后就将其优先数减少1。或者,进程等待的时间超过某一时限时增加其优先数的值,等等

    该题根据老师给的代码用Visual C++运行,结果以及分析如下:

    更多相关内容
  • 实用标准文案 优 先 级 调 度 算 法 实 验 报 告 院系 * 学院 班级 * 姓名 * 学号 * 精彩文档 实用标准文案 一实验题目 优先级调度算法 二实验目的 进程调度是处理机管理的核心内容 本实验要求用高级语言编写 模拟...
  • 进程调度算法模拟 专业 XXXXX 学号 XXXXX 姓名 XXX 实验日期 20XX 年 XX 月 XX 日 一实验目的 通过对进程调度算法的模拟加深对进程概念和进程调度算法的理解 二实验要求 编写程序实现对 5 个进程的调度模拟 要求至少...
  • C++实现优先进程调度算法源代码+实验报告:计算机操作系统课程综合性实验报告-进程调度算法程序设计。
  • 目录 一、实验目的 二、实验内容 三、实验原理 四....六....七.... 本实验模拟在单处理器情况下的处理器调度,帮助学生加深了解处理器调度的工作。 二、实验内容 设计一个程序,根据不同的调度算...

    目录

     

    一、实验目的

    二、实验内容

    三、实验原理

    四.算法流程图

     六.运行结果

    七.实验小结


    一、实验目的

    1. 在采用多道程序设计的系统中,往往有若干个进程同时处于就绪状态。
    2. 当就绪进程个数大于处理器数时,就必须依照某种策略来决定哪些进程优先占用处理器。
    3. 本实验模拟在单处理器情况下的处理器调度,帮助学生加深了解处理器调度的工作。

    二、实验内容

    1. 设计一个程序,根据不同的调度算法模拟操作系统对进程的调度。 
    2. 动态优先级法 
    3. 设计进程控制块PBC表结构,分别适用优先数调度算法 
    4.  PBC结构通常包括以下信息:进程名、进程优先数、轮转时间片、进程的CPU时间,进程状态等。根据调度算法不同,PCB结构可作适当的调整。 
    5.  建立进程队列。对不同的算法编制不同的入链程序。 
    6. 程序要求达到的运行效果:在设置好进程数量、调度算法后,系统能按设定的参数运行,并在屏幕上交替显示就绪队列和完成队列的进程名等信息。

    三、实验原理

    设计一个按优先数调度算法实现处理器调度的程序

    •  假定系统有五个进程每一个进程用一个进程控制块PCB来代表,进程控制块的格式为:

    进程名

    指针

    要求运行时间

    优先数

    状态

    其中,进程名——作为进程的标识,假设五个进程的进程名分别为P1,P2,P3,P4,P5。

    指针——按优先数的大小把五个进程连成队列,用指针指出下一个进程的进程控制块的首地址,最后一个进程中的指针为“0”。

    要求运行时间——假设进程需要运行的单位时间数。

    优先数——赋予进程的优先数,调度时总是选取优先数大的进程先执行。

    状态——可假设有两种状态,“就绪”状态和“结束”状态。五个进程的初始状态都为“就绪”,用“R”表示,当一个进程运行结束后,它的状态为“结束”,用“E”表示。

    •  在每次运行你所设计的处理器调度程序之前,为每个进程任意确定它的“优先数”和“要求运行时间”。
    • 为了调度方便,把五个进程按给定的优先数从大到小连成队列。用一单元指出队首进程,用指针指出队列的连接情况。例:

      队首标志

             K2    

    K1

    P1

     K2

    P2

     K3

    P3

     K4

    P4

     K5

    P5

     

    0

     

    K4

     

    K5

     

    K3

     

    K1

     

    2

     

    3

     

    1

     

    2

     

    4

     

    1

     

    5

     

    3

     

    4

     

    2

     

    R

     

    R

     

    R

     

    R

     

    R

     

    PCB1

     

    PCB2

     

    PCB3

     

    PCB4

     

    PCB5

     

    •  处理器调度总是选队首进程运行。采用动态改变优先数的办法,进程每运行一次优先数就减“1”。由于本实验是模拟处理器调度,所以,对被选中的进程并不实际的启动运行,而是执行:

    优先数-1

    要求运行时间-1

    来模拟进程的一次运行。

    提醒注意的是:在实际的系统中,当一个进程被选中运行时,必须恢复进程的现场,让它占有处理器运行,直到出现等待事件或运行结束。在这里省去了这些工作。

    • 进程运行一次后,若要求运行时间¹0,则再将它加入队列(按优先数大小插入,且置队首标志);若要求运行时间=0,则把它的状态修改成“结束”(E),且退出队列。
    • 若“就绪”状态的进程队列不为空,则重复上面(4)和(5)的步骤,直到所有进程都成为“结束”状态。
    •  在所设计的程序中应有显示或打印语句,能显示或打印每次被选中进程的进程名以及运行一次后进程队列的变化。
    • 为五个进程任意确定一组“优先数”和“要求运行时间”,启动所设计的处理器调度程序,显示或打印逐次被选中进程的进程名以及进程控制块的动态变化过程。

    四.算法流程图

    五.源程序及注释

    •  

    struct pcb   /* 定义进程控制块PCB */ {

        char name[10];//存储进程名
        struct pcb* next;  //指针
        int super;        //优先级数
        int ntime;       //运行时间
        int rtime;
        char state;       //进程状态
    }*ready = NULL, *p;
    typedef struct pcb PCB;  

    • 程序包含函数:

     input(); /* 建立进程控制块函数*/
    sort(); /* 建立对进程进行优先级排列函数*/  
    disp(PCB * pr) ;/*建立进程显示函数,用于显示当前进程*/
    check() ;// 建立进程查看函数 
    destroy(); /*建立进程撤消函数(进程运行结束,撤消进程)*/
    running(); /* 建立进程就绪函数(进程运行时间到,置就绪状态*/ 
     main(void) {
    }/*主函数*/
                                                               

    • 打印一份源程序并附上注释。

     

    
    #define _CRT_SECURE_NO_WARNINGS 
    #include <stdio.h>
    #include <stdlib.h> 
    
    #define getpch(type) (type*)malloc(sizeof(type)) 
    
    
    
    struct pcb   /* 定义进程控制块PCB */ {
    	char name[10];//存储进程名
    	struct pcb* next;  //指针
    	int super;        //优先级数
    	int ntime;       //运行时间
    	int rtime;
    	char state;       //进程状态
    }*ready = NULL, *p;
    typedef struct pcb PCB;
    
    void sort() /* 建立对进程进行优先级排列函数*/ {
    	PCB *first, *second;
    	int insert = 0;
    	if ((ready == NULL) || ((p->super) > (ready->super))) /*优先级最大者,插入队首*/
    	{
    		p->next = ready;//插入的数据作为链表头结点
    		ready = p;//头结点指针指向插入数
    	}
    
    	else /* 进程比较优先级,插入适当的位置中*/ {
    		first = ready;
    		second = first->next;
    		while (second != NULL)
    		{
    			if ((p->super) > (second->super)) /*若插入进程比当前进程优先数大,*/
    			{ /*插入到当前进程前面*/
    				p->next = second;
    				first->next = p;
    				second = NULL;
    				insert = 1;
    			}
    			else /* 插入进程优先数最低,则插入到队尾*/
    			{
    
    				first = first->next;
    				second = second->next;
    			}
    		}
    		if (insert == 0)
    			first->next = p;
    	}
    }
    
    void input() /* 建立进程控制块函数*/
    {
    	int i, num;
    	printf("\n 请输入进程数:");
    	scanf("%d", &num);
    	for (i = 0; i < num; i++)
    	{
    		printf("\n 进程号%d:\n", i + 1);
    		p = getpch(PCB);
    		printf("\n 输入进程名:");
    		scanf("%s", p->name);
    		printf("\n 输入进程优先数:");
    		scanf("%d", &p->super);
    		printf("\n 输入进程运行时间:");
    		scanf("%d", &p->ntime);
    		printf("\n");
    		p->rtime = 0; p->state = 'w';
    		p->next = NULL;
    		sort(); //调用sort函数
    	}
    }
    
    int space()
    {
    
    	int len = 0; PCB* pr = ready;
    	while (pr != NULL)
    	{
    		len++;
    		pr = pr->next;
    	}
    	return(len);
    }
    
    void disp(PCB * pr) /*建立进程显示函数,用于显示当前进程*/
    {
    	printf("\n qname \t state \t super \t ndtime   runtime \n");
    	printf("|%s\t", pr->name);
    	printf("|%c\t", pr->state);
    	printf("|%d\t", pr->super);
    	printf("|%d\t", pr->ntime);
    	printf("|%d\t", pr->rtime);
    	printf("\n");
    
    }
    
    void check() // 建立进程查看函数 
    {
    	PCB* pr;
    	printf("\n **** 当前正在运行的进程是:%s", p->name); //显示当前运行进程
    	disp(p);
    	pr = ready;
    	printf("\n ****当前就绪队列状态为:\n"); //显示就绪队列状态
    	while (pr != NULL)
    	{
    		disp(pr);
    		pr = pr->next;
    	}
    }
    
    void destroy() /*建立进程撤消函数(进程运行结束,撤消进程)*/
    {
    	printf("\n 进程 [%s] 已完成.\n", p->name);
    	free(p);
    }
    
    void running() /* 建立进程就绪函数(进程运行时间到,置就绪状态*/
    
    {
    	(p->rtime)++;
    	if (p->rtime == p->ntime)
    		destroy(); /* 调用destroy函数*/
    	else
    	{
    		(p->super)--;
    		p->state = 'w';
    		sort(); /*调用sort函数*/
    	}
    }
    int main(void) /*主函数*/
    {
    	while (true)
    	{
    		int len;//
    		char ch;
    		input();
    		len =space();
    		while ((len != 0) && (ready != NULL))
    		{
    			ch = getchar();
    			p = ready;
    			ready = p->next;
    			p->next = NULL;
    			p->state = 'R';
    			check();
    			running();
    			system("pause");
    		}
    
    		printf("\n\n 进程已经完成.\n");
    	}
    	system("pause");
    	return 0;
    }
    

     六.运行结果

     

    七.实验小结

    1.基本思想:为每个进程设置一个优先级,在调度的时候,选取优先级最大的任务去执行。

    2.优先级可以是静态赋予:创建任务的时候,就指定优先级大小,并且保持不变,直到任务结束。

    3.也可以是动态赋予:优先级在执行任务中动态改变。

    4.为了防止高优先级进程无休止地运行下去,调度程序可以在每个时钟中断降低当前进程的优先级。

    5.在平时中,我们可以把不同的任务划分为不同的优先级,然后在相同优先级的任务中使用时间片轮转。

     

    展开全文
  • python实现进程调度

    2019-12-29 14:45:18
    python模拟实现进程调度算法,先来先服务,短作业优先,静态高优先级优先,动态高优先级优先,时间片轮转法
  • 操作系统进程调度实验报告

    千次阅读 2020-09-30 22:12:37
    实验模拟在单处理器情况下的处理器调度,帮助学生加深了解处理器调度的工作。 二、实验内容 (1) 假定系统有五个进程,每一个进程用一个进程控制块PCB来代表,进程控制块的格式为: 进程名 指针 要求运行时间 优先...

    一、实验目的
    在采用多道程序设计的系统中,往往有若干个进程同时处于就绪状态。当就绪进程个数大于处理器数时,就必须依照某种策略来决定哪些进程优先占用处理器。本实验模拟在单处理器情况下的处理器调度,帮助学生加深了解处理器调度的工作。

    二、实验内容
    (1) 假定系统有五个进程,每一个进程用一个进程控制块PCB来代表,进程控制块的格式为:
    进程名
    指针
    要求运行时间
    优先数
    状态
    其中,进程名——作为进程的标识,假设五个进程的进程名分别为P1,P2,P3,P4,P5。
    指针——按优先数的大小把五个进程连成队列,用指针指出下一个进程的进程控制块的首地址,最后一个进程中的指针为“0”。
    要求运行时间——假设进程需要运行的单位时间数。
    优先数——赋予进程的优先数,调度时总是选取优先数大的进程先执行。
    状态——可假设有两种状态,“就绪”状态和“结束”状态。五个进程的初始状态都为“就绪”,用“R”表示,当一个进程运行结束后,它的状态为“结束”,用“E”表示。
    (2) 在每次运行你所设计的处理器调度程序之前,为每个进程任意确定它的“优先数”和“要求运行时间”。
    (3) 为了调度方便,把五个进程按给定的优先数从大到小连成队列。用一单元指出队首进程,用指针指出队列的连接情况。例:
    队首标志
    K2
    K1 P1 K2 P2 K3 P3 K4 P4 K5 P5
    0 K4 K5 K3 K1
    2 3 1 2 4
    1 5 3 4 2
    R R R R R
    PCB1 PCB2 PCB3 PCB4 PCB5

    (4) 处理器调度总是选队首进程运行。采用动态改变优先数的办法,进程每运行一次优先数就减“1”。由于本实验是模拟处理器调度,所以,对被选中的进程并不实际的启动运行,而是执行:
    优先数-1
    要求运行时间-1
    来模拟进程的一次运行。
    提醒注意的是:在实际的系统中,当一个进程被选中运行时,必须恢复进程的现场,让它占有处理器运行,直到出现等待事件或运行结束。在这里省去了这些工作。
    (5) 进程运行一次后,若要求运行时间¹0,则再将它加入队列(按优先数大小插入,且置队首标志);若要求运行时间=0,则把它的状态修改成“结束”(E),且退出队列。
    (6) 若“就绪”状态的进程队列不为空,则重复上面(4)和(5)的步骤,直到所有进程都成为“结束”状态。
    (7) 在所设计的程序中应有显示或打印语句,能显示或打印每次被选中进程的进程名以及运行一次后进程队列的变化。
    (8) 为五个进程任意确定一组“优先数”和“要求运行时间”,启动所设计的处理器调度程序,显示或打印逐次被选中进程的进程名以及进程控制块的动态变化过程。

    三、算法流程图

    在这里插入图片描述

    四、源程序及注释
    附录中
    五、测试数据及运行结果
    K2
    K1 P1 K2 P2 K3 P3 K4 P4 K5 P5
    0 K4 K5 K3 K1
    2 3 1 2 4
    1 5 3 4 2
    R R R R R
    PCB1 PCB2 PCB3 PCB4 PCB5

    开始执行P2进程
    进程名:P2//需要运行的时间:3//优先级:5//状态:R
    P2进程执行一次完毕
    进程队列的所有进程信息:
    进程名:P4//需要运行的时间:2//优先级:4//状态:R
    进程名:P2//需要运行的时间:2//优先级:4//状态:R
    进程名:P3//需要运行的时间:1//优先级:3//状态:R
    进程名:P5//需要运行的时间:4//优先级:2//状态:R
    进程名:P1//需要运行的时间:2//优先级:1//状态:R

    开始执行P4进程
    进程名:P4//需要运行的时间:2//优先级:4//状态:R
    P4进程执行一次完毕
    进程队列的所有进程信息:
    进程名:P2//需要运行的时间:2//优先级:4//状态:R
    进程名:P3//需要运行的时间:1//优先级:3//状态:R
    进程名:P4//需要运行的时间:1//优先级:3//状态:R
    进程名:P5//需要运行的时间:4//优先级:2//状态:R
    进程名:P1//需要运行的时间:2//优先级:1//状态:R

    开始执行P2进程
    进程名:P2//需要运行的时间:2//优先级:4//状态:R
    P2进程执行一次完毕
    进程队列的所有进程信息:
    进程名:P3//需要运行的时间:1//优先级:3//状态:R
    进程名:P2//需要运行的时间:1//优先级:3//状态:R
    进程名:P4//需要运行的时间:1//优先级:3//状态:R
    进程名:P5//需要运行的时间:4//优先级:2//状态:R
    进程名:P1//需要运行的时间:2//优先级:1//状态:R

    开始执行P3进程
    进程名:P3//需要运行的时间:1//优先级:3//状态:R
    P3进程执行一次完毕
    P3运行结束
    进程名:P3//需要运行的时间:0//优先级:2//状态:E
    进程队列的所有进程信息:
    进程名:P2//需要运行的时间:1//优先级:3//状态:R
    进程名:P4//需要运行的时间:1//优先级:3//状态:R
    进程名:P5//需要运行的时间:4//优先级:2//状态:R
    进程名:P1//需要运行的时间:2//优先级:1//状态:R

    开始执行P2进程
    进程名:P2//需要运行的时间:1//优先级:3//状态:R
    P2进程执行一次完毕
    P2运行结束
    进程名:P2//需要运行的时间:0//优先级:2//状态:E
    进程队列的所有进程信息:
    进程名:P4//需要运行的时间:1//优先级:3//状态:R
    进程名:P5//需要运行的时间:4//优先级:2//状态:R
    进程名:P1//需要运行的时间:2//优先级:1//状态:R

    开始执行P4进程
    进程名:P4//需要运行的时间:1//优先级:3//状态:R
    P4进程执行一次完毕
    P4运行结束
    进程名:P4//需要运行的时间:0//优先级:2//状态:E
    进程队列的所有进程信息:
    进程名:P5//需要运行的时间:4//优先级:2//状态:R
    进程名:P1//需要运行的时间:2//优先级:1//状态:R

    开始执行P5进程
    进程名:P5//需要运行的时间:4//优先级:2//状态:R
    P5进程执行一次完毕
    进程队列的所有进程信息:
    进程名:P1//需要运行的时间:2//优先级:1//状态:R
    进程名:P5//需要运行的时间:3//优先级:1//状态:R

    开始执行P1进程
    进程名:P1//需要运行的时间:2//优先级:1//状态:R
    P1进程执行一次完毕
    进程队列的所有进程信息:
    进程名:P5//需要运行的时间:3//优先级:1//状态:R
    进程名:P1//需要运行的时间:1//优先级:0//状态:R

    开始执行P5进程
    进程名:P5//需要运行的时间:3//优先级:1//状态:R
    P5进程执行一次完毕
    进程队列的所有进程信息:
    进程名:P1//需要运行的时间:1//优先级:0//状态:R
    进程名:P5//需要运行的时间:2//优先级:0//状态:R

    开始执行P1进程
    进程名:P1//需要运行的时间:1//优先级:0//状态:R
    P1进程执行一次完毕
    P1运行结束
    进程名:P1//需要运行的时间:0//优先级:-1//状态:E
    进程队列的所有进程信息:
    进程名:P5//需要运行的时间:2//优先级:0//状态:R

    开始执行P5进程
    进程名:P5//需要运行的时间:2//优先级:0//状态:R
    P5进程执行一次完毕
    进程队列的所有进程信息:
    进程名:P5//需要运行的时间:1//优先级:-1//状态:R

    开始执行P5进程
    进程名:P5//需要运行的时间:1//优先级:-1//状态:R
    P5进程执行一次完毕
    P5运行结束
    进程名:P5//需要运行的时间:0//优先级:-2//状态:E
    进程控制块中的所有进程执行完毕

    Process finished with exit code 0

    代码

    package 进程调度算法;
    
    class PCB {
        public String name;
        public PCB next;
        public int time;
        public int priority;
        public char state; //'R'就是就绪状态  'E'为结束状态
    
        //指针的话 我们在插入的时候就那个是那个的指针了
        public PCB(String name, int time, int priority, char state) {
            this.name = name;
            this.time = time;
            this.priority = priority;
            this.state = state;
        }
    
        @Override
        public String toString() {
            return "进程名:" + name +  "//需要运行的时间:" + time + "//优先级:" + priority
                    + "//状态:" + state;
        }
    }
    
    
    public class Process {
        private PCB head;//规定一个头节点
    
        //插入操作
        public void addPCB(PCB node) {
    
            //当一个进程运行完毕的时候也就是time = 0 或者 state = 'E'的时候
            //我们就不需要将这个进程插入到控制块中了
            //直接结束
            if (node.state == 'E') {
                System.out.println(node.name + "运行结束");
                System.out.println(node);
                return;
            }
            //如果所需运行时间为0,状态改为E 退出进程队列 E就是结束
            if (node.time == 0) {
                node.state = 'E';//将状态改为E
                System.out.println(node.name + "运行结束");
                System.out.println(node);
                return;
            }
    
            //头节点为空的时候 直接插入就好了
            if (this.head == null) {
                this.head = node;
                return;
            }
    
            //插入的时候需要按优先级进行排序
            //如果这个节点的优先级比头结点大
            //我们需要进行头插法
            if (node.priority > this.head.priority) {
                node.next = this.head;
                this.head = node;
                return;
            }
    
            //优先级和头结点优先级相同的时候,插到头节点的后面就好了(先来服务)
            if (node.priority == this.head.priority) {
                node.next = this.head.next;
                this.head.next = node;
                return;
            }
    
            //如果节点的优先级在中间我们需要挨个比较后然后插入
            //我们需要设置两个节点 进行比较后 然后插入
            PCB cur = this.head.next;
            PCB parent = this.head;
            while (cur != null) {
                //当前的节点的优先级小于node的优先级
                if (node.priority > cur.priority) {
                    node.next = parent.next;
                    parent.next = node;
                    return;
    
                //当前的节点优先级等于node的优先级,同样遵循先来服务
                } else if (node.priority == cur.priority) {
                    parent = cur;
                    node.next = parent.next;
                    parent.next = node;
                    return;
                }
                //向后跳一步
                parent = cur;
                cur = cur.next;
            }
    
            //走到的这里的时候cur已经为空了,那木证明前面的节点的优先级都大于这个节点的优先级了
            //也就是说我们只需要进行尾插就好了
            parent.next = node;
            node.next = null;
        }
    
        //如何去运行进程
        public void run() {
            while (this.head != null) {
                //我们插入的时候是按照优先级来进行的
                //那木我们的运行的时候就从头节点开始运行
                PCB cur = this.head;//创建一个当前的节点指向头节点
                this.head = this.head.next;
                System.out.println();
                System.out.println("开始执行" + cur.name + "进程");
                System.out.println(cur);
                //当前的节点的时间-1 并且优先级-1
                cur.priority -= 1;
                cur.time -= 1;
                //执行一次后我们需要将这个进程再次插入,不管它的运行时间是否完毕,我们在插入的时候会判断
                System.out.println(cur.name + "进程执行一次完毕");
                //将cur再插入进程队列
                addPCB(cur);
    
                //当头节点给为null的时候 也就是这个进程控制块中的所有内容已经执行完毕了
                //我们就直接return可以了 不在需要去执行了
                if (this.head == null) {
                    System.out.println("进程控制块中的所有进程执行完毕");
                    return;
                }
                System.out.println("进程队列的所有进程信息:");
                display();
            }
        }
    
        //遍历这个队列,我们确定来看看这个队列中每一个pcb的状态
        public void display() {
            for (PCB pcb = this.head; pcb != null; pcb = pcb.next) {
                System.out.println(pcb);
            }
        }
    }
    

    怎木调就不用我写了吧。

    展开全文
  • 操作系统原理实验—进程调度实验报告一、目的与要求(1)进程是操作系统最重要的概念之一,进程调度是操作系统内核的重要功能,本实验选用XX语言编写了一个进程调度模拟程序,使用优先级或时间的轮转法实现进程调度。...

    操作系统原理实验—进程调度实验报告

    一、目的与要求

    (1)进程是操作系统最重要的概念之一,进程调度是操作系统内核的重要功能,本实验选用XX语言编写了一个进程调度模拟程序,使用优先级或时间的轮转法实现进程调度。本实验可加深对进程调度算法的理解。

    (2)按照实验题目要求独立地、正确地完成实验内容(编写、调试算法程序,提交程序清单及相关实验数据与运行结果,完成个人实验报告)。

    (3)2020年6月5日以前提交本次实验报告(含实验所有电子文档和纸质报告,实验相关文件打包以 学号-姓名-实验1.rar 为名命名,实验报名以 学号-姓名-实验1为文件名,由学习委员以班为单位统一打包提交)。

    2 实验内容或题目

    (1)设计有5个或5个以上进程并发执行的模拟调度程序,每个程序由一个PCB表示。

    (2)模拟调度程序可任选两种调度算法之一实现,也可实验两个或两个以上调度算法。

    (3)程序执行中应能在屏幕上显示出各进程的状态变化,以便于观察调度的整个过程。

    (4)本次实验内容(项目)的详细说明以及要求请参见实验指导书。

    3 实验步骤与源程序

    1. 算法原理

    时间片轮转调度算法

    1) 时间片轮转算法的思想是,让队列中运行的每个进程都可以得到平等的运行时间片,然后对队列进行循环直到所有进程执行完毕。

    2) 对于时间片大小的选取是十分重要的,既不能太大,如果太大的话会导致短进程无法作业运行,如果时间片太小的话效率又会减小很多。所以对于时间片来讲要根据进程的大小选择合理的时间片

    3) 进程的切换机制体现出了时间片轮转算法的特点。若一个进程在时间片还没结束时就已完成,就将它从队列中移除。若一个进程在时间片结束时还没运行完成,等待下次运行。

    4) 本次实验的时间片轮转算法采用c语言对算法进行模拟,采用的时间片为3直到系统需要的时间片都小于0结束

    优先级调度算法

    1) 由于时间的轮转算法,无法对进程的紧急情况进行区分。因此又提出了优先级调度算法,从而解决进程优先级的问题。

    2) 进程优先级的确定同样重要,进程优先级可以分为静态优先级和动态优先部,静优先级是在通程创建里初期就被确定的值,此后不再更改。动态优先级指进程在创建时被赋子一个初值,此后其值会所进程的推进或等待时间的增加而改变。

    3) 本次实验的优先级调度算法采用C语言对算法进行模拟,优先级选择初始化随机数据1-5,当need满足的时候将进程优先级设置为-100。

    2. 程序流程图

    时间片轮转算法执行流程图:

    e04f0f4117f8329825b1c09b8044870f.png

    优先级调度算法执行流程图:

    3fa2fd833f55197c528fbed2aba6ea6b.png

    3. 程序代码及注释

    /**

    时间的轮转算法!!!

    */

    #include

    #include

    #include

    #include

    #define spand 3//设置时间片长度为3

    typedef struct pcd

    {

    int id;//进程ID

    int span;//运行进程的时间片数

    int used;//已用的时间片数

    int need;//进程需要运行的时间

    char status;//进程状态

    struct PCB *next;

    } PCB;

    PCB *head,p[5],t[5];

    //打印

    void print()

    {

    int i,temp;

    printf("---------------------------------");

    printf("ID spanusedneedstatus");

    for(i=0; i < 5; i++)

    {

    printf("%d%d%d%d%c",p[i].id,p[i].span,p[i].used,p[i].need,p[i].status);

    }

    }

    //初始化进程队列

    void inputprocess()

    {

    int i;

    srand(time(0));//为随机数产生种子;

    for(i = 0; i < 5; i++)

    {

    p[i].id = i + 1;

    p[i].span= 3;

    p[i].used=0;

    p[i].need=5+rand()%6;//为总的时间片产生5-10的整数

    p[i].status='J';

    }

    head = p;

    printf("开始进程的状态:");

    print();//打印进程状态

    }

    //时间的轮转算法

    void runprocess()

    {

    int i=0;

    while(p[0].need > 0 ||p[1].need > 0||p[2].need > 0||p[3].need > 0||p[4].need > 0)//当需求有一个未被满足时进程继续执行

    {

    p[i%5].used += 3;

    p[i%5].need -= 3;

    p[i%5].status = 'R';

    if(p[i%5].need <= 0)//如果进程已被满足调用下一个进程

    {

    p[i%5].status='F';

    i++;

    }

    else if(p[i%5].need <= 0 && p[(i%5)+1].need <= 0)//如果连续两个进程已被满足调用下一个进程

    {

    p[i%5].status='F';

    i++;

    }

    else if(p[i%5].need <= 0 && p[(i%5)+1].need <= 0 && p[(i%5)+2].need <= 0)//如果连续三个进程已被满足调用下一个进程

    {

    p[i%5].status='F';

    i++;

    }

    else if(p[i%5].need <= 0 && p[(i%5)+1].need <= 0 && p[(i%5)+2].need <= 0 && p[(i%5)+3].need <= 0)如果连续三个进程已被满足调用下一个进程

    {

    p[i%5].status='F';

    i++;

    }

    print();//打印进程状态

    if(p[i%5].status=='R')//如果本次进程执行完毕将程序由运行状态置为就绪状态

    {

    p[i%5].status = 'J';

    }

    i++;

    }

    }

    int main(void)

    {

    inputprocess();

    runprocess();

    return 0;

    }

    /**

    优先级调度算法

    */

    #include

    #include

    #include

    typedef struct pcd

    {

    int id;//进程ID

    int prior;//进程优先级

    int used;//已使用时间

    int need;//还需时间

    char status;//进程状态

    } PCB;

    PCB *head,p[5],a[5];

    //将每次进程调度的结果打印在屏幕上

    void print()

    {

    int i,temp;

    printf("---------------------------------");

    printf("ID priorusedneedstatus");

    for(i=0; i < 5; i++)

    {

    printf("%d%d%d%d%c",p[i].id,p[i].prior,p[i].used,p[i].need,p[i].status);

    }

    }

    //根据进程的优先级进行排序为下一次进程调度做准备

    void sort()

    {

    int i,j;

    //PCB temp;

    for(i=0; i < 5; i++)

    {

    for(j = 0; j <4-i;j++)

    {

    if(p[j].prior

    {

    PCB temp = p[j];

    p[j] = p[j+1];

    p[j+1] = temp;

    }

    }

    }

    }

    //初始化进程队列

    void inputprocess()

    {

    int i;

    for(i = 0; i < 5; i++)

    {

    p[i].id = i + 1;

    p[i].prior = rand()%5+1;//随机生成1-5的整数

    p[i].used = 0;

    p[i].need = 5+rand()%6;//为总的时间片产生5-10的整数

    p[i].status = 'W';

    }

    sort();//按优先级排序

    head = p;

    printf("开始进程的状态:");

    print();//打印进程状态

    }

    //按最高优先级调度进程队列

    void runprocess()

    {

    PCB *p1 = NULL;

    do{

    p1 = head;

    head = p+1;

    printf("***%d***%d***",p1->prior,head->prior);

    while((p1->need > 0)&&(p1->prior >= head->prior))//如果p1的需求数大于0并且 当前进程的优先级大于等于它下面一个进程的优先级

    {

    p1->need--;

    p1->prior--;

    p1->used++;

    p1->status='R';

    print();

    }

    if(p1->need == 0)//如果当前进程的需求为0时将优先级置为-100说明该进程运行完毕

    {

    p1->prior = -100;

    p1->status = 'F';

    }

    else//否则将该进程置为等待状态为下一次运行做准备

    {

    p1->status='W';

    }

    sort();

    head = p;

    }

    while(head->prior != -100);

    print();//显示最后各个进程的状态

    printf("--------------------------");

    printf("所有进程全部完成!!!");

    }

    int main()

    {

    inputprocess();//调用初始化进程自定义函数

    runprocess();//调用调度程序的函数

    return(1);

    }

    4 测试数据与实验结果(可以抓图粘贴)

    1. 时间的轮转算法测试数据及结果:

    a56f6c1db0f04806eeb886b196a8e88a.png
    6b0cf931eef29e8cf87a947aae9fa9ed.png
    876b2e718600c69df3580f56ac2ff682.png
    3d4d8802ce1b61a8e43789fa7188e7c5.png

    直到全部need小于等于0时所有进程运行完成

    2.优先级调度算法测试数据及结果:

    87d4f3b0beca6d598c4c1fabb872e3ed.png
    344f9787bef61fa5b01ec621d272655e.png

    5 结果分析与实验体会

    本次实验使用了时间片轮转算法与优先级调度算法并用C语言进行算法进程模拟。使我对C语言编写有了更加深刻的理解,同时对两个算法的原理也有了更加深刻的理解。使我以后对操作系统的调度算法能够运用的更加熟练。

    6.分析与思考

    1、逻辑时间片该如何实现?

    答:系统将所有的就绪进程按先来先服务算法的原则,排成- 一个队列,每次调度时,系队列首进程,并让其执行一一个时间片。当执行的时间片用完时,由一个计时器发出时钟中断请求,调度程序根据这个请求停止该进程的运行,将它送到就绪队列的末尾,再把处理机分给就绪队列中

    新的队首进程,同时让它也执行一一个时间片。

    2、如果不使用指针操作,是否也可以使用数组实现进程就绪队列的组织?

    答:可以

    展开全文
  • C语言,运行成功,比较基础,c语言模拟设计一个有N个进程运行的进程调度程序,用最高优先数优先法:在创建进程时,给定一个进程优先数,并按一定规则减少优先数,直至所有进程运行完成(例如进程每获得一次cpu进程数...
  • 操作系统实验2进程调度实验报告佛山科学技术学院实 验 报 告课程名称 操作系统原理实验项目 实验二-进程调度实验讲义专业班级 姓 名 学 号指导教师 成 绩 日 期一、实验目的通过对进程调度算法的模拟,进一步理解...
  • 本文件包含完整的大作业完整的资源,包含c++源代码,可运行,有调度视频,有实验报告
  • 计算机操作系统进程调度实验报告 操作系统实验题:操作系统实验题:设计一若干并发进程的进程调度程序设计一若干并发进程的进程调度程序一、一、实验目的实验目的无论是批处理系统、分时系统还是实时系统,用户进程...
  • 时间片轮转发加优先级进程调度算法如下: #include <stdio.h> struct PCB { int ID; int Alltime; int Cputime; int Priority; int starte; }; int maxpriorityxiabiao(PCB pcb[],int n) { int ...
  • 操作系统--进程调度实验报告

    千次阅读 多人点赞 2020-04-22 14:38:27
    编程实现进程调度算法的基本过程,设计要求: (1)能够选择进程调度算法(先来先服务、短进程优先算法和高响应比优先算法)。 (2)可以输入进程数目(至少3个进程),以及各进程的提交时间和运行时间。 (3)能够...
  • 使用动态优先权和时间片轮转的进程调度算法的模拟使用动态优先权和时间片轮转的进程调度算法的模拟使用动态优先权和时间片轮转的进程调度算法的模拟使用动态优先权和时间片轮转的进程调度算法的模拟使用动态优先权和...
  • 《计算机操作系统-实验一:进程调度实验报告书》由会员分享,可在线阅读,更多相关《计算机操作系统-实验一:进程调度实验报告书(6页珍藏版)》请在人人文库网上搜索。1、淮海工学院计算机工程学院实验报告书课程名:...
  • 3、掌握进程调度算法。2、实验要求1、编写程序,模拟实现以下功能:创建新的进程;查看运行进程;查看就绪进程;查看阻塞进程;阻塞某个进程;显示全部进程;唤醒进程;撤销进程。2、在以上程序的基础上,创建5-10个...
  • 操作系统实验之模拟进程调度,是本人自己用MFC做的,语言用的是C++。包括时间片轮转法 高响应比优先法和动态优先级法。大学实验课的成品,仅供大家参考和学习
  • 1.实现四种不同及进程调度算法: 先来先服务、时间片轮转调、优先级调度以及短作业优先调度算法。 2.通过实验理解有关进程控制块,进程队列等的概念。 1.运行素材中的代码,观察其执行结果是否正确?各个调度...
  • 1.理解操作系统进程管理中进行进程调度的过程和编程方法,创建进程控制块PCB。 2.理解进程的状态及变化,动态显示每个进程的当前状态及进程的调度情况。掌握几种调度算法。 3.理解几种进程调度的方式。 4.用代码...
  • 操作系统实验——进程调度 实验报告

    万次阅读 多人点赞 2018-06-29 11:20:14
    (一) 实验目的 进程是操作系统中最基本、最重要的概念,进程调度又是操作系统的核心模块。本实验要求学生独立地用C 或 C++语言编写一个简单的进程管理程序,其主要部分是进程调度。调度算法可由学生自行选择,如...
  • 淮海工学院计算机工程学院 实验报告书 课 程 名 操作系统原理 A 题 目 进程调度 班 级 Z 计 121 学 号 2014140093 姓 名 薛慧君 评语 成绩 指导教师 批 阅时间 年 月 日 操作系统原理实验进程调度实验报告 一目的与...
  • 1.进程控制块的数据结构定义如下...//进程动态优先级 ax:integer; next:pointer; times://进程要求服务时间 END; 2.通过过程creat创建进程进程控制块的相关数据手动输入(当输满10个或进程名为“0”时结束输入)
  • #include #include #include typedef struct node{char name[20];... /*进程优先级*/int round; /*分配CPU的时间片*/int cputime; /*CPU执行时间*/int needtime; /*进程执行所需要的时间*/char state; ...
  • 优先数和轮转法进程调度实验报告实验二 进程调度报告基本信息实验题目:进程调度完成人:****报告日期:###########实验内容简要描述1、实验目标:进程调度是处理机管理的核心内容。本实验要求用C语言编写和调试一个...
  • (1) 用C语言实现对N个进程采用某种进程调度算法(如先来先服务调度、时间片轮转调度、动态优先级调度)的调度。 (2) 为了清楚地观察每个进程的调度过程,程序应将每个进程的被调度情况显示出来。 (3) 分析程序...
  • 进程调度实验,python实现

    千次阅读 2019-11-14 22:02:31
    一、 设计一个有N个进程其行的进程调度算法。 进程调度算法:采用最高优先数的调度算法(即把处理机分配给优先数最高的进程)。 每个进程有一个进程控制块(PCB)表示。进程控制块可以包含如下信息:进程名、优先数...
  • 操作系统实验报告16 实验内容 实验内容:CPU 调度。 讨论课件 Lecture19-20 中 CPU 调度算法的例子,尝试基于 POSIX API 设计一个简单调度器(不考虑资源竞争问题): 创建一些 Pthread 线程任务,建立一个管理链...
  • 动态设置进程优先级,并设有延时函数 while(head!=NULL) { Output(&head); DeleteQueue(&head,&curr); curr.runtime--; curr.privilege++; if(curr.runtime!=0) { InsertQueue(&head,curr); } ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,946
精华内容 1,178
关键字:

优先级进程调度实验报告

友情链接: steganodotnet_20_src.zip