Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.

Chapter 4

Inter-Process Communication (IPC)

On The Same Machine

Semaphors Mutexes Monitors

Message Passing

Carry explicit information Compared to semaphores, etc.

Can be used for synchronization

Header Body

IPC Primitives Send/receive Send/receive can be blocking or

non-blocking Communication can be

synchronous or asynchronous Communication can also be

transient or persistent Sockets (Java and Unix)

IPC Primitives (Cont.) Send ( destination, &msg );

Receive ( source, &buf );destination and source can be process id, port (with single receiver), or mailbox (multiple receivers)

Blocking vs. non-blocking Non-blocking: returns after ‘minimal’ delay;

only local operation is involved Blocking receive: blocks until message

available Blocking send: different definitions

Communication System

Send A Message

Process A

1

2Network controller

Network

4

5

3

User space

Kernel space

Process B

What’s it for?

Comments In non-blocking send/receive, interrupt

can be used to inform calling process when operation is complete (e.g., Unix SIGIO)

Non-blocking receive can simulate blocking receive (busy wait), but not vice versa (unless extra thread is used)

Non-blocking receive is not very useful (you cannot proceed without message)

Comparison Blocking

Advantages: Ease of use and low overhead of implementation

Disadvantage: low concurrency Non-blocking

Advantages: Flexibility, parallel operations Disadvantages: Programming tricky: Program is

timing-dependent (interrupt can occur at arbitrary time, and execution irreproducible)

Using blocking version with multi threads

Multi-thread for Blocking

Some threads are blocked while others continue to be active.

Practice

Many OSs support both blocking and non-blocking versions of send/receive

With blocking version, timeout option is often available

Blocking send may also block on full buffer (no more space in send buffer)

Implementation Consideration Time-out is especially important for inter-

machine communication, due to possible failure of communication or remote machine

Copying to local kernel takes time, but facilitates buffer reuse by sender

If destination is on same machine, send-by-reference, is most efficient if memory can be shared, but access must be controlled after send Copy-on-write

Communication Synchronous: communication if sender blocks until

some response returns from destination. Asynchronous: not synchronous

The client is not assumed to wait for the server after issuing request

It may continue processing before reply arrives

often handled using message passing Transient: Both sender and receiver must be up and

running Persistent: Sender and receiver need not be running

at same time

Persistent Communication Message stored by communication system as

long as it takes to deliver Sending application does not need to keep

executing after sending Receiving applications does not have to be

executing when message sent Needed when:

systems are large not all parts continually connected Handle network failure mobility

Transient Communication

Message stored only as long as both sending and receiving application are executing

Can have various transient synchronous

Persistent Communication

A

B

A

B

Time

Time

A sends message and continues.

A stopped running.

B is not running

B starts and receives message.

Message is stored at B’s location for later delivery.

Accepted

B is not running

B starts and receives message.

A sends message and waits until accepted.

A stopped running.

(a) Persistent asynchronous communication

(b) Persistent synchronous communication

Transient Communication (1)

A

B

A

B

Time

Time

A sends message and continues.

B receives message.

Request is received.

ACK

B is running but doing something else.

B processes request.

A sends message and waits until received.

(c)Asynchronous communication

(d) Receipt-based synchronous communication

Message can be sent only if B is running.

Transient Communication (2)

A

B

A

B

Time

Time

A sends request and waits until accepted.

B is running but doing something else.

Process request

Accepted

A sends request and waits for reply.

(e) Delivery-based synchronous communication

(f) Response-based synchronous communication

Request is received.

Accepted Request is received.

B is running but doing something else.

Process request

Example: E-Mail User message sent to local mail server Stored in temporary buffer Subsequently sent to target mail server Placed in mail box for recipient to read How about RPC?

Actually delivery-based transient synchronous

Ways of Communication

Shared memory Copy-on-write

Pipe Socket Message passing

Copy-On-Write

A lazy approach Widely used

In UNIX: fork() call Another example:

String s1=“Hello”;String s4=s3=s2=s1;

Overheads

Region size Simple copy Amount of data copied (on writing) 0 kilobytes

(0 pages)8 kilobytes(1 page)

256 kilobytes(32 pages)

8 kilobytes 1.4 2.7 4.82

256 kilobytes 44.8 2.9 5.12 66.4

_

Note: all times are in milliseconds.

•Good for large region

•Good for small amount of update

•Less effects on system performance

Pipe Pipe

Between two related processes Processes with the same ancestor

