Organizational Communications and Distributed Object Technologies

95-702 OCT1Master of Information System

Management

Organizational Communications and Distributed Object Technologies

Week 11: Operating Systems Support Coulouris Chapter 6


Management

OS Support

• Modern operating systems support distributed applications and middleware– Network OS– Distributed OS– Processes, threads, ports, and

support for invocation mechanisms.


Management

System layers

Applications, services

Computer &

Platform

Middleware

OS: kernel,libraries & servers

network hardware

OS1

Computer & network hardware

Node 1 Node 2

Processes, threads,communication, ...

OS2Processes, threads,communication, ...

Figure 2.1Software and hardware

service layers in distributed systems

Applications, services

Computer and network hardware

Platform

Operating system

Middleware


Management

Middleware Support• Middleware implements abstractions that

support network-wide programming. Examples:

• RPC and RMI (Sun RPC, Corba, Java RMI, Web Services)

• Messaging, event distribution and filtering (Corba Event Notification, JMS, MOM)

• Resource discovery for mobile and ubiquitous computing• QoS Guarantees for multimedia streaming


Management

OS Types

• Traditional DOS's (e.g. early Unix, Windows 3.0)– simplify, protect and optimize the use of local

resources

• Network OS's (e.g. UNIX, Windows NT) – do the same but they also support a wide range of

communication standards.– For example, TCP and UDP sockets are available from the operating system.- Machines are still autonomous


Management

OS TypesA distributed OS:

• Presents users (and applications) with an integrated computing platform that hides the individual computers.

• Has control over all of the nodes (computers) in the network and allocates their resources to tasks without user involvement.

• In a distributed OS, the user doesn't know (or care) where his programs are running.

• Research examples have been built.

• Not in widespread use.

The combination of middleware plus a network O.S. provides forsome autonomy and some distribution.


Management

OS Support Required by Middleware

An OS manages resources:– processing, memory, persistent storage and communication.

The task of the OS is to:– raise the programming interface for these resources to a more useful level:

• By providing abstractions of the basic resources such as:processes, unlimited virtual memory, files, communication channels

• Protection of the resources used by applications• Concurrent processing to enable applications to complete

their work with minimum interference from other applications– provide the resources needed for (distributed) services and

applications to complete their task:• Communication - network access provided• Processing - processors scheduled at the relevant computers


Management

Core OS functionality

Communication

manager

Thread manager Memory manager

Supervisor

Process manager

Figure 6.2


Management

Core OS functionality

Communication

manager

Thread manager Memory manager

Supervisor

Process manager

Handles the creation of and operation on processes.Create, synchronizeand schedule

Physical and virtualmemory

Typical kernalservicesrun withcomplete access

Machine dependentcode

Between threads in differentprocesses


Management

ProcessThread activations

Activation stacks(parameters, local variables)

Threads concept and implementation

'text' (program code)Heap (dynamic storage, objects, global variables)

system-provided resources(sockets, windows, open files)

The traditional process wasfound to be unequal to thedemands of distributedsystems

Threads can improve throughput but all thissharing can be tricky


Management

The Advantage of Threads(1)

Assume a single process computer and all arrivals are queued with no threading.

1 request = 8 ms of disk input + 2 ms of processor time = 10 ms

N requests 1000 ms======= X ====== = 100 Request/SecondN*10 MS 1 Second


Management

The Advantage of Threads(2)

Allow for two threads. The processor runs in parallel with I/O.

Thread1 8,2,8,2,8,2,8,2,8,2,8 While waiting for disk the other thread Thread2 8,2,8,2,8,2,8,2,8 can use the CPU

N request is roughly (and ideally) N * 8 ms.

N Requests 1000 ms======= X ===== = 125 Requests/SecondN*8 ms 1 second

If a cache is associated with the disk and you add more processorsthis gets even better.


Management

Client and server with threads

Figure 6.5

Client

Thread 2 makes

Thread 1

requests to serverand may block untilreply.

generates results forserver andneeds no reply.

Server

N threads

Input-output

Requests

Receipt &queuing

The 'worker pool' architecture

N threads read from a shared queue of arrivals.


Management

Alternative Server Threading Architectures

