1. Synchronization

2. Inter-Process Communication (IPC)
IPC needed in
multiprogramming – management of multiple processes within a uni-processor system
multiprocessing – management of multiple processes within a multi-processor system
Pass information to each other via shared resource
Mutual exclusion & Synchronization
Proper sequencing

3. Spooling Example: Correct
Shared memory
Process 1
Process 2
int next_free;
int next_free; …
out 1
next_free = in; 4
abc
Stores F1 into next_free; 2
Prog.c 5
Prog.n 6 3
in=next_free+1 in 7 F1 4
next_free = in F2 5
Stores F2 into next_free; … 6
in=next_free+1

4. Spooling Example: Data Races
Shared memory
Process 1
Process 2
int next_free;
int next_free;
out … 1
next_free = in; 4
abc
Prog.c 2
next_free = in
/* value: 7 */ 5
Stores F1 into next_free; 3
Prog.n 6 in 7 F2 F1 4
in=next_free+1 5
Stores F2 into next_free; … 6
in=next_free+1

5. Critical Region (Critical Section)
Process {
while (true) {
ENTER CRITICAL SECTION
Access shared variables; // Critical Section; LEAVE CRITICAL SECTION
Do other work }

6. Critical Region Requirements
Mutual Exclusion
Progress
Bounded Wait
No Speed and Number of CPU assumptions

7. Critical Region Requirements
Mutual Exclusion: No other process must execute within the critical section while a process is in it.
Progress: If no process is waiting in its critical section and several processes are trying to get into their critical section, then entry to the critical section cannot be postponed indefinitely.

8. Critical Region Requirements
Bounded Wait: A process requesting entry to a critical section should only have to wait for a bounded number of other processes to enter and leave the critical section.
Speed and Number of CPUs: No assumption may be made about speeds or number of CPUs.

9. Oversimplifying Assumptions
visual learning aid: ‘bmp’ in alphabetical order
Bounded Wait
Mutual Exclusion
Progress
Oversimplifying Assumptions

10. No cutting in! Bounded Wait Mutual Exclusion Progress
Oversimplifying Assumptions

11. Are there door locks? No cutting in! Bounded Wait Mutual Exclusion
Progress
Are there door locks?
No cutting in!
Oversimplifying Assumptions

12. We'll be first if we sprint
Bounded Wait
Mutual Exclusion
Progress
Are there door locks?
No cutting in!
We'll be first if we sprint
Oversimplifying Assumptions

13. Are there door locks? Well, Did you see anybody go in? No cutting in!
Bounded Wait
Mutual Exclusion
Progress
Well, Did you see anybody go in?
Are there door locks?
No cutting in!
We'll be first if we sprint
Oversimplifying Assumptions

14. Mutual exclusion using critical regions

15. Mutual Exclusion With Busy Waiting
Possible Solutions
Software-only candidate solutions (Two-Process Solutions)
Lock Variables
Turn-Based Mutual Exclusion
Other Flag Mutual Exclusion
Two Flag Mutual Exclusion
Two Flag and Turn Mutual Exclusion
Hardware solutions
Disabling Interrupts; Test-and-set; Swap (Exchange)
Semaphores

16. Semaphore Concept
Fundamental Principle: two or more processes want to cooperate by means of simple signals
For signaling introduce
Special Variable : Semaphore s
Primitives:
semSignal(s) – transmit signal via semaphore s
semWait(s) – receive signal via semaphore s
Primitives semSignal and semWait must be ATOMIC!!!
Note: Different notation is used for semSignal and semWait (P for semWait, V for semSignal, ‘wait’ for semWait, ‘signal’ for semSignal)

17. Definition of Semaphore Primitives (Counting Semaphore)
struct semaphore{
int count;
queueType queue; };
void semWait(semaphore s)
{ s.count--;
if (s.count < 0)
{ place this process in s.queue;
block this process; }
void semSignal(semaphore s) {
s.count++;
if (s.count ≤ 0)
remove a process P from s.queue;
place process P on ready list; }

18. Definition of Binary Semaphore Primitives
struct binary_semaphore {
enum {0,1} value;
queueType queue; };
void semWaitB(binary_semaphore s) {
if (s.value == 1)
s.value = 0;
else
{ place this process in s.queue;
block this process; }
void semSignalB(binary_semaphore s) {
if (s.queue is empty())
s.value = 1;
else
remove a process P from s.queue;
place process P on ready list; }

19. Mutual Exclusion Using SemaphoresPi {
while(1) {
semWait(s);
/* Critical Section */
semSignal(s);
/* remainder */ }
lock = 0; Pi {
while(1) {
while(Test_And_Set(lock)) { };
/* Critical Section */
lock =0;
/* remainder */ }

20. Process Process Value of Semaphore lock Queue B A 1 semWait(lock)
Critical Region
Value of
Semaphore
lock
Queue B A
Normal Execution
Blocked on
semaphore
lock 1
semWait(lock)
semWait(lock) -1 B
semSignal(lock)
semSignal(lock) 1

21. Implementation of Semaphores in POSIX
POSIX:SEM semaphore is
variable of type sem_t
Atomic Operations:
int sem_init(sem_t *sem, int pshared, unsigned value);
int sem_destroy(sem_t *sem);
int sem_post(sem_t *sem);
Int sem_trywait(sem_t *sem);
Int sem_wait(sem_t *sem);
Use <semaphore.h>

22. Unnamed Semaphores Ch 14 pp 491-501
#include <semaphore.h>
Sem_t sem;
You cannot make a copy of a semaphore variable!!!
#include <semaphore.h>
int sem_init(sem_t *sem, int pshared, unsigned value);
pshared == 0: only threads of process creating semaphore can use semaphore.

23. Sharing Semaphores
Sharing semaphores between threads within a process is easy, use pshared==0
Forking a process creates copies of any semaphore it has… this does not share the semaphore
Making pshared non zero allows any process that can access the semaphore to use it. This places the semaphore in global environment.

24. sem_init can fail!!!
In unsuccessful, sem_init returns -1 and sets errno.
Example:
sem_t semA;
if (sem_init(&semA, 0, 1) == -1)
perror(“Failed to initialize semaphore semA”);
Value > sem_value_max
Resources exhausted
Insufficient privileges
EINVAL
ENOSPC
EPERM
cause
errno

25. Semaphore Operations #include <semaphore.h>
int sem_destroy(sem_t *sem);
Destroying a semaphore that’s been destroyed gives undefined result.
Destroying a semaphore on which a thread is blocked gives undefined results.

26. Semaphore Operations #include <semaphore.h>
int sem_post(sem_t *sem);
Unlocks the semaphore.
If the semaphore value resulting from this operation is:
positive, then no threads were blocked waiting for the semaphore.
zero, then one of the threads blocked waiting for the semaphore will be allowed to return successfully from its call to sem_wait().
if unsuccessful, returns -1 and sets errno
errno == EINVAL if semaphore doesnt exist

27. Semaphore Operations int sem_trywait(sem_t *sem);
locks the semaphore if it is currently not locked (>0).
doesn’t block
returns -1 and errno==EAGAIN if semaphore zero
can be interrupted by signal – errno == EINTR
int sem_wait(sem_t *sem);
locks the semaphore.
If the semaphore value is currently zero, then the calling thread will block.
Can be interrupted by signal – errno == EINTR