FIFO of bounded length (normally 4KB) No message boundaries Heavily used in shell commands

E.g. ls -l | grep “^d” Named pipe

Almost like file: name and permissions (but created by mknod)

Can be accessed by unrelated processes Persistent

Pipe: Code Snippet

if(pipe(p) == -1) { perror("pipe call error"); exit(1); } switch(pid = fork()){

case -1: perror("error: fork call"); exit(2);case 0: /* if child then write down pipe */

close(p[0]); /* first close the read end of the pipe */

write(p[1], msg1, MSGSIZE); write(p[1], msg2, MSGSIZE); close(p[1]);break;

default: /* parent reads pipe */ close(p[1]); /* first close the write end of the

pipe */ for(j=0; j<2; j++) { read(p[0], inbuf,

MSGSIZE); } close(p[0]);

}

Sockets And Ports

message

agreed portany port socketsocket

Internet address = 138.37.88.249Internet address = 138.37.94.248

other ports

client server

•An improvement on pipe.

•Based on client-server model

•Originated from BSD UNIX. Now available in most modern OSs.

Socket Types in UNIX Stream socket: provides for the

bidirectional, reliable, sequenced, and unduplicated flow of data without record boundaries. Very similar to pipe

Datagram socket: supports bidirectional flow of data which is not promised to be sequenced, reliable, or unduplicated Preserve record boundaries. Reliability guaranteed by high-level apps. Most widely used

Socket Types (Cont.) A raw socket: provides users access to

the underlying communication protocols which support socket abstractions. Not for general users

Sequenced packet socket: similar to a stream socket, with the exception that record boundaries are preserved. Only for Xerox communication standard

Socket Creation: socket() s = socket(domain, type, protocol);

A system call domain: AF_UNIX or AF_INET type: SOCK_STREAM, SOCK_DGRAM, etc protocol: TCP or UDP. Auto selected if 0 Return a socket descriptor (a small integer

for later reference) Ex: s = socket(AF_INET, SOCK_STREAM, 0);

Creation Failure: Reasons

Unknown protocol Socket without supporting protocol Any more? Fun question:

Test the function StrtoInt(char *s) Converting a string to an integer

Binding Names: bind() Socket created without an address

Process has no way to access it. System call: bind(s, address, len)

s: socket descriptor address: <local address, local port> or a

path name len: the length of the address.

Why not make socket() and bind() as one system call?

Connection Establishment

Asymmetric, involving a server and a client Server: createbindlistenaccept Client: createbindconnect connect(s, address, len)

s: socket descriptor address: server address len: the length of the address

Connection Failure

Timeout Server down or network corrupt

Connection refused Server not ready yet

Network down or server down Unknown host

System Call: listen()

listen(s, max_num) s: socket descriptor max_num: the maximum number of

outstanding connections which may be queued awaiting acceptance by the server process

If the queue is full, a connection will be ignored (instead of refused). Why?

System call: accept() newsock = accept(s, from-addr,len)

s: socket descriptor from-addr: to store the address of the client

Usually a pointer, could be null len: length of from-addr Return a new socket. Why? Usually block the caller Cannot select the client to be accepted.

Data Transfer Once a connection is established,

data flow may begin. write(s, buf, sizeof (buf));

send(s, buf, sizeof (buf), flags); read(s, buf, sizeof (buf));

recv(s, buf, sizeof (buf), flags); Flags: provide more features

E.g.: look at data without reading

Discarding Sockets

close(s) Sockets which promises reliable

transmission will still attempt transfer data.

Shutdown(s, how), where how is 0: no more receiving 1: no more sending 2: no more receiving or sending

Input/Output Multiplexing

A server/client could have multiple sockets selection issue

select(nfds, &readmask, &writemask, &exceptmask, &timeout); nfds: number of descriptors readmask: indicating the sockets which

the caller is interested in reading Similar for writemask and exceptmask

BSD UNIX Sockets

socket()

close()

read()

connect()

write()

client

socket()

bind()

listen()

accept()

accept()

read()

write()

close()

server

Start a

thread

Wait for new

connection

Java Sockets

close()

readUTF()

socket()

writeUTF()

client socket()

accept()

accept()

readUTF()

writeUTF()

close()

server

Start a

thread

Wait for new

connection

Exampleimport java.net.*

import java.io.*

