Scribd Logo
Upload

Welcome to Scribd!

  • 755 views

    Classical Problem of Synchronization

    Uploaded by

    Anubhav Halwai
    The document discusses several classical concurrency problems: producer-consumer with unbounded/bounded buffers, reader-writer problem, and dining philosophers problem. It also provides definitions and solutions to these problems using concepts like semaphores, mutexes and condition variables to synchronize access to shared resources. The document also introduces monitors as a synchronization construct that encapsulates shared data and associated operations to provide atomic access.

    Copyright:

    Attribution Non-Commercial (BY-NC)
    Download as PPT, PDF, TXT or read online from Scribd

    Classical Problem of Synchronization

    Uploaded by

    Anubhav Halwai
    755 views14 pages
    The document discusses several classical concurrency problems: producer-consumer with unbounded/bounded buffers, reader-writer problem, and dining philosophers problem. It also provides definitions and solutions to these problems using concepts like semaphores, mutexes and condition variables to synchronize access to shared resources. The document also introduces monitors as a synchronization construct that encapsulates shared data and associated operations to provide atomic access.

    Original Description:

    fgdfhdhdfhdhdhdhdhdhdhdhdfdhhhdhdhdhhgdsjkj

    Copyright

    © Attribution Non-Commercial (BY-NC)

    Available Formats

    PPT, PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    The document discusses several classical concurrency problems: producer-consumer with unbounded/bounded buffers, reader-writer problem, and dining philosophers problem. It also provides definitions and solutions to these problems using concepts like semaphores, mutexes and condition variables to synchronize access to shared resources. The document also introduces monitors as a synchronization construct that encapsulates shared data and associated operations to provide atomic access.

    Copyright:

    Attribution Non-Commercial (BY-NC)
    Download as PPT, PDF, TXT or read online from Scribd
    Download as ppt, pdf, or txt
    755 views14 pages

    Classical Problem of Synchronization

    Uploaded by

    Anubhav Halwai
    The document discusses several classical concurrency problems: producer-consumer with unbounded/bounded buffers, reader-writer problem, and dining philosophers problem. It also provides definitions and solutions to these problems using concepts like semaphores, mutexes and condition variables to synchronize access to shared resources. The document also introduces monitors as a synchronization construct that encapsulates shared data and associated operations to provide atomic access.

    Copyright:

    Attribution Non-Commercial (BY-NC)
    Download as PPT, PDF, TXT or read online from Scribd
    Download as ppt, pdf, or txt
    of 14

    Classical problem of Synchronization

    Producer-Consumer

    with an unbounded

    buffer Producer-Consumer with a bounded buffer Reader-Writer problem Dining Philosopher problem

    Producer-Consumer with an unbounded buffer: A buffer of unbounded capacity is set aside to smooth the speed difference between producer and consumer. A producer must be the first process to run in order to provide the first item.

    A consumer process may run whenever there is more than one item in the buffer produced but not yet consumed. Producer may run at any time without restriction.

    Variable produced: semaphore; Process producer begin While true do begin produce

    place_in_buffer
    signal (produced) other _producer _ processing end (while) End (producer)

    Process consumer begin While true do begin wait (produced) take _from _buffer consume other _consumer _ processing end (while) End (consumer)

    Producer-Consumer with a bounded buffer


    Process producer begin While true do begin wait (mayproduced) pitem :=produce wait (pmutex) buffer [ in ]:=pitem in:=in+1 signal(pmutex) signal (mayconsume) other _producer _ processing end (while) End (producer)

    Process consumer begin While true do begin wait (mayconsumed) wait(cmutex) citem := buffer [ out ] out :=out +1 signal (cmutex) signal (mayproduce) other _consumer_processing end (while) End (consumer)

    Reader/Writer problem
    Readcount:integer mutex,write:semaphore (binary) Process reader Begin While true do begin wait (mutex) readercount := readercount + 1; if readercount = 1 then wait(write) Signal(mutex) [read] Wait(mutex) readercount := readercount -1; if readercount =0 then signal(write) Signal(mutex) Other processing End{while}; end {reader}

    Process writer

    Begin While true do begin wait (write) .[writes] Signal(write) Other processing end {while}; end {writer}

    Dining Philosopher problem


    The dining philosophers problem is summarized as five philosophers sitting at a table doing one of two things: eating or thinking. While eating, they are not thinking, and while thinking, they are not eating. The five philosophers sit at a circular table with a large bowl of rice in the center. A chopstick is placed in between each pair of adjacent philosophers, and as such, each philosopher has one chopstick to his left and one chopsticks to his right. it is assumed that a philosopher must eat with two chopsticks. Each philosopher can only use the chopsticks on his immediate left and immediate right. The philosophers never speak to each other, which creates a dangerous possibility of deadlock when every philosopher holds a left fork and waits perpetually for a right fork (or vice versa).

    Solution :do { wait (chopstick [i]); wait (chopstick [ ( i+1 ) % 5 ]); // eat signal (chopstick [i]); signal (chopstick [ ( i+1 ) % 5 ] );

    //think
    }while (true);

    1. Allow at most four philosopher to be sitting simultaneously


    2. Allow philosopher to pick up her chopsticks if both chopsticks are available 3. Odd philosopher picks up first left and then right chopstick

    What is a monitor?
    A collection of data and procedures High level of data abstraction tool that automatically generates atomic operations on a given data structure

    A monitor has
    Shared data A set of atomic operations on that data A set of condition variables

    Why monitors?
    Concurrency has always been an OS issue
    Resource allocation is necessary among competing processes Timer interrupts

    Existing synchronization mechanisms (semaphores, locks) are subject to hard-to-find Reduce probability of errors

    Monitor Implementation

    Each monitor has one lock. Acquire lock when begin a monitor operation, and release lock when operation finishes

    Rules to Follow with Monitors


    Any process can call a monitor procedure at any time But only one process can be inside a monitor at any time (mutual exclusion) No process can directly access a monitors local variables (data encapsulation) A monitor may only access its local variables

    You might also like