a. Thread-per-request b. Thread-per-connection c. Thread-per-object

Figure 6.6

remote

workers

I/O

objects

serverprocess

remote

per-connection threads

objects

serverprocess

remoteI/O

per-object threads

objects

serverprocess

(a) would be useful for UDP-based service, e.g. NTP. See Fig. 4.6. (b) is the most commonly used - matches the TCP connection model. Many

requests may be made over the connection.(c) is used where the service is encapsulated as an object. E.g. could have

multiple shared whiteboards with one thread each. Each object has only one thread, avoiding the need for thread synchronization within objects.


Management

Threads Versus Multiple Processes

• Creating a thread is (much) cheaper than a process (~10-20 times)• Switching to a different thread in same process is (much) cheaper (5-50 times)• Threads within same process can share data and other resources more conveniently and efficiently (without copying or messages)• Processes are generally protected from each other.• Threads within a process are not protected from each other.


Management

Threads Implementation

Threads can be implemented:

– In the OS kernel (Win NT, Solaris, Mach)

– At user level (e.g. by a thread library: C threads, pthreads),

– In the language (Ada, Java).


Management

But Threading Means Sharing

• E.g. Global variables may be shared.

• This permits threads to share information and coordinate.

• But often times, a thread needs private access to data and we are concerned that an another thread will interrupt this access.


Management

Mutual Exclusion?

Begin while(occupied) do {} occupied = trueEnd { critical section }Begin occupied = falseEnd


occupied = false


Management

Mutual Exclusion?



occupied = true


Management

Mutual Exclusion?



occupied = true


Management

Mutual Exclusion?



occupied = false


Management

Mutual Exclusion?



occupied = false

The busy wait loop may be replaced with a call on wait().


Management

Mutual Exclusion? No.



occupied = false


Management

Mutual Exclusion? No.



occupied = true


Management

Why be concerned about mutual exclusion anyway?

Begin while(occupied) do {} occupied = trueEnd { critical section x = 4;}Begin occupied = falseEnd

Begin while(occupied) do {} occupied = trueEnd { critical section x = 9000; }Begin occupied = falseEnd

occupied = true

Perhaps the writing of 9000 to x is interrupted by the writing of 4.Now, x has a little of 9000 and a little of 4.


Management

Dekker’s Algorithm (1964)Begin occupied1 = true while(occupied2) { if(which == 2) { occupied1 = false while(which == 2) {} occupied1 = true } }End critical sectionBegin which = 2 occupied1 = falseEnd

Dekker solves the problemusing software for two processes.

Dijkstra and other solutions exist for more than twoprocesses.


Management


Begin occupied2 = true while(occupied1) { if(which == 1) { occupied2 = false while(which == 1) {} occupied2 = true } }End critical sectionBegin which = 1 occupied2 = falseEnd


Management



occupied1 false occupied2 false which 1


Management





Management



occupied1 true occupied2 false which 2


Management



occupied1 true occupied2 false which 2


Management





Management





Management

Dijkstra’s Semaphore (1965)

• From train terminology, one train at a time on one section of track.

• A semaphore is an integer variable that may be changed by just two primitive operations - P and V.

• P and V stand for Dutch equivalents of test and increment.

• P an V may not be interrupted. Processors are built this way.


Management

Semaphore Operations

STest or waitP(s): if (s > 0) s = s - 1 else suspend this process

Increment or signalV(s): if a process is suspended as a result of P(s) then resume it else s = s + 1


Management

Mutual Exclusion

S Begin P(s)End critical sectionBegin V(s)End

1

Begin P(s)End critical sectionBegin V(s)End


Management

Mutual Exclusion

SBegin if(s > 0) s = s - 1 else suspend this processEnd critical sectionBegin if a process is suspended as a result of P(s), resume it else s = s + 1End

1

Begin if(s > 0) s = s - 1 else suspend this processEnd critical sectionBegin if a process is suspended as a result of P(s), resume it else s = s + 1End


Management

Mutual Exclusion


0



Management

Mutual Exclusion


0



Management

Mutual Exclusion


0


S changes back to 1.Quiz: What will happen if s starts off at 0?


Management

Semaphores

• May be extended to mutual exclusion over multiple processes.

