处理机调度和进程调度

  在多道程序系统中，进程的数量往往多于处理机的个数，这样不可能同时并行地处理各个进程。处理机的调度就是 从就绪队列中按照一定的算法选择一个进程并将处理机分配给它运行 ，以实现进程的并发执行。

  调度的方式： 高级调度、中级调度、低级调度。

  由于内存空间有限，有时无法将用户提交的作业全部放入内存中，因此需要确定某种规则来决定作业调入内存的顺序。

   高级调度（作业调度） ：按照一定的原则从外存上处于后备队列的作业中挑选一个或多个作业，给他们分配内存等必要资源，并建立相应的进程（ 建立PCB ），以使它（们） 获得竞争处理机的权利。

   高级调度是外存与内存之间的调度。 每个作业只调入一次，调出一次。作业调入时会建立相应的PCB，作业调出时才撤销PCB。高级调度主要是指调入的问题，因为只有调入的时机需要 *** 作系统来确定，但调出的时机必然是作业运行结束才调出。

  在引入虚拟存储技术之后，可以将暂时不能运行的进程调至外存等待，等它重新具备了运行条件且内存又稍有空间时，再重新调入内存。

  这样做是为了提高内存利用率和系统吞吐量。

  暂时调到外存等待的进程状态为 挂起状态 ，但是进程的PCB不会一起调到外存，而是会 常驻内存 。PCB中会记录进程数据在外存中的存放位置，进程状态等信息， *** 作系统通过内存的PCB来保持对各个进程的监控、管理。被挂起的进程PCB会被放到挂起队列中。

   中级调度（内存调度） ，就是按照某种规则，从挂起队列中选择合适的进程将其数据重新调回内存。

  一个进程可能会被多次调出、调入内存。因此中级调度发生的频率比高级调度更高

   低级调度（进程调度） ：其主要任务是按照某种方法和策略从就绪队列中选取一个进程，将处理机分配给它。

  进程调度是 *** 作系统中最基本的一种调度，在一般的 *** 作系统中都必须配置进程调度。

  进程调度的频率很高，一般几十毫秒一次。这样才能保证多进程在宏观是同时进行的。

  需要进行进程调度与切换的情况：

  不能进行进程调度与切换的情况：

   非剥夺调度方式，又称非抢占式。 即只允许进程主动放弃处理机，在运行过程中即使有更紧急的任务到达，当前进程依然会继续使用处理机，直到该进程终止或要求进入阻塞态。

  实现简单，系统开销小但是无法及时处理紧急任务，适合早期批处理 *** 作系统。

   剥夺调度方式，又称抢占式。 当一个进程正在处理机上执行时，如果有一个更重要更紧急进程要使用处理机，即立即暂停正在执行的进程，将处理机分配给更重要更紧急的那个进程。

  可以优先处理更紧急的进程。也可以实现各进程按时间片轮流执行的功能（通过时钟中断）。适合分时 *** 作系统、实时 *** 作系统。

  由此可见， 进程的切换是有代价的 ，因此如果进程切换调度过于频繁的话，必然会使整个系统的开销过大，效率降低。因为系统大部分时间都花在进程切换上，真正用于执行进程的时间少。

  评价指标： CPU利用率、系统吞吐量、周转时间、等待时间、响应时间。

  CPU利用率：指CPU忙碌的时间占总时间的比例。

   CPU利用率 = 忙碌时间 / 总时间。

  如某计算机只支持单道程序，某个作业刚开始需要在CPU上运行5s，再用打印机打印输出5s，之后再执行5s，在此过程中：

  CPU利用率=(5 + 5) / 15 = 6667%

  打印机利用率=5 / 15 = 3333%

  系统吞吐量：单位时间内完成作业的数量。

   系统吞吐量=总共完成了多少道作业/总共花了多少时间

  周转时间：指从作业被提交给 *** 作系统开始，到作业完成为止的这段时间间隔。

  包括四个部分：作业在外存设备队列上等待作业调度（高级调度）的时间、进程在就绪队列上等待进程调度（低级调度）的时间、进程在CPU上执行的时间、进程等待I/O *** 作完成的时间。

   作业周转时间= 作业完成时间 – 作业提交时间

   平均周转时间 = 各作业周转时间之和 / 作业数

   带权周转时间 = 作业周转时间 / 作业实际运行时间

   平均带权周转时间 = 各作业带权周转时间之和 / 作业数

   等待时间：指进程或作业处于等待处理机状态时间之和。

   平均等待时间：各个进程/作业等待时间的平均值。

  对进程来说，等待时间就是指进程建立后等待被服务的时间之和。

  对于作业来说，不仅要考虑建立进程后等待的时间（进程建立时作业已经进入了内存），还要加上作业在外部存后备队列中等待的时间。

  响应时间：指从用户提交请求到首次产生相应所用的时间。

   本文完

  如发现错误，请指正！！！

