Chapter 7 process synchronization
This presentation is the property of its rightful owner.
Sponsored Links
1 / 81

Chapter 7: Process Synchronization PowerPoint PPT Presentation


  • 173 Views
  • Uploaded on
  • Presentation posted in: General

Chapter 7: Process Synchronization. Background The Critical-Section Problem Synchronization Hardware Semaphores Classical Problems of Synchronization Critical Regions Monitors Synchronization in Solaris 2 & Windows 2000. Background.

Download Presentation

Chapter 7: Process Synchronization

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


Chapter 7 process synchronization

Chapter 7: Process Synchronization

  • Background

  • The Critical-Section Problem

  • Synchronization Hardware

  • Semaphores

  • Classical Problems of Synchronization

  • Critical Regions

  • Monitors

  • Synchronization in Solaris 2 & Windows 2000

Operating System Concepts


Background

Background

  • Concurrent access to shared data may result in data inconsistency.

  • Maintaining data consistency requires mechanisms to ensure the orderly execution of cooperating processes.

  • Shared-memory solution to bounded-butter problem (Chapter 4) allows at most n – 1 items in buffer at the same time. A solution, where all N buffers are used is not simple.

    • Suppose that we modify the producer-consumer code by adding a variable counter, initialized to 0 and incremented each time a new item is added to the buffer

Operating System Concepts


Bounded buffer

Bounded-Buffer

  • Shared data

    #define BUFFER_SIZE 10

    typedef struct {

    . . .

    } item;

    item buffer[BUFFER_SIZE];

    int in = 0;

    int out = 0;

    int counter = 0;

Operating System Concepts


Bounded buffer1

Bounded-Buffer

  • Producer process

    item nextProduced;

    while (1) {

    while (counter == BUFFER_SIZE)

    ; /* do nothing */

    buffer[in] = nextProduced;

    in = (in + 1) % BUFFER_SIZE;

    counter++;

    }

Operating System Concepts


Bounded buffer2

Bounded-Buffer

  • Consumer process

    item nextConsumed;

    while (1) {

    while (counter == 0)

    ; /* do nothing */

    nextConsumed = buffer[out];

    out = (out + 1) % BUFFER_SIZE;

    counter--;

    }

Operating System Concepts


Bounded buffer3

Bounded Buffer

  • The statementscounter++;counter--;must be performed atomically.(原子地)

  • Atomic operation means an operation that completes in its entirety without interruption. (原子操作)

Operating System Concepts


Bounded buffer4

Bounded Buffer

  • The statement “count++” may be implemented in machine language as:register1 = counter

    register1 = register1 + 1counter = register1

  • The statement “count—” may be implemented as:register2 = counterregister2 = register2 – 1counter = register2

Operating System Concepts


Bounded buffer5

Bounded Buffer

  • If both the producer and consumer attempt to update the buffer concurrently, the assembly language statements may get interleaved.

  • Interleaving depends upon how the producer and consumer processes are scheduled.

Operating System Concepts


Bounded buffer6

Bounded Buffer

  • Assume counter is initially 5. One interleaving of statements is:producer: register1 = counter (register1 = 5)producer: register1 = register1 + 1 (register1 = 6)consumer: register2 = counter (register2 = 5)consumer: register2 = register2 – 1 (register2 = 4)producer: counter = register1 (counter = 6)consumer: counter = register2 (counter = 4)

  • The value of count may be either 4 or 6, where the correct result should be 5.

Operating System Concepts


Another example

Another example

two processes p0,p1, share a variable:int total(initialized as 0 ) ;

Both of them execute the following program concurrently:

p0,p1:

{

int count;

for (count=1; count <=50; count++)

total = total + 1 ;

}

Question: what is the probable result of “total”?(upper limit and lower limit)

Operating System Concepts


Race condition

Race Condition

  • Race condition: The situation where several processes access – and manipulate shared data concurrently. The final value of the shared data depends upon how these processes interleave.

  • To prevent race conditions, concurrent processes must be synchronized.

Operating System Concepts


The critical section problem

The Critical-Section Problem

  • n processes all competing to use some shared data

  • The shared data can be accessed only by one process at a time(we call this kind of data as “critical resource”)

  • Each process has a code segment, called critical section, in which the shared data is accessed.

  • Problem – ensure that when one process is executing in its critical section, no other process is allowed to execute in its critical section.

Operating System Concepts


Solution to critical section problem

Solution to Critical-Section Problem

