smilesword.com

1．实验目的
在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。当就绪进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占用处理器。本实验模拟在单处理器情况下的处理器调度，帮助学生加深了解处理器调度的工作。
2．实验内容与要求
（1）设计多个进程并发执行的模拟调度程序，每个程序由一个PCB表示。
（2）模拟调度程序可任选两种调度算法之一实现。
（3）程序执行中应能在屏幕上显示出各进程的状态变化，以便于观察调度的整个过程。
3．实验说明
本实验有两个题，学生可选择其中的一题做实验。
第一题：设计一个按优先数调度算法实现处理器调度的程序。
(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)为五个进程任意确定一组“优先数”和“要求运行时间”，启动所设计的处理器调度程序，显示或打印逐次被选中进程的进程名以及进程控制块的动态变化过程。


恩~~下面是代码~实现是C语言，大部分是链表实现，涉及到了链队，链表，排序等内容~~思路是先按照优先级排序，然后每运行一次后再重新排序~

#include <stdlib.h>

typedef struct s_pcb
{
	char name;
	struct s_pcb* next;
	int time;
	int level;
	int status;
}
node;
typedef struct 
{
	node *front,*rear;
}
queue;
queue* qu;
queue *init()
{
	qu = (queue*)malloc(sizeof(queue));
	qu->front = NULL;
	qu->rear = NULL;
	return qu;
}
void pushInQue(node* p)
{
	if (qu->front == NULL)
	{
		qu->front = p;
		qu->rear = p;
	}
	else
	{
		orderPushInQue(p);	
	}
}
void orderPushInQue(node* p)
{
	node *a,*b;
	a = qu->front;
	if (a->level < p->level)
	{
		qu->front = p;
		p->next = a;
	}
	else
	{
		do
		{
			if (a->level < p->level)
			{
				b->next = p;
				p->next = a;
				break;	
			}
			else if (qu->rear == a || (p->level < a->level && p->level >= (a->next)->level))
			{
				b = a->next;
				a->next = p;
				p->next = b;
				if (qu->rear == a)
				{
					qu->rear = p;
				}
				break;
			}
			b = a;
			a = a->next;
		}
		while (1);
	}
}
void runProgress()
{
	node *p,*q;
	p = qu->front;
	q = p;
	displayQue();
	while(p)
	{
		p->time = p->time - 1;
		p->level = p->level - 1;
		if (p->time == 0)
		{
			qu->front = p->next;
			printf("%c out\n",p->name);
			free(p);
			displayQue();
		}
		else
		{
			qu->front = p->next;
			pushInQue(p);
			displayQue();
		}
		p = qu->front;
	}
	displayQue();
}
void displayQue()
{
	node* p;
	p=qu->front;
	printf("Progress in queue:\n");
	while(p)
	{
		printf("name:%c ",p->name);
		printf("level:%d\n",p->level);
		p=p->next;
	}
}
int main(void)
{
	char i;
	init();
	while (1)
	{

		printf("Please input the name of the Progress(input 0 to exit):");
		scanf("%c",&i);
		if (i == '0')
		{
			break;
		}
		else
		{
			node *p;
			p = (node*)malloc(sizeof(node));
			p->next=NULL;
			p->name = i;
			printf("please input the time of the progress need:");
			scanf("%d",&p->time);
			printf("please input the Level of the progress:");
			scanf("%d",&p->level);
			getchar();
			pushInQue(p);
		}
		
	}
	runProgress();
	return 0;	
}