在C++环境下建立空进程，输入

#include "stdioh"

#include <stdlibh>

#include <conioh>

#define getpch(type) (type)malloc(sizeof(type))

#define NULL 0

struct pcb { / 定义进程控制块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->link=ready;

ready=p;

}

else / 进程比较优先级,插入适当的位置中/

{

first=ready;

second=first->link;

while(second!=NULL)

{

first=first->link;

second=second->link;/插尾/

}

if(insert==0) first->link=p;

}

}

input() / 建立进程控制块函数/

{'

int i,num;

system("cls"); /清屏/

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->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->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();

}

一个进程在运行期间，不断地从一种状态转换到另一种状态，它可以多次处于就绪状态和执行状态，也可以多次处于阻塞状态。

　(1) 就绪－>执行

就绪状态是指进程获得了调度程序为之分配的除了CPU时间之外的其他必要资源，只要CPU时间一到位就可执行了。

处于就绪状态的进程，当进程调度程序为之分配了处理机后，该进程便由就绪状态转变成执行状态。

　(2) 执行－>就绪

处于执行状态的进程在其执行过程中，因分配给它的一个时间片已用完而不得不让出处理机，于是进程从执行状态转变成就绪状态。

　(3) 执行－>阻塞

正在执行的进程因等待某种事件发生而无法继续执行时，便从执行状态变成阻塞状态。

　(4) 阻塞－>就绪

处于阻塞状态的进程，若其等待的事件已经发生，于是进程由阻塞状态转变为就绪状态。

实现方法进程与指定cpu绑定

：SetProcessAffinityMask(GetCurrentProcess(),dwMask);

线程与指定cpu绑定：

SetThreadAffinityMask(GetCurrentThread(),dwMask);dwMask为CPU序号的或运算值：1（0001）

代表只运行在CPU1，2（0010）代表只运行在CPU2，3（0011）代表可以运行在CPU1和CPU2

，以此类推。

设置之前最好判断一下系统有几个CPU：

SYSTEM_INFOSystemInfo;

GetSystemInfo(&SystemInfo);CPU个数：SystemInfodwNumberOfProcessors

当前启用的CPU序号：

SystemInfodwActiveProcessorMask

，Mask representing the set of processors configured into the system Bit 0 is processor 0;

bit 31 is processor 31

CPU亲缘性介绍

按照默认设置，当系统将线程分配给处理器时，Windows使用软亲缘性来进行 *** 作。这意味着如果所有其他因素相同的话，它将设法在它上次运行的那个处理器上运行线程。让线程留在单个处理器上，有助于重复使用仍然在处理器的内存高速缓存中的数据。

有一种新的计算机结构，称为NUMA（非统一内存访问），在该结构中，计算机包含若干块插件板，每个插 件板上有4个CPU和它自己的内存区。

当CPU访问的内存是它自己的插件板上的内存时，NUMA系统运行的性能最好。如果CPU需要访问位于另一个插件板上的内 存时，就会产生巨大的性能降低。在这样的环境中，就需要限制来自一个进程中的线程在共享同一个插件版的CPU上运行。

为了适应这种计算机结构的需要，Windows允许你设置进程和线程的亲缘性。换句话说，你可以控制哪个CPU能够运行某些线程。这称为硬亲缘性。请注意，子进程可以继承进程的亲缘性。

注意：（1）无论计算机中实际拥有多少个CPU，Windows98及以前系统只使用一个CPU，上述API不被支持。

（2）在大多数环境中，改变线程的亲缘性就会影响调度程序有效地在 各个CPU之间移植线程的能力，而这种能力可以最有效地使用CPU时间。

应用场景举例：

将UI线程限制在一个CPU，将其他实时性要求较高的线程限制在另一个CPU。这样，当UI需要占用大量CPU时间时，就不会拖累其他实时性要求较高的线程的执行

。同样可以将UI线程与一些优先级不高但耗时的异步运算线程设置在不同CPU上，避免UI给人卡顿的感觉。

以上就是关于处理机调度和进程调度全部的内容，包括:处理机调度和进程调度、 *** 作系统实验 使用C++完成处理器调度、进程三个基本调度状态的转换过程是CPU怎么处理的等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！