Networking Operating Systems (CO32010) 1. Operating Systems 2. Processes and scheduling 4. Distributed file systems 5. Routing protocols 6. Routers 7. Encryption 8. NT, UNIX and NetWare 3.1Introduction 3.2Interprocess communication 3.3Flags and semaphores 3.4RPC 3.5Multi-processor systems 3.6Exercises Objectives: To define the concept of distributed processing, and contrast centralized systems against distributed ones. To define mechanisms of interprocess control, such as pipes, semaphores, flags, and message queues. To define, in detail, how semaphores are used, and how the can prevent deadlock. To define the conditions for deadlock. To outline algorithms to prevent deadlock, such as the Banker ’ s Algorithm. To outline practical interprocess control protocols, especially RPC. 3. Distributed processing

Centralised v. Distributed Head Office Regional Office Local Office ATM Customers Staff Logistics Distributed: Decision making Account management Logistics

Network Client requests a remote process and passes process parameters Server runs process and returns the results to the client 3.2 Client/server architecture

Process A Process A Shared memory Shared memory Process A Process A Process B Process B Process B Process B 1. Socket 2. Semaphores 3. Shared memory Resource Process A Process A Process B Process B Sleep until ready Gets access to resource and increments a semaphore (wait) Process A Process A Process B Process B 4. Pipe Process A | Process B Connection over a network over locally 3.3 IPC methods Message queue Message queue Process A Process A Process B Process B 5. Message queue

wait (); code that must be mutually exclusive signal (); wait (); code that must be mutually exclusive signal (); Wait decrements the semaphore Signal increments the semaphore wait (); code that must be mutually exclusive signal (); wait (); code that must be mutually exclusive signal (); Process B will go to sleep as the semaphore has a zero value Process A Process B Process B will wake up when the semaphore value becomes a non-zero Semaphore 3.4 Semaphore usage in a program

#define MAX_BUFF 100 /*maximum items in buffer*/ int buffer_count=0; /*current number of items in buffer*/ void producer_buffer(void) { while (TRUE){/*Infinite loop */ put_item(); /*Put item*/ if (buffer_count==MAX_BUFF) sleep(); /*Sleep, if buffer full */ enter_item(); /*Add item to buffer*/ buffer_count = buffer_count + 1; /*Increment number of items in the buffer */ if (buffer_count==1) wakeup(consumer);/*was buffer empty?*/ } void consumer_buffer(void) { while (TRUE) {/*Infinite loop */ if (buffer_count==0) sleep(); /* Sleep, if buffer empty */ get_item(); /* Get item*/ buffer_count = buffer_count - 1; /* Decrement number of items in the buffer*/ if (buffer_count==MAX_BUFF-1) wakeup(producer_buffer); /* if buffer not full anymore, wake up producer*/ consume_item(); /*remove item*/ } 3.5 Consumer-producer example

Deadlock Resource locking. This is where a process is waiting for a resource which will never become available. Some resources are pre-emptive, where processes can release their access on them, and give other processes a chance to access them. Others, though, are non-pre- emptive, and processes are given full rights to them. No other processes can then get access to them until the currently assigned process is finished with them. An example of this is with the transmission and reception of data on a communication system. It would not be a good idea for a process to send some data that required data to be received, in return, to yield to another process which also wanted to send and receive data. Starvation. This is where other processes are run, and the deadlocked process is not given enough time to catch the required event. This can occur when processes have a low priority compared with other ones, as higher priority tasks tend to have a better chance to access the required resources.

Analogy to deadlock C F A B D E

Four conditions for deadlock Mutual exclusion condition. This is where processes get exclusive control of required resources, and will not yield the resource to any other process. Wait for condition. This is where processes keep exclusive control of acquired resources while waiting for additional resources. No pre-emption condition. This is where resources cannot be removed from the processes which have gained them, until they have completed their access on them. Circular wait condition. This is a circular chain of processes on which each process holds one or more resources that are requested by the next process in the chain.

Banker’s Algorithm (Safe condition) Process A requires a maximum of 50MB. Process B requires a maximum of 40MB. Process C requires a maximum of 60MB. Process D requires a maximum of 40MB. The current state would be safe as Process A can complete which releases 50 MB (which allows the other processes to complete): ProcessCurrent allocationMaximum allocation required A4050 B2040 C2060 D1040 Resource unallocated10

Banker’s Algorithm(Unsafe condition) Process A requires a maximum of 50MB. Process B requires a maximum of 40MB. Process C requires a maximum of 60MB. Process D requires a maximum of 40MB. The current state would be unsafe as no process can complete: ProcessCurrent allocationMaximum allocation required A1550 B3040 C4560 D040 Resource unallocated5

Banker’s Algorithm Each resource has exclusive access to resources that have been granted to it. Allocation is only granted if there is enough allocation left for at least one process to complete, and release its allocated resources. Processes which have a rejection on a requested resource must wait until some resources have been released, and that the allocated resource must stay in the safe region. Problems: Requires processes to define their maximum resource requirement. Requires the system to define the maximum amount of a resource. Requires a maximum amount of processes. Requires that processes return their resources in a finite time. Processes must wait for allocations to become available. A slow process may stop many other processes from running as it hogs the allocation.

RPC

The caller process sends a call message, with all the procedure’s parameters Client Server reads parameters and runs the process Server Caller process waits for a response Server process waits for a call The caller process sends a call message, with all the procedure’s parameters Process, and parameters Server sends results to the client Results Server process waits for a call 3.13 RPC operation