CSNB 334 Advanced Operating Systems 4 Concurrency

CSNB 334 Advanced Operating Systems 4. Concurrency : Mutual Exclusion and Synchronization Asma Shakil

Concurrency n Concurrency is the simultaneous execution of threads q The system must support concurrent execution of threads q Scheduling : Deals with execution of “unrelated” threads q Concurrency: Deals with execution of “related” threads Why is it necessary? n Cooperation: One thread may need to wait for the result of some operation done by another thread q e. g. “Calculate Average” must wait until all “data reads” are completed n Competition: Several threads may compete for exclusive use of resources q e. g. two threads trying to increment the value is a memorylocation

Concurrency Thr A load mem, reg inc reg store reg, mem n n Thr B load mem, reg inc reg store reg, mem Critical Section All three instructions of a thread must be executed before other thread

Mutual Exclusion n If one thread is going to use a shared resource (critical resource) q q n n n a file a variable printer register, etc the other thread must be excluded from using the same resource Critical resource: A resource for which sharing by the threads must be controlled by the system Critical section of a program: A part of a program where access to a critical resource occurs

Concurrency

Concurrency Two problems related to concurrency control

Concurrency

Concurrency n Mutual Exclusion Mechanism

Concurrency requirements among all threads that have CSs for the same resource q Only one thread at a time is allowed into its CS, n It must not be possible for a thread requiring access to a CS to be delayed indefinitely q no deadlock q no starvation n When no thread is in a CS, any thread requesting entry to the CS must be granted permission without delay n No assumptions are made about the relative thread speeds or number of processors. n A thread remains inside its CS for a finite time only. n

Concurrency The responsibility of Mutual Exclusion can be satisfied in a number of ways: n Leave it to the processes. Use special purpose machine instructions Provide some support within the OS 1. 2. 3. n n semaphores message passing monitors, etc. It is the responsibility of the OS (not the programmer) to enforce mutual exclusion.

Mutual Exclusion : Hardware Support n n n Interrupt Disabling The only way of providing threads to interleave on a single processor machine is by the use of interrupts. If it is guaranteed that no interrupt occurs while a thread is in the CS, then no other thread can enter the same CS n Simplest solution q n n But it is not desirable to give a thread the power of controlling interrupts In a multiprocessor environment, it does not work This approach is often used by some OS threads (because they are short)

Mutual Exclusion : OS Support Semaphores n Semaphore is a non-negative integer variable q q q Its value is initialized Its value can be changed by two “atomic” instructions WAIT: (P) n n q Wait until the value is greater than 0. Then the value is decremented by 1. (The thread when waiting is moved to a wait queue) SIGNAL: (V) n n The value is incremented by 1 (If there is a thread waiting for that semaphore, it’s woken up and continues)

Semaphores

Synchronization

Synchronization n n Only one thread can access the buffer at a time Order of WAIT signals is crucial q E. g. if WAIT(Mutex) comes before WAIT(Slot. Free) in producer algorithm, the system would go into deadlock when the buffer is full.

Implementation of Semaphores n n They must be atomic There must be a queue mechanism, for putting the waiting thread into a queue, and waking it up later. q Scheduler must be involved n n Define a semaphore as a record typedef struct { int value; struct process *PList; } semaphore; n n Assume two simple operations: q q block suspends the process that invokes it. wakeup(P) resumes the execution of a blocked process P.

Implementation of Semaphores n Semaphore operations now defined as q wait(S): S. value--; if (S. value < 0) { add this process to S. PList; block; } q signal(S): S. value++; if (S. value <= 0) { remove a process P from S. PList; wakeup(P); } n REM: Note that, S can be negative with this implementation, where the negative value indicates the number of processes waiting for S…

Semaphores n n n Semaphore mechanism is handled by OS Writing correct semaphore algorithms is a complex task All threads using the same semaphore assumed to have the same priority. q Implementation does not take priority into account.

