计算机分布操作系统知识要点.docx
《计算机分布操作系统知识要点.docx》由会员分享，可在线阅读，更多相关《计算机分布操作系统知识要点.docx（12页珍藏版）》请在冰豆网上搜索。
计算机分布操作系统知识要点
阻塞原语：
阻塞性报文通信原语也称为同步（Synchronous）原语。
阻塞原语不立即将控制权返回给调用该原语的进程，也就是说send一直被阻塞直到发送的信息被接收方收到并得到接收方的应答。
同样地，receive一直被阻塞，直到要接受的信息到达并被接收
非阻塞原语将要发送的报文送入缓冲区后就立即将控制权归还给发送进程，发送进程开始执行下一条语句。
当该报文发送完毕时，系统向发送者进程发送一个中断信号，通知它可以继续发送。
RPC采用客户机/服务器模式。
请求程序就是一个客户机，而服务提供程序就是一个服务器。
首先，客户机调用进程发送一个有进程参数的调用信息到服务进程，然后等待应答信息。
在服务器端，进程保持睡眠状态直到调用信息的到达为止。
当一个调用信息到达，服务器获得进程参数，计算结果，发送答复信息，然后等待下一个调用信息，最后，客户端调用进程接收答复信息，获得进程结果，然后调用执行继续进行。
RPC执行的主要步骤
1.客户过程以普通方式调用相应的客户存根。
2.客户存根建立消息并激活内核陷阱。
3.内核将消息发送到远程内核。
4.远程内核将消息送到服务器存根。
5.服务器存根取出消息中的参数后调用服务器的过程。
6.服务器完成工作后将结果返回至服务器存根。
7.服务器存根将它打包并激活内核陷阱。
8.远程内核将消息发送至客户内核。
9.客户内核将消息交给客户存根。
10.客户存根从消息中取出结果返回给客户。
客户存根的功能是获取调用的参数并将参数打包放入消息中送往服务器存根。
将参数打包形成消息的过程称为参数组装（parametermarshalling）。
考虑远程调用函数sum（i,j）,该函数有两个整型参数并返回其代数和。
1.对下图所示的由三个进程组成的分布计算系统，为所有的事件提供逻辑时间，假设每个Lci初始化为0，并且d=1。
分别使用：
（1）标量时间
（2）向量时间
答案：
标量时间：
A0
（1）、A1
（2）、A2（3）、A3（4）
B0
（1）、B1
（2）、B2（3）、B3（4）
C0
（1）、C1
（2）、C2（3）、C3（4）
向量时间：
A0（1,0,0）、A1（2,0,0）、A2（3,0,0）、A3（4,0,0）
B0（0,1,0）、B1（1,2,0）、B2（1,3,1）、B3（1,4,1）
C0（0,0,1）、C1（0,0,2）、C2（2,0,3）、C3（3,0,4）
标量逻辑时钟
每个进程Pi有一个逻辑时钟LCi，LCi被初始化为init（init≥0）并且它是一个非减的整数序列。
进程Pi发送的每个报文m都被标上LCi的当前值和进程的标号i，从而形成一个三元组（m,LCi,i）。
任何一个逻辑时钟LCi基于以下两条规则更新它的逻辑时钟值：
当发生一个事件（一个外部发送或内部事件）之前，更新LCi：
LCi:
=LCi+d（d>0）
当收到一个带时间戳的报文（m,LCj,j）时，更新LCi：
LCi:
=max（LCi,LCj）+d（d>0）
向量逻辑时钟
在向量逻辑时钟中，每个进程Pi和一个时间向量LCi[1,…,n]相关联，其中
向量元素LCi[i]描述了进程Pi的逻辑时间进展情况，即自身的逻辑时间进展情况；
向量元素LCi[j]表示进程Pi所知的关于进程Pj的逻辑时间进展情况；
向量LCi[1,…,n]组成进程Pi对于逻辑全局时间的局部视图。
任何一个逻辑时钟LCi基于以下两条规则更新它的逻辑时钟值：
当发生一个事件（一个外部发送或内部事件）之前，Pi更新LCi[i]：
LCi[i]:
=LCi[i]+d（d>0）
每个报文捎带发送方在发送时的时钟向量，当收到一个带时间戳的报文（m,LCj,j）时，Pi更新LCi：
LCi[k]:
=max（LCi[k],LCj[k]）1≤k≤nLCi[i]:
=LCi[i]+d（d>0）
标量逻辑时钟：
A0
（1）、A1
（2）、A2（3）、A3（4）
B0
（2）、B1（4）、B2（6）、B3（8）
C0（3）、C1（6）、C2（9）、C3（12）
3、假设一个由6个进程P1、P2、P3、P4、P5、P6组成的系统，若使用Maekawa互斥算法，请设计每个进程的请求集，要求每个请求集中不超过3个进程。
R1={P1,P3,P4}
R2={P2,P4,P5}
R3={P3,P5,P6}
R4={P4,P1,P6}
R5={P5,P1,P2}
R6={P6,P2,P3}
请求子集：
在Maekawa互斥算法中，一个进程P在发出申请报文后，不用得到所有其他进程的回答，而只须得到一个进程子集S中的所有进程的回答即可进入临界区。
称S是P的请求子集。
假设Ri和Rj分别是进程Pi和Pj的请求子集，要求Ri∩Rj≠NULL。
当进程Pi请求进入临界区时，它只向Ri中的进程发送请求报文。
当进程Pj收到一个请求报文时，如果它自上一次临界区释放后还没有发出过回答报文给任何进程，且自己的请求队列中无任何请求，它就给该请求报文一个回答。
否则，请求报文被放入请求队列中。
进程Pi只有收到Ri中的所有进程的回答后，才能进入临界区。
在释放临界区时，进程Pi只给Ri中的所有进程发送释放报文。
Maekawa指出，算法中的申请集合必须满足下面4个条件：
对任意的i和j：
Ri∩Rj≠NULL（i≠j,1≤i,j≤n）
对任意的i：
Pi∈Ri（1≤i≤n）
对任意的i：
|Ri|=K（1≤i≤n）
任一个Pi必须属于K个Rj（1≤i,j≤n）
其中K是一个整型常数，如果系统中有n个进程，则K=根号K+1
根据条件1，在任意两个申请集合之间必然至少存在一个共同的进程；
根据条件3，每个申请互斥的进程都具有相同的工作量（即发出相同数量的申请报文）
根据条件4，任一个进程都要有相同的责任来保证互斥。
考虑一个7个进程的例子，每个进程的请求子集如下：
R1:
{P1,P3,P4}；R2:
{P2,P4,P5}；R3:
{P3,P5,P6}；R4:
{P4,P6,P7}；R5:
{P5,P7,P1}；R6:
{P6,P1,P2}；R7:
{P7,P2,P3}；
在以上请求子集中，任何两个请求子集恰好有一个公共的进程。
每个进程只能发出一个回答报文从而使互斥得以保证。
如果请求子集的大小为K并且每个请求子集大小都一样，进程数为n，则n的最小值为k（k-1）+1。
显然，对每次临界区的访问，发出的请求报文的个数是k=O（根号K）
图a不存在死锁
图b存在死锁
在使用AND条件的系统中，死锁条件是在等待图中存在回路。
但是在使用OR条件的系统中，等待图中的回路未必会引发死锁。
在使用OR条件的系统中，死锁条件是存在结（knot）。
一个结K是一个节点集合，对于K中的任何节点a，a能到达K中的所有节点，并且只能到达K中的节点。
图a、b均存在死锁，a、b中均存在结。
资源分配图到等待图的转化
（1）在资源分配图中找到一个未被处理的资源R。
如果所有的资源都已经处理，转向步骤3。
（2）从这个资源R的每个输入进程节点到每个输出进程节点之间加一条有向边。
一个资源的输入进程节点是等待这个资源的进程节点，一个资源的输出进程节点是占有这个资源的进程节点。
转向步骤1。
（3）删除所有的资源节点以及相应的边。
图a不处于死锁状态，而图b处于死锁状态。
因为在图a中，进程P1可以释放资源类型R1中的一个资源，然后这个资源被分配给进程P3，从而打破回路。
分别使用等待-死亡方案和伤害-等待方案给出5个进程的资源分配时间
（1）等待—死亡方案（wait-diescheme）。
该方案是基于非剥夺方法。
当进程Pi请求的资源正被进程Pj占有时，只有当Pi的时间戳比进程Pj的时间戳小时，即Pi比Pj老时，Pi才能等待。
否则Pi被卷回（roll-back），即死亡。
（2）伤害—等待方案（wound-waitscheme）。
它是一种基于剥夺的方法。
当进程Pi请求的资源正被进程Pj占有时，只有当进程Pi的时间戳比进程Pj的时间戳大时，即Pi比Pj年轻时，Pi才能等待。
否则Pj被卷回（roll-back），即死亡。
图a中P1得到了资源R1和R2，P2请求资源R2。
P2将被阻塞。
一旦P1完成，将释放资源R1和R2，第一个在R1上阻塞的进程，如P2将被激活。
图b中P2得到了资源R1和R2，P1请求资源R1。
P2将被杀死。
当P2以原有的时间戳重新运行时，它将有一个比任何新创建的进程都小的时间戳，具有最高的优先级。
图c中P1得到了资源R1，P2得到了资源R2。
P1请求资源R2，P2请求资源R1。
P1在请求被P2占有的资源R2时，P2将被杀死。
P2释放所占有的资源R2，P1将不被阻塞，得到所需的所有资源。
9、x的初始时间戳是Timer（x）=3和Timew（x）=2。
对数据对象x有下列读/写操作。
Write（x,2）,read（x,1）,read（x,4）,Write（x,3）,Write（x,5）,read（x,6）
给出对每个读和写请求的基于时间戳的并发控制的结果及每次请求后的Timer（x）和Timew（x）。
读或写操作的处理方式：
（1）读请求read（T,x,ts）。
如果ts＜tsWR（x）,说明有一个对x的写操作发生在事务处理T启动之后，则读请求被拒绝，事务处理T被取消。
反之，让T执行该读操作，并把max{tsRD（x）,ts}赋给tsRD（x）。
（2）写请求write（T,x,ts）。
如果ts＜tsWR（x），或者ts＜tsRD（x），说明有一个对x的写操作或者有一个对x的读操作发生在事务处理T启动之后，则写请求被拒绝，事务处理T被取消。
反之，让T执行该写操作，并把ts赋给tsWR（x）。
初始：
Timer（x）=3Timew（x）=2
Write（x,2）：
拒绝。
Timer（x）=3Timew（x）=2
read（x,1）：
拒绝。
Timer（x）=3Timew（x）=2
read（x,4）：
接受。
Timer（x）=4Timew（x）=2
Write（x,3）：
拒绝。
Timer（x）=4Timew（x）=2
Write（x,5）：
接受。
Timer（x）=4Timew（x）=5
read（x,6）：
接受。
Timer（x）=6Timew（x）=5
升级会员 