chapter 4
DESCRIPTION
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 - PowerPoint PPT PresentationTRANSCRIPT
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