Three requirements must be satisfied: (三个必须)

1.Mutual Exclusion. If process Pi is executing in its critical section, then no other processes can be executing in their critical sections.(每次最多只有一个进程在CS)

2.Progress. If no process is executing in its critical section and there exist some processes that wish to enter their critical section, then the selection of the processes that will enter the critical section next cannot be postponed indefinitely.(没有进程在CS,若有多个进程申请进入CS,应在有限时间内让其中之一进入,而不应互相阻塞,以至于各进程都无法进入)

3.Bounded Waiting. A bound must exist on the number of times that other processes are allowed to enter their critical sections after a process has been admitted to enter its critical section. No starvation(进程允许进入CS后,将在有限时间内离开CS并允许其他进程进入)

Two assumptions(二个前提)

  • Assume that each process executes at a nonzero speed

  • No assumption concerning relative speed of the n processes.

Operating System Concepts


Methods to solve the cs problem

Methods to solve the CS Problem

1.Software solution. To solve the CS problem by the user processes themselves. No need of operating system support or special programming language.

2.Hardware support. To rely on special hardware support ( e.g. interrupt disabling, special machine instructions)

3.Operating System support. OS provides services(usually system calls) to solve the CS problem.

Operating System Concepts


Software solution initial attempts to solve problem

Software solution: Initial Attempts to Solve Problem

  • Only 2 processes, P0 and P1

  • General structure of process Pi(other process Pj)

    do {

    entry section

    critical section

    exit section

    remainder section

    } while (1);

  • Processes may share some common variables to synchronize their actions.

  • Entry section: code requesting for entering CS

  • Exit section: code releasing resources

Operating System Concepts


Algorithm 1

Algorithm 1

  • Shared variables:

    • int turn;initially turn = 0

    • turn = i Pi can enter its critical section

  • Process Pi

    do {

    while (turn != i) ;

    critical section

    turn = j;

    reminder section

    } while (1);

  • Satisfies mutual exclusion, but not progress(必须交替进入)

Operating System Concepts


Algorithm 2

Algorithm 2

  • Shared variables

    • boolean flag[2];initially flag [0] = flag [1] = false.

    • flag [i] = true Pi ready to enter its critical section

  • Process Pi

    do {

    flag[i] := true;while (flag[j]) ;critical section

    flag [i] = false;

    remainder section

    } while (1);

  • Satisfies mutual exclusion, but not progress requirement.(互相谦让)

Operating System Concepts


Algorithm 3 peterson

Algorithm 3(Peterson)

  • Combined shared variables of algorithms 1 and 2.

  • Process Pi

    do {

    flag [ i ]:= true;turn = j;while (flag [ j ] and turn = j) ;

    critical section

    flag [ i ] = false;

    remainder section

    } while (1);

  • Meets all three requirements; solves the critical-section problem for two processes.

Operating System Concepts


Proof of algorithm 3

Proof of Algorithm 3

  • Mutual exclusion

    1. Pi and Pj can enter CS almost simultaneously only if turn=i and turn=j (impossible)

    2. If Pi entered CS in advance, Pj must be loop in while

  • Progress

    1. If only Pi wants to enter CS, Pj does not want to enter CS, then flag[ j ] = false. Pi will enter CS immediately.

    2. If Pi and Pj all want to enter CS, they cannot both be blocked in loop(turn = i or turn = j)

  • Bounded-waiting

    If Pj exits CS, it will reset flag[ j ]=false. If Pj has time to set flag[ j ]=true, it must also set turn = j, allowing Pi to enter CS.

Operating System Concepts


Bakery s algorithm

Bakery’s Algorithm

  • Before entering its critical section, process receives a number. Holder of the smallest number enters the critical section.

  • If processes Pi and Pj receive the same number, if i < j, then Pi is served first; else Pj is served first.

  • The numbering scheme always generates numbers in increasing order of enumeration; i.e., 1,2,3,3,3,3,4,5...

Critical section for n processes

Operating System Concepts


Bakery s algorithm cont