3.16在一个单处理器的多道程序设计系统中，现有两道进程同时执行，其中一以计算为主，另一道以输出为主，将怎样赋予进程占有处理器的优先级数？为什么？
答应该让输入输出为主的作业具有较高的优先级。当这种作业先占用处理器执行时,因常常要启动外围设备,一旦启动外围设备,它就会让出处理器,另一道作业就可占用处理器,使处理器和外围设备都处于忙状态。
3.17 假定就绪状态的进程按其优先数自小到大顺序排成队列,当有一进程要进入就绪队列时,应按照它的优先数排在相应的位置上,试写出进程入队程序。
单向链接方式：
var head , p,q, addpcb:1ink
begin
if head =nil (//如果进程链表头是空的)
        then begin
        head:=addpcb;(//以所加入的进程作为链表的头)
        head ⬆. next = nil; (//它的下一个显然是没有的)
end；
e1se begin ( //否则)
        p:-head ;(//取得链表的头)
whilep <> nil and addpcbt. pri <=pt. pri (//循环语句)
        do begin
                q:-p;(//取得前一个节点)
                p:=p⬆ next;
ends (//此时 为符合条件的最后一个进程)
q⬆.next:=addpcb; ( //新进程加到a的后面)
addpcbt.next:-p (//把不符合要求的第一进程接到新进程的后面)
end；
end；
解：这就是一个单向链表的插入操作，用类C语言描述如下：
 procedure Insert(Queue ReadyQue,Pointer P)
    {//ReadyQue 是就绪队列指针，P是要插入队列进程指针
     //P中的priority指示其进程的优先数
     //P中的Next指示其后继进程指针
     Pointer P1=ReadyQue, P2=ReadyQue;
            //P1指示比P优先数小的第一个进程指针
            //P2指示比P优先数大的第一个进程指针
     while(P->priority<P1->priority  && P1->Next)
       {  //查找要插入位置的前后结点
           P2=P1;         
           P1=P1->Next;
        }
     //查到后将P插入到就绪队列中
     P->Next=P1;
     P2->Next=P;
  }//End Procedure
借鉴答案，暂时看不懂。
3.18考虑表内的若干进程
1)分别给出采用最短剩余时间算法、非抢占式算法（优先级越小，表示优先级越高）和时间片算法（30ms）轮转算法的调度过程及进程执行顺序。
2）计算出上述每种调度策略的等待平均时间。
3.19列出第二节3-4中包含7个状态。原则上，若任意两个状态间进行切换，则可能有42种不同的转换。
1）列出这些转换，并举例说明那些事件会触发这些状态转换。
2）列出所有不可能的转换，并说明原因。
暂时省略。
3.20 有5个进程P1，P2，P3，P4，P5，它们以此进入就绪队列，它们的优先数和所需的处理器的时间如下表
忽略进行调度的时间，回答
1)分别给出采用先来先服务算法、非抢占式算法（优先级越小，表示优先级越高）进程执行顺序。
2）计算出上述每种调度策略的等待平均时间。

实验内容与要求
（1）设计多个进程并发执行的模拟调度程序，每个程序由一个PCB表示。
（2）模拟调度程序可任选两种调度算法之一实现。
（3）程序执行中应能在屏幕上显示出各进程的状态变化，以便于观察调度的整个过程。
  (4) 假定系统有五个进程，每一个进程用一个进程控制块PCB来代表，进程控制块的格式为：
            进程名  要求运行时间  优先数  状态
其中，进程名——作为进程的标识，假设五个进程的进程名分别为P1，P2，P3，P4，P5。
指针——按优先数的大小把五个进程连成队列，用指针指出下一个进程的进程控制块的首地址，最后一个进程中的指针为“0”。
要求运行时间——假设进程需要运行的单位时间数。
优先数——赋予进程的优先数，调度时总是选取优先数大的进程先执行。
状态——可假设有两种状态，“就绪”状态和“结束”状态。五个进程的初始状态都为“就绪”，用“R”表示，当一个进程运行结束后，它的状态为“结束”，用“E”表示。
<html> 
 <head> 
  <meta http-equiv="Content-Type" content="text/html;charset=utf-8"> 
  <title>操作系统01</title> 
<mce:style type="text/css"><!--
.letft {
	font-size: 12px;
	background-color: #CCC;
	margin: 10px;
	height: auto;
	width: 100px;
	border: 1px inset #999;
	float: left;
}
--></mce:style><style type="text/css" mce_bogus="1">.letft {
	font-size: 12px;
	background-color: #CCC;
	margin: 10px;
	height: auto;
	width: 100px;
	border: 1px inset #999;
	float: left;
}</style> 
<mce:script language="javascript" type="text/javascript"><!--
 
var PCB=new Array(['p1','k1',2,1,'R'],['p2','k2',3,5,'R'],['p3','k3',1,3,'R'],['p4','k4',2,4,'R'],['p5','k5',4,2,'R']);//五个进程，每一个进程用一个进程控制块PCB[i]来代表
function main()//主函数
{ //alert('h');
  var priority=priorityFC();  
   priority.sort(descOrder);
   //alert(priority.toString());
   for(var i=0;i<=PCB.length-1;i++)
   {
	 if(PCB[i][2]==0){ PCB.splice(i,1); }//tuchu
     if(priority[0]==PCB[i][3])
	 { //alert(priority[0]);
	   PCB[i][2]=PCB[i][2]-1;//要求运行时间-1
	   PCB[i][3]=PCB[i][3]-1;//优先数-1
	   if(PCB[i][2]==0){ PCB[i][4]='E'}
	document.getElementById('db').innerHTML+=(PCB[i][0]+'&nbsp;&nbsp;&nbsp;'+PCB[i][2]+'&nbsp;&nbsp;&nbsp;'+PCB[i][3]+'&nbsp;&nbsp;&nbsp;'+PCB[i][4]+'<br>'); break}
	priority.sort(descOrder);//对优先级排序
	//alert(priority.toString());
  }
 
setTimeout("main()",500);
}
function descOrder(x,y)//排序函数
    {
     if (x>y)
     {
      return -1;
     }
     else
     {
      return 1;
     }
    }	
function priorityFC()//重新列队
{ 
 var TakeOut=[];
 for(var i=0;i<=PCB.length-1;i++)
  { 
   //alert(PCB.length);
 //alert(PCB[i][3]);
    TakeOut.push(PCB[i][3]) 
	  }
	 // alert(TakeOut.length);
	  return TakeOut;
}	
  
// --></mce:script> 
 </head> 
 <body onLoad="main()"> 
  <div id="db" class="letft"  onClick="main()"></div> 
 </body> 
</html> 
 
运行结果：

 CPUSET是linux内核中的轻量级对象，它能使用户区分多个处理器，在每个处理器上单独运行进程，通过创建cpu集的方式。这是通过文件系统的方式实现的(旧内核是通过syscall方式)。

1) mkdir /dev/cpuset

2) 
mount -t cpuset none /dev/cpuset

3) mkdir /dev/cpuset/my_cpu0

4) echo 0 > /dev/cpuset/my_cpu0/cpus

   echo 0 > /dev/cpuset/my_cpu0/mems

   echo PID1 > /dev/cpuset/my_cpu0/tasks
   
   echo PID2 > /dev/cpuset/my_cpu0/tasks
   ......