• May be used to solve the producer consumer problem.

Process P1 Process P2

: : E1 E2

: :• We need E1 to produce before E2

consumes.


Management

Producer/Consumer


: : E1 E2

store data read data from in buffer buffer


Management

Producer/Consumer


: : : P(S) Event E1 Event E2

V(S) :

S is initially zero. Assume writes are queued. Do three writes followed by four reads. What happens?


Management

The Circular Buffer Problem Is Generalized Producer Consumer

occupied: semaphore (initially 0 - number of filled locations)empty : semaphore (initially n - number of empty locations)

j = 0 i = 0repeat repeat

P(empty) P(occupied) store data in location j get data from location i j = (j + 1) mod n i = (i + 1) mod n V(occupied) V(empty)Until forever until forever

We can’t readif none areoccupied.

We can’t writeif none areempty.


Management


occupied: goes from 0 to 1empty : goes from 3 to 2






Management








Management








Management


occupied: goes from 3 to 2 and back to 3empty : goes from 1 to 0





Resumewriter


Management

Locks• A lock is a variable associated with a data

item and describes the status of that item with respect to possible operations that can be applied to that item.

• Generally, there is one lock for each item.• Locks provide a means of synchronizing the

access by concurrent transactions to the items.

• Locks lead to big atomic actions.


Management

Example: Binary Lock (1)

Lock_Item(x)B: if(Lock(x) == 0) Lock(x) = 1 else { wait until Lock(x) == 0 and we are woken up. GOTO B }

Not interleaved with othercode until this terminates orwaits.


Management

Example: Binary Lock(2)

Unlock_Item(x) Lock(x) = 0 if any transactions are waiting then wake up one of the waiting transactions.

Not interleaved with othercode.


Management

Locks Can Support Concurrent Transactions

Transaction T1 Transaction T2

Lock_Item(x) Lock_Item(y) T1 uses x T2 uses y

Unlock_Item(x) Unlock_Item(y)

If x differs from y these two transactions proceed concurrently.If both want to use x, one waits until the other completes.


Management

Support for Communication and Invocation

• The performance of RPC and RMI mechanisms is critical for effective distributed systems. – Typical times for 'null procedure call':– Local procedure call < 1 microsecond =10-6 sec– Remote procedure call ~ 10 ms = 10-2 sec– That is about 100 times slower!– 'network time' (involving about 100 bytes

transferred, at 100 megabits/sec.) accounts for only .01 millisecond; the remaining delays must be in OS and middleware - latency, not communication time.


Management

Where Does The Time Go?

•Factors affecting RPC/RMI performance–marshalling/unmarshalling + operation dispatch at the server–data copying:- application -> kernel space -> communication buffers–thread scheduling and context switching:- including kernel entry–protocol processing:- for each protocol layer–network access delays:- connection setup, network latency


Management

Implementation of Invocation Mechanisms

• Most invocation middleware (Corba, Java RMI, HTTP) is implemented over TCP– For universal availability, unlimited message

size and reliable transfer; – Sun RPC (used in NFS) is implemented over

both UDP and TCP and generally works faster over UDP

– RPC is heavily used on backend systems


Management

Implementation of Invocation Mechanisms

• Research-based systems have implemented much more efficient invocation protocols

• Concurrent and asynchronous invocations (getting a lot of attention - Messaging)– middleware or application doesn't

block waiting for reply to each invocation


Management

Invocations Between Address Spaces

Control transfer viatrap instruction

User Kernel

Thread

User 1 User 2

Control transfer viaprivileged instructions

Thread 1 Thread 2

Protection domainboundary

(a) System call

(b) RPC/RMI (within one computer)

Kernel

(c) RPC/RMI (between computers)

User 1 User 2

Thread 1 Network Thread 2

Kernel 2Kernel 1

Figure 6.11


Management

Summary• The OS provides local support for the

implementation of distributed applications and middleware:– Manages and protects system resources

(memory, processing, communication)– Provides relevant local abstractions:

• files, processes• threads, communication ports

• Middleware provides general-purpose distributed abstractions– RPC, RMI, Messaging, streaming

Documents

Organizational Communications and Distributed Object Technologies