精华内容
下载资源
问答
  • 进程调度实验

    2012-12-20 15:32:46
    进程调度实验
  • 实验一 进程调度实验

    2019-01-10 12:10:08
    实验一 进程调度实验
  • 操作系统进程调度实验代码,创建20个子进程,分别使用各个进程调度模式,对比结果
  • 实现先来先服务、短进程优先、高响应比优先三个算法的进程调度实验
  • 操作系统 实验报告三 进程调度 进程调度实验 进程调度原理
  • 操作系统课程实习,进程调度实验,用高级语言编写和调试一个进程调度程序,以加深对进程的概念及进程调度算法的理解。
  • 进程调度实验报告

    2014-05-03 16:28:30
    计算机操作系统实验 进程调度实验 内有实验报告 源代码 实验结果
  • 操作系统进程调度实验代码
  • 实验一 进程调度实验 课程名称操作系统 实验日期xxxxxxx 仪器编号 班级 姓名 山水不言 学号 xxxxxxx 实验目的 用高级语言编写和调试一个进程调度程序以加深对进程的概念及进程调度算法的理解 实验要求 编写并调试一...
  • 计算机操作系统-实验一进程调度实验报告书 作者 日期 淮海工学院计算机工程学院 实验报告书 课程名操作系统原理A 题 目: 进程调度 班 级 计21 学 号: 0114009 姓 名 薛慧君 评语 评语 成绩 指导教师 批阅时间 年 月 ...
  • 进程调度实验报告.doc

    2011-09-22 13:11:36
    进程调度实验报告模板.本实验目的是通过对进程调度算法的实现和实验模拟,加深对操作系统进程调度操作功能和进程调度算法的完整理解,培养和提高学生对操作系统开发的兴趣,以及进程调度程序的开发与应用能力.
  • 用于计算机专业的操作系统实验中的进程调度实验的源代码,用Visual Basic6.0编写的
  • 实 验 报 告 书 课 程 名 操作系统原理 A 题 目 进程调度 班 级 Z 计 121 学 号 2014140093 姓 名 薛慧君 评语 成绩 指导教师 批阅时间 年 月 日 操作系统原理 A 实验报告 - 1 - 操作系统原理实验进程调度实验报告 ...
  • 广东工业大学操作系统进程调度实验报告,包含源代码
  • 广东技术师范学院实验报告学院:计算机科学学院专业:计算机科学与技术(师范)班级:成绩:姓名:学号:组别:组员:实验地点:实验日期:指导教师签名:实验名称:实验一、进程调度实验一、实验目的用高级语言编写和...

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

    学院:计算机科学学

    专业:

    计算机科学与

    技术(师范)

    班级:成绩:

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

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

    299e8ca3651aa6a014b42eaff1673ec6.png

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

    一、实验目的

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

    二、实验类别

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

    三、实验内容和步骤

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

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

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

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

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

    展开全文
  • 实验一 进程调度实验 专业XXXXX 学号XXXXX 姓名XXX 实验日期20XX 年 XX 月 XX 日 选择调度算法voidvoidvoidvoid输 选择调度算法 void void void void 输入进程信息 打印各进程信息 进行统计计算周转 时间等 看当前...
  • OS进程调度实验

    2017-05-08 21:17:38
    OS进程调度实验 模拟优先级时间片调度

    OS进程调度实验

    一、实验目的
    通过实验加强对进程调度算法的理解和掌握。
    二、实验内容
    编写程序实现基于优先级的时间片轮转调度算法。
    三、实验要求
    1、假定系统有5个进程,每个进程用一个进程控制块PCB来代表,进程控制块的结构如下图1.1所示:

    进程名
    优先级
    要求运行时间
    已运行时间
    进程状态
    指针
    
    其中:
    进程名:作为进程的标识,假设五个进程的进程名分别为p1,p2,p3,p4,p5。
    指针:进程按顺序排成循环链表,用指针指出下一个进程的进程控制块首地址,最后一个进程中的指针指出第一个进程的进程控制块首地址。
    要求运行时间:假设进程需要运行的单位时间数。
    已运行时间:假设进程已经运行的单位时间数,初值为0。
    状态:可假设有两种状态,就绪状态和结束状态。进程的初始状态都为就绪状态。
    

    2、每次运行所设计的处理器调度程序调度进程之前,为每个进程随机确定它的要求运行时间。
    3、此程序是模拟处理器调度,因此,被选中的进程并不实际启动运行,而是执行

    已运行时间+1
    来模拟进程的一次运行,表示进程已经运行过一个单位时间。
    

    4、在所设计的程序中应有显示语句,能显示每次被选中的进程名以及运行一次后进程队列的变化。

    • 再次犯错了!pre是指针变量,可以修改pre向的内容,但修改pre的指向是不会影响外部的!
      PCB*getHp(PCB *pre);
    • code:
    #include<iostream>
    #include<cstring>
    #include<cstdlib>
    using namespace std;
    struct PCB{
    	char name[20];
    	int priority;
    	int all_time;
    	int run_time;
    	int status;//1 ready 0 stop
    	PCB* next;
    	PCB(){
    		priority=0;
    		all_time=run_time;
    		status=1;
    	}
    };
    const int piece=10;
    PCB *pcb=NULL;
    PCB* getHp(PCB* pre);
    void  create(PCB*p)
    {
    	if(pcb==NULL)
    	{
    	  pcb=p;
    	  pcb->next=pcb;
    	}
    	PCB*pn=pcb;
    	while(pcb!=pn->next)pn=pn->next;
    	pn->next=p;
    	p->next=pcb;
    }
    void run()
    {
    	PCB*pre=pcb;
    	PCB*p=pcb->next;
    	while(pcb!=NULL)
    	{
    		pre=getHp(pre);
    		p=pre->next;
    		cout<<p->name<<" is running!"<<endl;
    		int i=0;
    		while(++i)
    		{
    		    p->run_time++;
    			if(p->run_time>=p->all_time)
    			{
    				cout<<p->name<<" over!"<<"all_time"<<  \
    					p->all_time<<" running time:"<<p->run_time<<endl;
    				p->status=0;
    				if(p->next==p)
    				{
    					delete p;
    					pcb=NULL;
    					break;
    				}else
    				{
    					PCB*pdone=p;
    					pre->next=p->next;
    					p=p->next;
    					delete pdone;
    					break;
    				}
    			}else if(i>piece)//
    			{
    				cout<<"piece time done!"<<endl;
    				pre=pre->next;
    				p=pre->next;
    				break;
    			}
    		}
    	}
    	cout<<"no process is running!"<<endl;
    }
    //ret:next param:pre-pre of next
    //pre->next==p
    //再次犯错了!pre是指针变量,可以修改pre向的内容,但修改pre的指向是不会影响外部的!
    PCB*getHp(PCB *pre)
    {
    	PCB*hp=pre;//记录优先级最高的pcb
    	PCB*pn=pre->next;//迭代
    	while(pre!=pn)
    	{
    		if(pn->next->priority>hp->next->priority)
    		  hp=pn;
    		pn=pn->next;
    	}
    	pre=hp;
    	return pre;
    }
    int main()
    {
    	cout<<"---------create process---------"<<endl;
    	char name[5]="pc0";
    	for(int i=0;i<5;i++)
    	{
    		PCB* p=new PCB();
    		p->priority=rand()%10;
    		name[2]='0'+i;
    		strcpy(p->name,name);
    		p->all_time=rand()%50;
    
    		cout<<p->name<<" priority:"<<p->priority<<"`all_time:"<<p->all_time<<endl;
    		create(p);
    	}
    	cout<<"------------run---------------"<<endl;
    	//时间片
    	run();
    
    	cout<<"------------exit---------------"<<endl;
    	return 0;
    }
    /*
    output:
    ---------create process---------
    pc0 priority:3`all_time:36
    pc1 priority:7`all_time:15
    pc2 priority:3`all_time:35
    pc3 priority:6`all_time:42
    pc4 priority:9`all_time:21
    ------------run---------------
    pc4 is running!
    piece time done!
    pc4 is running!
    pc4 over!all_time21 running time:21
    pc1 is running!
    piece time done!
    pc1 is running!
    pc1 over!all_time15 running time:15
    pc3 is running!
    piece time done!
    pc3 is running!
    piece time done!
    pc3 is running!
    piece time done!
    pc3 is running!
    pc3 over!all_time42 running time:42
    pc0 is running!
    piece time done!
    pc2 is running!
    piece time done!
    pc0 is running!
    piece time done!
    pc2 is running!
    piece time done!
    pc0 is running!
    piece time done!
    pc2 is running!
    piece time done!
    pc0 is running!
    pc0 over!all_time36 running time:36
    pc2 is running!
    pc2 over!all_time35 running time:35
    no process is running!
    ------------exit---------------;
     */
    
    展开全文
  • 实验一:进程调度实验

    千次阅读 2017-11-06 00:02:00
    实验一、进程调度实验 [目的要求]  用高级语言编写和调试一个进程调度程序,以加深对进程的概念及进程调度算法的理解. [准备知识] 一、基本概念 1、进程的概念; 2、进程的状态和进程控制块; 3、进程调度...

    实验一、进程调度实验

    [目的要求]

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

    [准备知识]

      一、基本概念

    1、进程的概念;

    2、进程的状态和进程控制块;

    3、进程调度算法;

      二、进程调度

          1、进程的状态

    2、进程的结构——PCB

    进程都是由一系列操作(动作)所组成,通过这些操作来完成其任务。因此,不同的进程,其内部操作也不相同。在操作系统中,描述一个进程除了需要程序和私有数据之外,最主要的是需要一个与动态过程相联系的数据结构,该数据结构用来描述进程的外部特性(名字、状态等)以及与其它进程的联系(通信关系)等信息,该数据结构称为进程控制块(PCB,Process Control Block)。

    进程控制块PCB与进程一一对应,PCB中记录了系统所需的全部信息、用于描述进程情况所需的全部信息和控制进程运行所需的全部信息。因此,系统可以通过进程的PCB来对进程进行管理。

    [实验内容]

        设计一个有 N个进程共行的进程调度程序。

      进程调度算法:采用最高优先数优先的调度算法(即把处理机分配给优先数最高的进程)和先来先服务算法。每个进程有一个进程控制块( PCB)表示。进程控制块可以包含如下信息:进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。 进程的优先数及需要的运行时间可以事先人为地指定(也可以由随机数产生)。进程的到达时间为进程输入的时间。进程的运行时间以时间片为单位进行计算。每个进程的状态可以是就绪 W(Wait)、运行R(Run)、或完成F(Finish)三种状态之一。就绪进程获得 CPU后都只能运行一个时间片。用已占用CPU时间加1来表示。如果运行一个时间片后,进程的已占用 CPU时间已达到所需要的运行时间,则撤消该进程,如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间,也就是进程还需要继续运行,此时应将进程的优先数减1(即降低一级),然后把它插入就绪队列等待CPU。每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的 PCB,以便进行检查。   

    重复以上过程,直到所要进程都完成为止。

    调度算法的流程图如下 : 

    jingchendiaodu.cpp


    #include "stdio.h"
    #include <stdlib.h>
    #include <conio.h>
    #define getpch(type) (type*)malloc(sizeof(type))
    #define NULL 0

    /* 定义进程控制块 PCB */ 

    struct pcb


      char name[10];
      char state;
      int super;
      int ntime;
      int rtime;
      struct pcb* link;
    }*ready=NULL,*p;
    typedef struct pcb PCB;


    sort() /* 建立对进程进行优先级排列函数*/
    {
      PCB *first, *second;
      int insert=0;
      if((ready==NULL)||((p->super)>(ready->super))) /*优先级最大者,插入队首*/
      {
        p->link=ready;
        ready=p;
      }
      else /* 进程比较优先级,插入适当的位置中*/
      {
        first=ready;
        second=first->link;
        while(second!=NULL)
        {
          if((p->super)>(second->super)) /*若插入进程比当前进程优先数大,*/
          { /*插入到当前进程前面*/
            p->link=second;
            first->link=p;
            second=NULL;
            insert=1;
          }
          else /* 插入进程优先数最低,则插入到队尾*/
          {
            first=first->link;
            second=second->link;
          }
         }
        if(insert==0)

           first->link=p;
      }
    }


    input() /* 建立进程控制块函数*/
    {
      int i,num;
      clrscr(); /*清屏*/
      printf("\n 请输入进程号?");
      scanf("%d",&num);
      for(i=0;i<num;i++)
      {
        printf("\n 进程号 No.%d:\n",i);
        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->link=NULL;
        sort(); /* 调用 sort 函数*/
      }
    }


    int space()
    {
      int l=0; PCB* pr=ready;
      while(pr!=NULL)
      {
        l++;
        pr=pr->link;
      }
      return(l);
    }


    disp(PCB * pr) /*建立进程显示函数,用于显示当前进程*/
    {
      printf("\n qname \t state \t super \t ndtime \t 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");
    }


    check() /* 建立进程查看函数 */
    {
      PCB* pr;
      printf("\n **** 当前正在运行的进程是:%s",p->name); /*显示当前运行进程*/
      disp(p);
      pr=ready;
      printf("\n ****当前就绪队列状态为:\n"); /*显示就绪队列状态*/
      while(pr!=NULL)
      {
        disp(pr);
        pr=pr->link;
      }
    }


    destroy() /*建立进程撤消函数(进程运行结束,撤消进程)*/
    {
      printf("\n 进程 [%s] 已完成.\n",p->name);
      free(p);
    }


    running() /* 建立进程就绪函数(进程运行时间到,置就绪状态*/
    {
      (p->rtime)++;
      if(p->rtime==p->ntime)
        destroy(); /* 调用 destroy 函数*/
      else
      {
        (p->super)--;
        p->state='w';
        sort(); /*调用 sort 函数*/
      }
    }


    main() /*主函数*/
    {
      int len,h=0;
      char ch;
      input();
      len=space();
      while((len!=0)&&(ready!=NULL))
      {
        ch=getchar();
        h++;
        printf("\n The execute number:%d \n",h);
        p=ready;
        ready=p->link;
        p->link=NULL;
        p->state='R';
        check();
        running();
        printf("\n 按任一键继续......");
        ch=getchar();
      }
      printf("\n\n 进程已经完成.\n");
      ch=getchar();

    }

     

    转载于:https://www.cnblogs.com/gd-luojialin/p/7790041.html

    展开全文
  • 实验一 进程调度实验 一、实验目的 通过对进程调度算法的模拟加深对进程概念和进程调度算法的理解。 二、实验要求 编写程序实现对5个进程的调度模拟,要求至少采用两种不同的调度算法分别进行模拟调度。 备注...
  • 淮海工学院计算机工程学院 实验报告书 课 程 名 操作系统原理 A 题 目 进程调度 班 级 Z 计 121 学 号 2014140093 姓 名 薛慧君 评语 成绩 指导教师 批 阅时间 年 月 日 操作系统原理实验进程调度实验报告 一目的与...
  • 计算机操作系统进程调度实验报告 操作系统实验题:操作系统实验题:设计一若干并发进程的进程调度程序设计一若干并发进程的进程调度程序一、一、实验目的实验目的无论是批处理系统、分时系统还是实时系统,用户进程...

    7d63a1dd2a806506125e94c1e8715445.gif计算机操作系统进程调度实验报告

    操作系统实验题:操作系统实验题:设计一若干并发进程的进程调度程序设计一若干并发进程的进程调度程序一、一、实验目的实验目的无论是批处理系统、分时系统还是实时系统,用户进程数一般都大于处理机数,这将导致用户进程互相争夺处理机。这就要求进程调度程序按一定的策略,动态地把处理及分配给处于就绪队列中的某一进程,以使之执行。进程调度是处理机管理的核心内容。本实验要求采用最高优先数优先的调度算法(即把处理机分配给优先数最高的进程)和先来先服务算法编写和调试一个简单的进程调度程序。通过本实验可以加深理解有关进程控制块、进程队列的概念。并体会了优先数和先来先服务调度算法的具体实施办法。二、二、实验要求实验要求用高级语言编写和调试一个进程调度程序,以加深对进程的概念及进程调度算法的理解三、实验内容实验内容进程调度算法:采用最高优先数优先的调度算法(即把处理机分配给优先数最高的进程)和先来先服务算法(将用户作业和就绪进程按提交顺序或变为就绪状态的先后排成队列,并按照先来先服务的方式进行调度处理)。每个进程有一个进程控制块()表示。进程控制块可以包含如下信息:进程名、优先数、到达时间、需要运行时间、已用时间、进程状态等等。进程的优先数及需要的运行时间可以事先人为地指定(也可以由随机数产生)。进程的到达时间为进程输入的时间。进程的运行时间以时间片为单位进行计算。每个进程的状态可以是就绪()、运行()、或完成()三种状态之一。就绪进程获得后都只能运行一个时间片。用已占用时间加来表示。如果运行一个时间片后,进程的已占用时间已达到所需要的运行时间,则撤消该进程,如果运行一个时间片后进程的已占用时间还未达所需要的运行时间,也就是进程还需要继续运行,此时应将进程的优先数减(即降低一级),然后把它插入就绪队列等待。每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的,以便进行检查。重复以上过程,直到所要进程都完成为止。四、四、实验算法流程实验算法流程调度算法的流程图如下:第页共页=()建立对进程进行优先级排列函数=((==)||(()()))优先级最大者插入队首==进程比较优先级插入适当的位置中==(!=)(()())若插入进程比当前进程优先数大插入到当前进程前面====插入进程优先数最低则插入到队尾==(==)=()建立进程控制块函数()清屏(“请输入被调度的进程数目:“)(“%“(=)(“进程号%:“)

    展开全文
  • 实验进程调度 实验学时:3 学时 实验类型:设计 实验要求:必修 一、 实验目的 多道程序设计中,经常是若干个进程同时处于就绪状态,必须依照某种策略来 决定那个进程优先占有处理机。因而引起进程调度。本实验...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 30,016
精华内容 12,006
关键字:

进程调度实验