Scribd
Upload
12 views17 pages

Unit 2 Lecture 32 - Synchronization Examples

The document provides an overview of synchronization mechanisms in various operating systems, including Windows, Linux, Pthreads, and Solaris. It details specific synchronization techniques such as mutex locks, semaphores, and condition variables, along with their implementation and usage in each system. The content is adapted from multiple sources and aims to educate on the principles of operating system synchronization.

Uploaded by

ayesha45583
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
12 views17 pages

Unit 2 Lecture 32 - Synchronization Examples

The document provides an overview of synchronization mechanisms in various operating systems, including Windows, Linux, Pthreads, and Solaris. It details specific synchronization techniques such as mutex locks, semaphores, and condition variables, along with their implementation and usage in each system. The content is adapted from multiple sources and aims to educate on the principles of operating system synchronization.

Uploaded by

ayesha45583
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 17

OPERATING SYSTEMS

UE22CS242B
Synchronization Examples

Suresh Jamadagni
Department of Computer Science
OPERATING SYSTEMS
Slides Credits for all the PPTs of this course

• The slides/diagrams in this course are an adaptation,


combination, and enhancement of material from the following
resources and persons:

1. Slides of Operating System Concepts, Abraham Silberschatz,


Peter Baer Galvin, Greg Gagne - 9th edition 2013 and some
slides from 10th edition 2018
2. Some conceptual text and diagram from Operating Systems -
Internals and Design Principles, William Stallings, 9th edition
2018
3. Some presentation transcripts from A. Frank – P. Weisberg
4. Some conceptual text from Operating Systems: Three Easy
Pieces, Remzi Arpaci-Dusseau, Andrea Arpaci Dusseau
OPERATING SYSTEMS

Synchronization Examples
● Windows
● Linux
● Pthreads
● Solaris

Suresh Jamadagni
Department of Computer Science
OPERATING SYSTEMS
Windows Synchronization

● Uses interrupt masks to protect access to global resources on uniprocessor


systems
● Uses spinlocks on multiprocessor systems
● For reasons of efficiency, kernel ensures that a thread will never be
preempted while holding a spinlock.
● Also provides dispatcher objects outside the kernel, to synchronize mutex
locks, semaphores, events, and timers
● Events
4 An event acts much like a condition variable (i.e notify a waiting thread
when a desired condition occurs)
● Timers notify one or more thread when time expired
OPERATING SYSTEMS
Windows Synchronization - Mutex dispatcher object

❑Dispatcher objects may be in either a signaled-state (object


available and a thread will not block) or a non-signaled state
(object not available, thread will block)
❑A Relationship exists between the state of a dispatcher object
and the state of a thread.
❑State of a thread changes from ready to waiting and vice-
versa
OPERATING SYSTEMS
Linux Synchronization

● Linux:
● Prior to kernel Version 2.6, disables interrupts to implement
short critical sections
● Version 2.6 and later, fully preemptive
● Linux provides:
● Semaphores
● atomic integers
● spinlocks
● reader-writer versions of both
● On single-cpu system, spinlocks replaced by enabling and disabling
kernel preemption
OPERATING SYSTEMS
Linux Synchronization (Cont.)

▪ Atomic variables
atomic_t is the data type for atomic integer
▪ Consider the variables
atomic_t counter;
int value;
OPERATING SYSTEMS
Pthreads (POSIX) Synchronization

● Pthreads API is OS-independent, widely used on UNIX,


Linux, and macOS
● It provides:
● mutex locks
● semaphores
● condition variable
● Non-portable extensions include:
● read-write locks
● spinlocks
OPERATING SYSTEMS
POSIX Mutex Locks

▪ Creating and initializing the lock

▪ Acquiring and releasing the lock


OPERATING SYSTEMS
POSIX Semaphores

▪ POSIX provides two versions – named and unnamed.


▪ Named semaphores (have actual names in the file system)
can be shared by multiple unrelated processes
▪ Unnamed semaphores can be used only by threads
belonging to the same process.
OPERATING SYSTEMS
POSIX Named Semaphores

▪ Creating and initializing the semaphore:

▪ Another process can access the semaphore by referring to its name SEM.
▪ Acquiring and releasing the semaphore:
OPERATING SYSTEMS
POSIX Unnamed Semaphores

▪ Creating and initializing the semaphore:

▪ Acquiring and releasing the semaphore:


OPERATING SYSTEMS
POSIX Condition Variables

▪ Since POSIX is typically used in C/C++ and these languages do not


provide a monitor (A high-level abstraction that provides a
convenient and effective mechanism for process synchronization) ,
POSIX condition variables are associated with a POSIX mutex lock to
provide mutual exclusion: Creating and initializing the condition
variable:
OPERATING SYSTEMS
POSIX Condition Variables

▪ Thread waiting for the condition a == b to become true:

▪ Thread signaling another thread waiting on the condition variable:


OPERATING SYSTEMS
Solaris 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 (< a few 100 instructions)
● Starts as a standard semaphore spin-lock
● If lock held, and by a thread running on another CPU, spins
● If lock held by non-run-state thread (i.e. the thread holding the
lock is not currently in run state), block and sleep waiting for
signal of lock being released
OPERATING SYSTEMS
Solaris Synchronization (Cont.)

● Uses condition variables


● Uses 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
● Turnstiles are per-lock-holding-thread, not per-object
● Priority-inheritance per-turnstile gives the running thread the
highest of the priorities of the threads in its turnstile
THANK YOU

Suresh Jamadagni
Department of Computer Science and Engineering
[email protected]

You might also like