Readers-Writers n n Reader tasks and writer tasks share a resource, say a database Many readers may access a database without fear of data corruption (interference) However, only one write may access the database at a time (all other readers and writers must be “locked” out of database. Solutions: q simple solution gives priority to readers. Readers enter CS regardless of whether a write is waiting n q writers may starve second solution requires once a write is ready, it gets to perform its write as soon as possible n readers may starve

Readers-Writers Problem semaphore mutex = 1, wrt = 1; int rdrcnt = 0; Writer // get exclusive lock wait(wrt); … modify object … // release exclusive lock signal(wrt); Reader // enter rdrcnt C. S. wait(mutex); rdrcnt++; if (rdrcnt == 1) // get reader lock wait(wrt); // exit rdrcnt C. S. signal(mutex); … reading is performed … // enter rdrcnt C. S wait(mutex); rdrcnt--; if (rdrcnt == 0) // release reader lock signal(wrt); signal(mutex): // exit rdrcnt C. S.

Concurrency in the Linux Kernel n The arrival of SMP machines and the facility of kernel preemption raises the concern of protecting shared kernel resources from concurrent access. q n A code area that accesses shared resources is called a critical section. Three mechanisms q q q Spinlocks Mutexes Semaphores (old-style)

Spinlocks n n A spinlock ensures that only a single thread enters a critical section at a time. Any other thread has to remain spinning at the door until the first thread exits. #include <linux/spinlock. h> Spinlock_t mylock = SPIN_LOCK_UNLOCKED // Initialize Spin_lock (&mylock); //Acquire the spinlock() /*…………Critical Section code………. . */ Spin_unlock (&mylock); //Release the spinlock() n Wasteful in terms of CPU resources

Mutexes n n Threads are put to sleep on a wait queue, as opposed to spinning when the mutex they try to acquire is locked When releasing a mutex, checks to see if anyone is sleeping on it. q If so, wake up the first thread on the wait queue #include <linux/mutex. h> static DEFINE_MUTEX(mymutex) // Declare a mutex_lock (&mymutex); //Acquire the mutex /*…………Critical Section code………. . */ mpin_unlock (&mymutex); //Release the mutex

The Old Semaphore Interface n Replaced by the mutex interface. #include <asm/semaphore. h> static DECLARE_MUTEX(mysem) // Declare a semaphore down (&mysem); //Acquire the semaphore /*…………Critical Section code………. . */ up (&mysem); //Release the semaphore

Example 1 n A simple readers/writers program using a one -word shared memory. q read-write-1. c

mmap() system call n To memory map a file, use the mmap() system call, which is defined as follows: void *mmap(void *addr, size_t len, int prot, int flags, int fildes, off_t off);

n addr q n len q n This is the file descriptor opened earlier. off q n MAP_SHARED if you want to share your changes to the file with other processes, or MAP_PRIVATE otherwise. If you set it to the latter, your process will get a copy of the mapped region, so any changes you make to it will not be reflected in the original file--thus, other processes will not be able to see them. fildes q n The "protection" argument allows you to specify what kind of access this process has to the memory mapped region. PROT_READ, PROT_WRITE, and PROT_EXEC, for read, write, and execute permissions, respectively. flags q n This parameter is the length of the data we want to map into memory. This can be any length you want. (rounded to the page size) prot q n This is the address we want the file mapped into. This is the offset in the file that you want to start mapping from. A restriction: this must be a multiple of the virtual memory page size. This page size can be obtained with a call to getpagesize(). mmap() returns -1 on error, and sets errno. Otherwise, it returns a pointer to the start of the mapped data.

Stack Mapped File Heap Bss Text File Mapped Region of file Off len

An Example of using mmap() #include <unistd. h> #include <sys/types. h> #include <sys/mman. h> int fd, pagesize; char *data; fd = fopen("foo", O_RDONLY); pagesize = getpagesize(); data = mmap((caddr_t)0, pagesize, PROT_READ, MAP_SHARED, fd, pagesize); Once this code stretch has run, you can access the first byte of the mapped section of file using data[0].

Annotations for read-write-1. c: n n n The mmap procedure (from the <sys/mman. h> library) sets up a shared memory segment and returns the base address for that segment. It has the following form: q base address = mmap(0, num bytes, protection, flags, -1, 0); The second parameter, num bytes, specifies the number of bytes to be allocated for the new segment. The third parameter, protection, specifies whether the segment may be used for reading, writing, executing, or other purpose. q For typical shared memory, both read and write permission is specified using the combination PROT READ | PROT WRITE. In read-write-1. c, the combination MAP ANONYMOUS | MAP SHARED in the fourth parameter indicates a new memory segment should be allocation (rather than allocating space from a file descriptor) and all writes to the memory segment should be shared with other processes. The value -1 in the next-to-last parameter indicates a new, internal file descriptor is needed - the segment will not be part of an existing file.

Example 2 n A simple readers/writers program using a shared buffer and spinlocks q read-write-2. c

Annotations for read-write-2. c: n A logical buffer is allocated in shared memory, and buffer indexes, in and out, are used to identify where data will be stored or read by the writer or reader process. More specifically, q q n *in gives the next free place in the buffer for the writer to enter data. *out gives the first place in the buffer for the reader to extract data. Writing to the buffer may continue unless the buffer is full (i. e. , (*in + 1) % BUF SIZE == *out) and reading from the buffer may proceed unless the buffer is empty (i. e. , *in == *out). Both conditions are tested in spin locks.