Bakery’s Algorithm (cont.)

  • Notation : lexicographical order (ticket #, process id #)

    • (a,b) < (c,d) if a < c or if a = c and b < d

    • max (a0,…, an-1) is a minimum number, k, such that k ai for i = 0, …, n – 1

  • Shared data

    boolean choosing[n];

    int number[n];

    Data structures are initialized to false and 0 respectively

Operating System Concepts


Bakery s algorithm cont1

Bakery’s Algorithm (cont.)

do {

choosing[i] = true;

number[i] = max(number[0], number[1], …, number [n – 1])+1;

choosing[i] = false;

for (j = 0; j < n; j++) {

while (choosing[j]) ;

while (number[j] != 0 && (number[j],j) < (number[i],i)) ;

}

critical section

number[i] = 0;

remainder section

} while (1);

Operating System Concepts


Synchronization hardware

Synchronization Hardware

  • Disabling interrupt: sometimes impossible(e.g. clock interrupt, SMP)

  • Test-and-set instruction: Test and modify the content of a word atomically.

    boolean TestAndSet(boolean &target) {

    boolean rv = target; // test first

    tqrget = true; // set next

    return rv;

    }

Operating System Concepts


Mutual exclusion with test and set

Mutual Exclusion with Test-and-Set

  • Shared data: boolean lock = false;

  • Process Pi

    do {

    while (TestAndSet(lock)) ;

    critical section

    lock = false;

    remainder section

    }

Operating System Concepts


Synchronization hardware1

Synchronization Hardware

  • Swap instruction: Atomically swap two variables.

    void Swap(boolean &a, boolean &b) {

    boolean temp = a;

    a = b;

    b = temp;

    }

Operating System Concepts


Mutual exclusion with swap no bounded waiting

Mutual Exclusion with Swap-- No bounded-waiting

  • Shared data (initialized to false): boolean lock;

  • Process Pi

    do {

    key = true;

    while (key == true) //获得lock值为false的进程能进入

    Swap(lock,key);

    critical section

    lock = false;

    remainder section

    }

Operating System Concepts


Hardware solution features

Hardware solution features

  • No limit on processes and CPUs

  • Simple and easy to verify

  • Busy-waiting is required

  • May cause starvation(do not satisfy bounded-waiting): selection of ready process to run is arbitrarily

Operating System Concepts


Mutual exclusion with testandset bounded waiting

Mutual Exclusion with TestAndSet-- Bounded-waiting

  • Shared data (initialized to false): boolean lock;

    boolean waiting[n];

  • Process Pi

    do {

    waiting[ i ] = true;

    key = true;

    while (waiting[ i ] && key)

    key = TestAndSet(lock);

    waiting[ i ] = false;

    critical section

    j = ( i + 1) % n;

    while(( j != i) && !waiting[ j ])

    j = ( j + 1 ) %n;

    if ( j == i )

    lock = false;

    else

    waiting[ j ] = false;

    remainder section

    }

Operating System Concepts


Operating system support semaphores

Operating system support: Semaphores

  • Synchronization tool that does not require busy waiting.

  • Semaphore S – integer variable

  • can only be accessed via two indivisible (atomic) operations

    wait (S): //(也叫P操作)

    while S 0 do no-op;S--;

    signal (S): //(也叫V操作)

    S++;

Operating System Concepts


Critical section of n processes

Critical Section of n Processes

  • Shared data:

    semaphore mutex; //initially mutex = 1

  • Process Pi: do { wait(mutex);critical section

    signal(mutex); remainder section} while (1);

Operating System Concepts


Semaphore implementation

Semaphore Implementation

  • Define a semaphore as a record

    typedef struct {

    int value; struct process *queue;} semaphore;

  • Assume two simple operations:

    • block suspends the process that invokes it.

    • wakeup(P) resumes the execution of a blocked process P.

Operating System Concepts


Implementation

Implementation

  • Semaphore operations now defined as

    wait(S):S.value- -;

    if (S.value < 0) {

    add this process to S.queue;block;

    }

    signal(S): S.value++;

    if (S.value <= 0) {

    remove a process P from S.queue;wakeup(P);

    }

Operating System Concepts


Semaphore as a general synchronization tool

Semaphore as a General Synchronization Tool

  • Execute B in Pj only after A executed in Pi

  • Use semaphore flag initialized to 0

  • Code:

    PiPj

     

    Await(flag)

    signal(flag)B

Operating System Concepts


Deadlock and starvation

Deadlock and Starvation

  • Deadlock – two or more processes are waiting indefinitely for an event that can be caused by only one of the waiting processes.

  • Let S and Q be two semaphores initialized to 1

    P0P1

    wait(S);wait(Q);

    wait(Q);wait(S);

     

    signal(S);signal(Q);

    signal(Q)signal(S);

  • Starvation – indefinite blocking. A process may never be removed from the semaphore queue in which it is suspended.

Operating System Concepts


Two types of semaphores

Two Types of Semaphores

  • Counting semaphore – integer value can range over an unrestricted domain.

  • Binary semaphore – integer value can range only between 0 and 1; can be simpler to implement.

  • Can implement a counting semaphore S using binary semaphores.

Operating System Concepts


Binary semaphores mutex

Binary semaphores(Mutex)

waitB(S):

if (S.value = 1) {

S.value := 0;

} else {

block this process

place this process in S.queue

}

signalB(S):

if (S.queue is empty) {

S.value := 1;

} else {

remove a process P from S.queue

place this process P on ready list

}

Operating System Concepts


Implementing s using binary semaphores

Implementing S using Binary Semaphores

  • Data structures:

    binary-semaphore S1, S2;

    int C:

  • Initialization:

    S1 = 1

    S2 = 0

    C = initial value of semaphore S

Operating System Concepts


Implementing s

Implementing S

  • wait operation

    wait(S1);

    C--;

    if (C < 0) {

    signal(S1);

    wait(S2);

    }

    signal(S1);

  • signal operation

    wait(S1);

    C ++;

    if (C <= 0)

    signal(S2);

    else

    signal(S1);

Operating System Concepts


Classical problems of synchronization

Classical Problems of Synchronization

  • A semaphore represents a shared data, its initialized value is the number of processes that can access the shared data simultaneously(一个信号量代表一个共享资源,其初值表示可以同时访问该共享资源的进程数)

  • Bounded-Buffer Problem

  • Readers and Writers Problem

  • Dining-Philosophers Problem

Operating System Concepts


Bounded buffer problem

Bounded-Buffer Problem

  • Shared datasemaphore full, empty, mutex;Initially:full = 0, empty = n, mutex = 1

Operating System Concepts


Bounded buffer problem producer process

Bounded-Buffer Problem Producer Process

do {

produce an item in nextp

wait(empty);

wait(mutex);

add nextp to buffer

signal(mutex);

signal(full);

} while (1);

do {

wait(full)

wait(mutex);

remove an item from buffer to nextc

signal(mutex);

signal(empty);

consume the item in nextc

} while (1);

Operating System Concepts


Bounded buffer problem consumer process

Bounded-Buffer Problem Consumer Process

do {

wait(full)

wait(mutex);

remove an item from buffer to nextc

signal(mutex);

signal(empty);

consume the item in nextc

} while (1);

Operating System Concepts


Readers writers problem

Readers-Writers Problem

  • Problem description: 读者只能读取共享数据,写者可以读写共享数据。写者只有一人,读者可以有多人。读者和写者不能共存

  • Shared datasemaphore mutex //互斥访问readcount

    semaphore wrt; //读者和写者不能共存Initiallymutex = 1, wrt = 1, readcount = 0 //读者人数

Operating System Concepts


Readers writers problem writer process

Readers-Writers Problem Writer Process

wait(wrt); //申请进入

writing is performed

signal(wrt); //离开

Operating System Concepts


Reader process

Reader Process

writer: wait(wrt); //申请进入

writing is performed

signal(wrt); //离开

reader:wait(mutex); //申请访问readcount

readcount++;

if (readcount == 1) //如果是第一个读者,禁止写者进入

wait(wrt);

signal(mutex); //释放访问readcount的锁

reading is performed

wait(mutex); //申请访问readcount

readcount--;

if (readcount == 0) //如果没有读者了,应该允许写者进入

signal(wrt);

signal(mutex): //释放访问readcount的锁

Operating System Concepts


Dining philosophers problem

Dining-Philosophers Problem

  • Shared data

    semaphore chopstick[5]:=1, count := 4

Operating System Concepts


Dining philosophers problem1

Dining-Philosophers Problem

  • Philosopher i:

    do {

    wait(count);

    wait(chopstick[i]) //want to pick up left chopstick

    wait(chopstick[(i+1) % 5]) //the right one

    eat

    signal(chopstick[i]); //release left

    signal(chopstick[(i+1) % 5]);//release right

    signal(count);

    think

    } while (1);

Operating System Concepts


Chapter 7 process synchronization

例题

有n个进程(P1,P2,…,Pn)向容量为M的缓冲区写数据,每个进程一次写1个数据,当缓冲区写满时,另一个读进程Pr一次将M个数据全部读完,如此反复。请用信号量解决这些进程的同步互斥问题。

答:本题中需要定义下述变量和信号量:

data_type buffer[M]; /* data_type对应于所需要的数据类型,如int、float等 */

int in=0; /* 用来指示下一个可存放数据的缓冲区 */

semaphore empty=M; /* 对应空闲的缓冲区 */

semaphore full=0; /* 对应缓冲区中的数据 */

semaphore mutex=1; /* 用来实现Pi进程对变量in的互斥访问 */

进程Pi可描述为:

Pi(){

while(1){

P(empty); P(mutex); 向缓冲区buffer[in]中写数据;

in=(in+1)%M; V(mutex); V(full); } }

进程Pr可描述为:

Pr(){

int i;

while(1){

for(i=0;i<M;i++) P(full);

取出缓冲buffer[0]到buffer[M-1]中的数据;

for(i=0;i<M;i++) V(empty); } }

Operating System Concepts


Chapter 7 process synchronization

思考题

  • 有一个仓库存放两种零件A和B,最大库容量各为m个。有一车间不断地取A和B进行装配,每次各取一个。有两种供应商分别不断地供应A和B。为保证齐套和合理库存,当某种零件的数量比另一种的数量超过n(n<m)个时,暂停对数量大的零件进货,集中补充数量少的零件。试用信号量正确地实现之。

Operating System Concepts


Unix semaphores

Unix Semaphores

  • Are a generalization of the counting semaphores (more operations are permitted).

  • A semaphore includes:

    • the current value S of the semaphore(non-negative integer)

    • number of processes waiting for S to increase

    • number of processes waiting for S to be 0

  • We have queues of processes that are blocked on a semaphore

  • The system call semget creates an array of semaphores

  • The system call semop performs a list of operations: one on each semaphore (atomically)

Operating System Concepts


Unix semaphores1

Unix Semaphores

  • Each operation to be done is specified by a value sem_op.

  • Let S be the semaphore value

    • if sem_op > 0:

      • S is incremented and process awaiting for S to increase are awaken

    • if sem_op = 0:

      • If S=0: do nothing

      • if S!=0, block the current process on the event that S=0

Operating System Concepts


Unix semaphores2

Unix Semaphores

  • if sem_op < 0 and |sem_op| <= S:

    • set S:= S + sem_op (ie: S decreases)

    • then if S=0: awake processes waiting for S=0

  • if sem_op < 0 and |sem_op| > S:

    • current process is blocked on the event that S increases

  • Hence: flexibility in usage (many operations are permitted)

  • Operating System Concepts


    Critical regions

    Critical Regions(临界域)

    • High-level synchronization construct

    • A shared variable v of type T, is declared as:

      v:sharedT

    • Variable v accessed only inside statement

      regionvwhenBdoSwhere B is a boolean expression.

    • While statement S is being executed, no other process can access variable v.

    Operating System Concepts


    Critical regions1

    Critical Regions

    • Regions referring to the same shared variable exclude each other in time.

    • When a process tries to execute the region statement, the Boolean expression B is evaluated. If B is true, statement S is executed. If it is false, the process is delayed until B becomes true and no other process is in the region associated with v.

    Operating System Concepts


    Example bounded buffer

    Example – Bounded Buffer

    • Shared data:

      struct buffer {

      int pool[n];

      int count, in, out;

      }

    Operating System Concepts


    Bounded buffer producer process

    Bounded Buffer Producer Process

    • Producer process inserts nextp into the shared buffer

      region buffer when( count < n) {pool[in] = nextp;in:= (in+1) % n;count++;}

    Operating System Concepts


    Bounded buffer consumer process

    Bounded Buffer Consumer Process

    • Consumer process removes an item from the shared buffer and puts it in nextc

      region buffer when (count > 0) {nextc = pool[out];out = (out+1) % n;count--;}

    Operating System Concepts


    Implementation region x when b do s

    Implementation region x when B do S

    • Associate with the shared variable x, the following variables:

      semaphore mutex, first-delay, second-delay; int first-count, second-count;

    • Mutually exclusive access to the critical section is provided by mutex.

    • If a process cannot enter the critical section because the Boolean expression B is false, it initially waits on the first-delay semaphore; moved to the second-delay semaphore before it is allowed to reevaluate B.

    Operating System Concepts


    Implementation1

    Implementation

    • Keep track of the number of processes waiting on first-delay and second-delay, with first-count and second-count respectively.

    • The algorithm assumes a FIFO ordering in the queuing of processes for a semaphore.

    • For an arbitrary queuing discipline, a more complicated implementation is required.

    Operating System Concepts


    Monitors

    Monitors(管程)

    • High-level synchronization construct that allows the safe sharing of an abstract data type among concurrent processes.monitor monitor-name

      {

      shared variable declarations

      procedure bodyP1(…) {

      . . .

      }

      procedurebodyP2 (…) {

      . . .

      }

      procedure bodyPn(…) {

      . . .

      }

      {

      initialization code

      }

      }

    Operating System Concepts


    Monitors1

    Monitors

    • Only one process at a time can be active within the monitor

    • To allow a process to wait within the monitor, a condition variable must be declared, as

      condition x, y;

    • Condition variable can only be used with the operations wait and signal.

      • The operation

        x.wait();means that the process invoking this operation is suspended until another process invokes

        x.signal();

      • The x.signal operation resumes exactly one suspended process. If no process is suspended, then the signal operation has no effect.

    Operating System Concepts


    Monitor

    Monitor

    • Awaiting processes are either in the entrance queue or in a condition queue

    • A process puts itself into condition queue cn by issuing cwait(cn)

    • csignal(cn) brings into the monitor 1 process in condition cn queue

    • Hence csignal(cn) blocks the calling process and puts it in the urgent queue (unless csignal is the last operation of the monitor procedure)

    • cwait(cn) equals to cn.wait()

    • csignal(cn)equals to cn.signal()

    Operating System Concepts


    Schematic view of a monitor

    Schematic View of a Monitor

    Operating System Concepts


    Monitor with condition variables

    Monitor With Condition Variables

    Operating System Concepts


    Dining philosophers example

    Dining Philosophers Example

    monitor dp

    {

    enum {thinking, hungry, eating} state[5];

    condition self[5];

    void pickup(int i)

    void putdown(int i)

    void test(int i)

    void init() {

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

    state[i] = thinking;

    }

    }

    Operating System Concepts


    Chapter 7 process synchronization

    • Philosopher i:

    • dp.pickup(i);

    • eat

    • dp.putdown(i);

    • No deadlock

    • May cause starvation

    void pickup(int i) {

    state[i] = hungry;

    test[i];

    if (state[i] != eating)

    self[i].wait();

    }

    void putdown(int i) {

    state[i] = thinking;

    // test left and right neighbors

    test((i+4) % 5);

    test((i+1) % 5);

    }

    void test(int i) {

    if ( (state[(i + 4) % 5] != eating) &&

    (state[i] == hungry) &&

    (state[(i + 1) % 5] != eating)) {

    state[i] = eating;

    self[i].signal();

    }

    }

    Operating System Concepts


    Monitor implementation using semaphores

    Monitor Implementation Using Semaphores

    • Variables

      semaphore mutex; // (initially = 1)

      semaphore next; // (initially = 0)

      int next-count = 0; //让位的进程数

    • Each external procedure F will be replaced by

      wait(mutex); //进入monitor

      body of F;

      if (next-count > 0) //离开前看有没有让位进程,如有,激活它们中的一个,不让其他进程进入,否则,释放mutex,让其他一个进程进入

      signal(next)

      else

      signal(mutex);

    • Mutual exclusion within a monitor is ensured.

    Operating System Concepts


    Monitor implementation

    Monitor Implementation

    • For each condition variable x, we have:

      semaphore x-sem; // (initially = 0)

      int x-count = 0; //等待条件x的进程数

    • The operation x.wait can be implemented as:

      x-count++;

      if (next-count > 0) //在进入等待队列前,看有没有让位进程,如有,激活其中的一个,不让其他进程进入,否则,释放mutex,让其他一个进程进入

      signal(next);

      else

      signal(mutex);

      wait(x-sem);

      x-count--;

    Operating System Concepts


    Monitor implementation1

    Monitor Implementation

    • The operation x.signal can be implemented as:

      if (x-count > 0) {

      next-count++; //自己变为让位进程

      signal(x-sem); //释放等待队列中的一个进程

      wait(next); //自己进入让位进程队列

      next-count--; //从让位进程队列出来,继续执行

      } //如果没有等待该条件的进程,什么也不做

    Operating System Concepts


    Monitor implementation2

    Monitor Implementation

    • Conditional-wait construct: x.wait(c);

      • c – integer expression evaluated when the wait operation is executed.

      • value of c (a priority number) stored with the name of the process that is suspended.

      • when x.signal is executed, process with smallest associated priority number is resumed next.

    • Check two conditions to establish correctness of system:

      • User processes must always make their calls on the monitor in a correct sequence.

      • Must ensure that an uncooperative process does not ignore the mutual-exclusion gateway provided by the monitor, and try to access the shared resource directly, without using the access protocols.

    Operating System Concepts


    Solaris 2 synchronization

    Solaris 2 Synchronization

    • Implements a variety of locks to support multitasking, multithreading (including real-time threads), and multiprocessing.

    • Uses adaptive mutexes for efficiency when protecting data from short code segments.

    • Uses condition variables and readers-writers locks when longer sections of code need access to data.

    • Uses turnstiles(十字转门)to order the list of threads waiting to acquire either an adaptive mutex or reader-writer lock.

    Operating System Concepts


    Windows 2000 synchronization

    Windows 2000 Synchronization

    • Uses interrupt masks to protect access to global resources on uniprocessor systems.

    • Uses spinlocks(旋转锁)on multiprocessor systems.

    • Also provides dispatcher objects which may act as mutexes and semaphores.

    • Dispatcher objects may also provide events. An event acts much like a condition variable.

    Operating System Concepts


    Spin lock

    Spin lock

    • Spin lock(旋转锁)on multiprocessor systems.× 利用busy waiting 而非blocking来阻止进程前进;

      × CPU不会去做其他事情,虽然浪费了部分CPU时间,但省去了进程切换;

      × 适合短代码的加锁

    • wait(S):

    • S--;

    • while S<0 do{};

    • signal(S):

    • S++;

    • 与spin lock相对应的就是suspend lock(挂起锁),即一般的锁,会挂起(阻塞)进程的执行

    Operating System Concepts


    Exercises

    Exercises

    • 7.3if Pi in CS, and Pk has chosen number[k]

      then (number[I],I) < (number[k],k)

      (1) Pk选择number时,Pi已经在CS,则number[k]>number[I]

      (2) Pk选择number时,Pi未进入CS

      A)Pi正在执行for循环,则number[I]<number[k]

      B)Pi未执行for循环,则(number[k],k)>(number[I],I),否则Pi无法进入

    Operating System Concepts


    Exercises1

    Exercises

    1.互斥(mutual exclusion)

    A) Pi和Pj不可能同时进入CS:

    turn==j 和turn==I不会同时满足

    B)一个进程(如Pi)先进入CS,则flag[ i ]为true,则Pj无法进入

    2.前进(progress)

    A)Pi申请进入,Pj不想进入,则flag[ i ]==false,Pi顺利进入

    B)Pi和Pj都想进入,则turn==j时Pj进入,turn==i时Pi进入

    3.有限等待(bounded waiting)

    Pi离开CS后,置turn=j,flag[ i ]=false,这时Pj可以进入,如果Pj没有进入,Pi又执行了falg[ i ]=true,则由于turn==j,所以Pi无法进入,而Pj可以进入

    • 7.4Dekker算法

      while(1) {

      flag[ i ] = true;

      while (flag[j]) {

      if (turn==j) {

      flag[ i ] = false;

      while ( turn == j );

      flag[ i ] = true;

      }

      }

      CS

      turn = j;

      flag[ i ] = false;

      RS

      }

    Operating System Concepts


    Exercises2

    Exercises

    1.互斥(mutual exclusion)

    A) 两个进程Px和Py不可能同时进入CS:

    turn==x 和turn==y不会同时满足,故Px和Py的两个if 条件不会都满足

    B)一个进程(如Px)先进入CS,则turn==x,flag[turn]==in_cs,则其他进程无法进入

    2.前进(progress)

    A)Px申请进入,其他进程不想进入,则其他进程flag均为idle,则Px的j>=n成立,if条件成立,跳出while,进入CS

    B)若干进程想进入,如Pturn也想进入,则Pturn优先进入;否则,编号在turn后的最小号的想进入的进程进入CS

    3.有限等待(bounded waiting)

    Pi离开CS时,置turn为想进入的进程中大于turn的最小欲进入之进程号,该进程就进入。

    进程Pk不会饿死,最多等待(k-turn)个进程的CS执行

    • 7.5Eisenberg and McGuire’s algorithm

      While(1) {

      while(1) {

      flag[i] = want_in;

      j = turn;

      while (j !=i) {

      if (flag[j]!=idle) j = turn

      else j = (j+1)%n;

      }

      flag[i] =in_cs; j = 0;

      while ((j<n)&&(j ==i || flag[j]!=in_cs)

      j ++ ;

      if ((j>=n)&&(turn==i||flag[turn]==idle))

      break;

      }

      turn = i ; CS

      j = (turn+1)%n;

      while(flag[j]==idle) j=(j+1)%n;

      turn=j; flag[i]=idle; RS

      }

    Operating System Concepts


    Exercises3

    Exercises

    7.9抽烟问题

    Semaphore smoker[3]; //初始0,三个抽烟者

    Semaphore material[3]; //初始0,三种原料

    Semaphore agent; //初始1,供应商

    Int turn; //初始0,轮到谁

    Agent:

    While(1){

    wait(agent);

    signal(smoker[turn]);

    signal(material[(turn+1)%3]);

    signal(material[(turn+2)%3]);

    turn= (turn+1)%3;

    }

    Smoker-i:

    While(1){

    wait(smoker[i]);

    wait(material[(i+1)%3]);

    wait(material[(i+2)%3]);

    signal(agent);

    }

    Operating System Concepts


    Exercises4

    Exercises

    • 7.11

      Monitor bounded_buffer

      {

      item pool[n];

      int count, in, out;

      condition full, empty;

      void get_item()

      {

      if (count==0) full.wait();

      get_from_buffer();

      count--;

      empty.signal();

      }

      void put_item()

      {

      if (count==n) empty.wait();

      put_to_buffer();

      count++;

      full.signal();

      }

      void init() { count=in=out=0;}

      }

    Producer process:

    While(1) {

    produce an item;

    bounded_buffer.put_item();

    }

    Consumer process:

    While (1) {

    bounded_buffer.get_item();

    consume the item;

    }

    Operating System Concepts


    Exercises5

    Exercises

    7.8 理发问题

    Semaphore max; //初始n+1,表示理发店可以容纳总人数

    Semaphore chair; //初始n,空闲的椅子

    Semaphore barber; //初始1,表示理发椅空闲

    Semaphore finished; //初始0,表示一次理发结束

    Semaphore ready; //初始0,表示客人准备就绪

    Customer:

    While(1){

    wait(max); wait(chair);

    wait(barber); signal(chair); signal(ready);

    … barbered …

    wait(finished); signal(max);

    }

    Barber:

    While(1){

    wait(ready);

    … barbering…

    signal(finished);

    signal(barber);

    }

    Operating System Concepts


    Chapter 7 process synchronization

    Lab

    实验1(a):进程间通讯

    要求:

    1.写一个程序,通过fork创建一个子进程。父进程与子进程间通过共享存储器(shared memory)进行通讯:

    2.父进程读取一个指定的文本文件,将文件中的每一行读入到共享存储器中,然后等待子进程结束。

    3.子进程判断由父进程读入的存放在共享存储器中的各行是否是回文(指顺读和倒读都一样的字串,忽略空格),并将各行内容及判断结果(yes or no)输出到屏幕上。

    提示:

    a.父进程在创建子进程前通过系统调用shmget先向内核申请创建一个共享存储段,申请时给它一个key值(整数);

    b.子进程利用与父进程相同的key值去申请使用该共享存储段;

    请通过Linux的man工具查询shmget, shmat,shmdt的用法。

    Key_t key; int shmid;

    Key = 5678;

    申请创建:shmid = shmget(key,100,IPC_CREAT|0666);

    申请使用:semid = shmget(key,100,0666);

    Operating System Concepts


    Chapter 7 process synchronization

    Lab

    实验1(b):进程间通讯

    要求:

    1.在实验1(a)的基础上,实现生产者/消费者问题,要求不是父子进程而是两个独立的进程进行通讯(两个独立的进程单独运行);

    2.将共享存储器作为一个环形缓冲区来管理,生产者进程往里面放消息(一个消息是一行字符串),消费者进程一次从里面读取一个消息,再如1(a)一样判断其是否为一回文,并输出;

    3. 因为两进程可能同时访问该共享存储段,因而需要通过信号量进行同步。

    注:信号量的使用:两个进程通过相同的key值向OS申请,一个进程(生产者)申请创建,另一个进程(消费者)申请使用。方法与共享存储器的使用类似。

    请通过Linux的man工具查询semget, semop的用法。

    Key_t key; int semid;

    Key = 5678;

    申请创建:semid = semget(key,1,IPC_CREAT|0666);

    申请使用:semid = semget(key,1,0666);

    Operating System Concepts


  • Login