Critical Sections with lots of Threads - PowerPoint PPT Presentation

Loading...

PPT – Critical Sections with lots of Threads PowerPoint presentation | free to download - id: 17eaee-MTBiM



Loading


The Adobe Flash plugin is needed to view this content

Get the plugin now

View by Category
About This Presentation
Title:

Critical Sections with lots of Threads

Description:

Can we generalize to many threads? Obvious approach won't work: ... of a popular store with a crowded counter, perhaps the pastry shop in Montreal's ... – PowerPoint PPT presentation

Number of Views:46
Avg rating:3.0/5.0
Slides: 19
Provided by: ranveer7
Category:

less

Write a Comment
User Comments (0)
Transcript and Presenter's Notes

Title: Critical Sections with lots of Threads


1
Critical Sections with lots of Threads
2
Refresher Dekers Algorithm
  • Assumes two threads, numbered 0 and 1
  • CSEnter(int i)
  • int J i1
  • insidei true
  • turn J
  • while(insideJ turn J)
  • continue
  • CSExit(int i)
  • insidei false

3
Can we generalize to many threads?
  • Obvious approach wont work
  • Issue notion of whos turn is next for
    breaking ties
  • CSEnter(int i)
  • insidei true
  • for(J 0 J lt N J)
  • while(insideJ turn J)
  • continue
  • CSExit(int i)
  • insidei false

4
Bakery concept
  • Think of a popular store with a crowded counter,
    perhaps the pastry shop in Montreals fancy
    market
  • People take a ticket from a machine
  • If nobody is waiting, tickets dont matter
  • When several people are waiting, ticket order
    determines order in which they can make purchases

5
Bakery Algorithm Take 1
  • int ticketn
  • int next_ticket
  • CSEnter(int i)
  • ticketi next_ticket
  • for(J 0 J lt N J)
  • while(ticketJ ticketJ lt ticketi)
  • continue
  • CSExit(int i)
  • ticketi 0
  • Oops access to next_ticket is a problem!

6
Bakery Algorithm Take 2
  • int ticketn
  • CSEnter(int i)
  • ticketi max(ticket0, ticketN-1)1
  • for(J 0 J lt N J)
  • while(ticketJ ticketj lt ticketi)
  • continue
  • CSExit(int i)
  • ticketi 0
  • Clever idea just add one to the max.
  • Oops two could pick the same value!

7
Bakery Algorithm Take 3
  • If i, j pick same ticket value, ids break tie
  • (ticketJ lt ticketi) (ticketJticketi
    Jlti)
  • Notation (B,J) lt (A,i) to simplify the code
  • (BltA (BA Jlti)), e.g.
  • (ticketJ,J) lt (ticketi,i)

8
Bakery Algorithm Take 4
  • int ticketN
  • boolean pickingN false

CSEnter(int i) ticketi max(ticket0,
ticketN-1)1 for(J 0 J lt N J)
while(ticketJ (ticketJ,J) lt
(ticketi,i)) continue
  • CSExit(int i)
  • ticketi 0
  • Oops i could look at J when J is still storing
    its ticket, and yet J could have the lower ticket
    number!

9
Bakery Algorithm Almost final
  • int ticketN
  • boolean choosingN false

CSEnter(int i) choosingi true ticketi
max(ticket0, ticketN-1)1 choosingi
false for(J 0 J lt N J) while(choosingJ)
continue while(ticketJ (ticketJ,J) lt
(ticketi,i)) continue
  • CSExit(int i)
  • ticketi 0

10
Bakery Algorithm Issues?
  • What if we dont know how many threads might be
    running?
  • The algorithm depends on having an agreed upon
    value for N
  • Somehow would need a way to adjust N when a
    thread is created or one goes away
  • Also, technically speaking, ticket can overflow!
  • Solution Change code so that if ticket is too
    big, set it back to zero and try again.

11
Bakery Algorithm Final
  • int ticketN / Important Disable thread
    scheduling when changing N /
  • boolean choosingN false

CSEnter(int i) do ticketi 0
choosingi true ticketi
max(ticket0, ticketN-1)1 choosingi
false while(ticketi gt MAXIMUM) for(J
0 J lt N J) while(choosingJ)
continue while(ticketJ (ticketJ,J) lt
(ticketi,i)) continue
  • CSExit(int i)
  • ticketi 0

12
How do real systems do it?
  • Some real systems actually use algorithms such as
    the bakery algorithm
  • A good choice where busy-waiting isnt going to
    be super-inefficient
  • For example, if you have enough CPUs so each
    thread has a CPU of its own
  • Some systems disable interrupts briefly when
    calling P() and V()
  • Some use hardware help atomic instructions

13
Critical Sections with Atomic Hardware Primitives
  • Process i
  • While(test_and_set(lock))
  • Critical Section
  • lock false

Share int lock Initialize lock false
Assumes that test_and_set is compiled to a
special hardware instruction that sets the lock
and returns the OLD value (true locked false
unlocked)
Problem Does not satisfy liveness (bounded
waiting) (see book for correct solution)
14
Presenting critical sections to users
  • CSEnter and CSExit are possibilities
  • But more commonly, operating systems have offered
    a kind of locking primitive
  • We call these semaphores

15
Semaphores
  • Non-negative integer with atomic increment and
    decrement
  • Integer S that (besides init) can only be
    modified by
  • P(S) or S.wait() decrement or block if already 0
  • V(S) or S.signal() increment and wake up process
    if any
  • These operations are atomic

These systems use the operation signal() instead
of V()
Some systems use the operation wait() instead of
P()
semaphore S P(S) while(S 0)
S--
V(S) S
16
Semaphores
  • Non-negative integer with atomic increment and
    decrement
  • Integer S that (besides init) can only be
    modified by
  • P(S) or S.wait() decrement or block if already 0
  • V(S) or S.signal() increment and wake up process
    if any
  • Can also be expressed in terms of queues

semaphore S P(S) if (S 0) stop thread,
enqueue on wait list, run something else S--
V(S) S if(wait-list isnt empty)
dequeue and start one process
17
Summary Implementing Semaphores
  • Can use
  • Multithread synchronization algorithms shown
    earlier
  • Could have a thread disable interrupts, put
    itself on a wait queue, then context switch to
    some other thread (an idle thread if needed)
  • The O/S designer makes these decisions and the
    end user shouldnt need to know

18
Semaphore Types
  • Counting Semaphores
  • Any integer
  • Used for synchronization
  • Binary Semaphores
  • Value is limited to 0 or 1
  • Used for mutual exclusion (mutex)

Process i P(S) Critical Section V(S)
Shared semaphore S Init S 1
About PowerShow.com