public class ToDServer {

public static void main ( String args[ ] ) {

// Create a server socket that listens on port 5555

try { ServerSocket s = new ServerSocket ( 5555 );

System.out.println ( “Server is listening ….” );

while ( true) {

// Listen for connect requests

Socket client = s.accept ( );

// Create a separate thread

Connection c = new Connection ( client );

c.start ( ); // service the request

} // end while

} //end try

} //end main

Q: how to make sure there is only one object of class ToDServer?

Connection.javapublic class Connection extends Thread

{ private Socket clientSocket

public Connection (Socket aClientSocket) {

clientSocket = aClientSocket;

}

public void run() {

try { // Here we use file IO over socket

private PrintWriter pOut = new

PrintWriter(clientSocket.getOutputStream(), true );

pOut.println( “The date and time is” +new java.util.Date().toString() );

clientSocket.close();

} //try

} // end of run()

} // end of Connection

Disadvantages of Sockets

• Sockets are not suitable for general programming: they do not provide alternatives for buffering and synchronization.

Connection-oriented Require connectionless

communication in many cases

Message Oriented Middleware (MOM) Based on message passing (obviously) Extensive support for persistent

asynchronous communication Have intermediate-term storage

capacity for messages Neither sender nor receiver required to

be active during transmission Message can be large Transmission time in minutes.

Message-Queuing The idea of a message queue is central

to MOM A sender inserts a message in a queue Receivers read messages from a queue Or a group of receivers may read from

the same queue Only guarantee is that a message will be

inserted in receivers queue no guarantees about when

Message Brokers Issue: message format

How to make sure the receiver understands sender’s message?

One format? Application are too diverse.

Act as an application level gateway E.g. change delimiters at the end of

records

Case Study: Mach System

Developed in CMU Target: implement much of UNIX as

user-level processes Microkernel Support multiple systems

Structure

Application processes/objects

Multiprocessor or uniprocessor

BSD4.3UNIX

CamelotDatabase OS/2

Object-orientedlanguagerun-time

MkLinux

Mach kernel

Features Multiprocessor operation Transparent extension to network

operation User-level servers

Microkernel Operating system emulation Flexible virtual memory

implementation Map files as virtual memory regions.

Concepts Tasks: execution environment

Protected address space, collection of kernel-managed capabilities.

Threads

Ports: a unicast, unidirectional communication channel with an associated message queue.

Port rights: capabilities to send messages to a port or receive messages from a port

Can be transferred The only way to access ports by programmers

Capability list List of port numbers with associated rights.

Messages: can contain port rights in addition to pure data.

Tasks, Ports And Communication

Uniprocessor Multiprocessor

Mach

Network

Networkservers

Port

Task

Thread

Processor

Key:

Communications

Thread mapping

Mach

Task & Thread Creationtask_create(parent_task, inherit_memory, child_task)

parent_task is the task used as a blueprint in the creation of the new task, inherit_memory specifies whether the child should inherit the address space of its parent or be assigned an empty address space, child_task is the identifier of the new task.

thread_create(parent_task, child_thread)parent_task is the task in which the new thread is to be created, child_thread is the identifier of the new thread. The new thread has no execution state and is suspended.

thread_set_state(thread, flavour, new_state, count)thread is the thread to be supplied with execution state, flavour specifies the machine architecture, new_state specifies the state (such as the program counter and stack pointer), count is the size of the state.

thread_resume(thread)This is used to resume the suspended thread identified by thread.

Access Control Resources accessed through ports Port rights:

Send May possessed by any number of tasks

Send-once: allow at most one msg sent Receive

At most one task may possess receive right at one time

Acquire port rights At creation Create new ports Receive port rights sent in messages

A Task’s Port Name Space

Task t (user-level) Kernel

t 's port name space

Port rights andport set rights(capabilities)

Port(s)

iSystem call quotingport right or port setidentifier i

Kernel Ports

On creation each task and threads are given some kernel ports, e.g., thread_self: thread can create new port

by sending msg to this port task_notify: to receive msg from kernel. Bootstrap: provides access to Name

Server, through which task can obtain send rights to ports of publicly available servers.

Network Communication Server Implemented at user-level, one per

computer Responsibilities:

Delivery guarantee Make network transparent Monitor the transfer of port rights Protect ports against illegal access Maintain the privacy of message

Network Communication in Mach

Mach Network Mach

8 n an 107

8

107

n

Message to a

Sendertask

Receivertask

Network address a

Address Send rights

Network server Network server

Receive rights Network port Network port

External Pagers

Task’saddress

spaceExternal pager

Memorycacheobjects

Kernel

Network

PortMessages

Kernel

Region