Operating System Concepts and Techniques Lecture 13

1. Operating System Concepts and Techniques Lecture 13 Interprocess communication-2 M. Naghibzadeh Reference M. Naghibzadeh, Operating System Concepts and Techniques, First ed., iUniverse Inc., 2011. To order: www.iUniverse.com, www.barnesandnoble.com, or www.amazon.com

2. Dekker’s solution • Dekker has a similar solution to Peterson’s, turn and desire are initialized first int desire[2]= {0,0}; int turn =0; void GetPermission( int process) { desire[process] = true; while ( desire[1-process] == true) { if ( turn != process) desire[process] = false; while (turn != process); desire [process] =true; } } void FreePermission(int process) { turn =1-process; desire [process] = false; }

3. Test and set lock (tsl) Method • In this method we use some help from hardware • A machine instruction which does two actions in one instruction, test the content of a memory location and set it equal to one • Its scientific name is test and set lock tsl register, x load register, x store #1, x // Store integer 1 into x • Using this instruction get permission and free resource inline codes are: • GetPermission: tsl register, x • cmp register, #0 • jnz GetPermission • FreePermission: store #0, x

4. Test and set lock (tsl) Method… • The procedure-based implementation of these two operations will look like: void GetPermission (void) { ASM; top: tsl register, x cmp register, #0 jnz top ENDASM; } void FreePermission (void) { x = 0; }

5. An actual tsl-like implementation • Some IBM Machines use TS GetPermission TS x BNZ *-4 //Go back 4 bytes, if not zero FreePermission MVI x,’00’ • Pentium processors use BTS (bit test and set) • Motorola processors have TAS (test and set operand) • Test and set lock method is • not restricted to two processes • not restricted to single processor • but it also suffers from busy-wait

6. Swap (or exchange) method • A shared variabel, say S, shows whether the resource is available, i.e., S=0, or taken, i.e., S=1 • An atomic operation called exchange will exchange the content of two memory locations uninterruptably • Each process will use the following procedures, correctly and in proper places to use the resource void GetPermission (void) { int p = 1; while (p != false) exchange (p, S); } void FreePermission(void) { S = 0; } • The exchange method is applicable in the single-processor or multiprocessor environment • It is applicable for two or more processes.

7. Busy-wait sideeffect • Busy-wait-based methods may sometimes cause priority inversion • When there is no high priority process a low priority starts • Enters a critical region to use a resource • A higher priority process arrives and the system preempts the low priority and starts the high priority • This process requests the same resource • Cannot get it because lower priority is not finished with it, therefore no progress on either processes

8. Semaphore-Based IPC method • Think of a semaphore as an abstract data type • It includes data objects and operations (methods) on these data objects • The whole entity is encapsulated to prevent manipulation of the data objects by any operation except the methods • It has one protected integer data and two methods • Down (or wait): checks the content of the semaphore variable; if it is grater than zero decrements it by one and continues Otherwise, puts the process in the waiting queue • Up (or signal): increments the content of semaphore variable by one; if there is any process waiting for this semaphore wakes one up to continue its execution; the process that has just wakened up must do its down operation again

9. Semaphore types • Binary: takes any of the values zero and one; it is usually initialized to one • It is used for the cases where only one process can use the resource at any given time • For example, there can be one professor teaching in the class • Integer: takes any non-negative integer to a maximum; it is usually initialized tot to its maximum • It is used for the cases where one or more processes can simultaneously use the resource • For example, there can be many students simultaneously participating in a university classroom

10. Producer-consumer problem • Let’s see semaphore in action in a race-free solution to the producer-consumer problem • Producer process(es) produce entities and put them in the shared storage • Consumer(s) take entities from the shared storage and use them • For example, all simultaneous processes in a system could be producers of output files to be printed • Al printers could be consumers • The queue of file names to be printed is the common storage • The size of buffer queue is limited to say BC slots

11. Producer-consumer problem.. • We start the solution by listing all constraints and assigning one semaphore to each constraint • Enforce mutual exclusion in using the entity-buffer • Make sure not to put new entities in a full buffer • Make sure not to remove articles from an empty buffer • We now assign one semaphore to each constraint • mutex , for mutual exclusion enforcement • occupied,to show how many slots of the buffer are occupied • available, to show how many slots are available • Recall that the operation available=BC-accupied is not allowed as we are only allowed to use down and up operations on semaphores

12. Producer-consumer problem.. • Semaphores have to be initialized • #define true 1 • #define BC 1000 // Buffer capacity • typedef int semaphore; //Defines the keyword semaphore • semaphore available = BC; //All buffer slots are available • semaphore occupied = 0; //Buffer is empty • semaphore mutex =1; //Shared Resource is

13. Producer procedure void producer (void) { struct buffer_slot entity; while (true) { produce_an_entity(&entity); wait (&available); //Wait for a free slot wait (&mutex); //Get permission insert_the_entity(&entity); //Put entity in queue signal (&mutex); //Free resource signal (&occupied); //One slot is filled } }

14. Consumer procedure void consumer (void) { struct buf_slot entity; while (true) { wait (&occupied); //Wait until there is an entity wait (&mutex); remove_the_entity(&entity); signal (&mutex); signal (&available); consume_the_entity(&entity); } }

15. Summary • The test-and-set-lock method solves the mutual exclusion problem with the help of a machine instruction provided only for this purpose • Another similar method is the swap method. This tries to obtain the permission to use a shared resource by swapping the value of a local variable with the value of a global variable • Some processors have a machine instruction that can swap the contents of two memory locations in one machine instruction, otherwise we have to implement it by software • These methods (except the disable interrupt) all suffer from busy-wait consumption of CPU time, however the waste may not be high and OS implementers may decide to use them • A semaphore-based method is a busy-wait free form of guaranteeing mutual exclusion • It is general and efficient

16. Find out • A machine instruction in your computer’s processor which works like tsl • A machine instruction in your computer’s processor which works like swap • The percent of CPU time which is wasted due to busy-wait in a system running three concurrent processes sharing one critical resource • An operating system problem scenario which resembles producer-consumer problem • Why busy-wait causes priority inversion • Which of the ME problem solutions you like the best and why

17. Any questions?