Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.
-
Upload
julian-johnson -
Category
Documents
-
view
238 -
download
3
Transcript of Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.
![Page 1: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/1.jpg)
Chapter 4
Inter-Process Communication (IPC)
![Page 2: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/2.jpg)
On The Same Machine
Semaphors Mutexes Monitors
![Page 3: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/3.jpg)
Message Passing
Carry explicit information Compared to semaphores, etc.
Can be used for synchronization
Header Body
![Page 4: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/4.jpg)
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)
![Page 5: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/5.jpg)
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
![Page 6: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/6.jpg)
Communication System
![Page 7: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/7.jpg)
Send A Message
Process A
1
2Network controller
Network
4
5
3
User space
Kernel space
Process B
What’s it for?
![Page 8: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/8.jpg)
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)
![Page 9: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/9.jpg)
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
![Page 10: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/10.jpg)
Multi-thread for Blocking
Some threads are blocked while others continue to be active.
![Page 11: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/11.jpg)
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)
![Page 12: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/12.jpg)
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
![Page 13: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/13.jpg)
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
![Page 14: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/14.jpg)
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
![Page 15: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/15.jpg)
Transient Communication
Message stored only as long as both sending and receiving application are executing
Can have various transient synchronous
![Page 16: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/16.jpg)
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
![Page 17: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/17.jpg)
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.
![Page 18: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/18.jpg)
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
![Page 19: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/19.jpg)
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
![Page 20: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/20.jpg)
Ways of Communication
Shared memory Copy-on-write
Pipe Socket Message passing
![Page 21: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/21.jpg)
Copy-On-Write
A lazy approach Widely used
In UNIX: fork() call Another example:
String s1=“Hello”;String s4=s3=s2=s1;
![Page 22: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/22.jpg)
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
![Page 23: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/23.jpg)
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
![Page 24: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/24.jpg)
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]);
}
![Page 25: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/25.jpg)
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.
![Page 26: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/26.jpg)
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
![Page 27: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/27.jpg)
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
![Page 28: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/28.jpg)
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);
![Page 29: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/29.jpg)
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
![Page 30: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/30.jpg)
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?
![Page 31: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/31.jpg)
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
![Page 32: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/32.jpg)
Connection Failure
Timeout Server down or network corrupt
Connection refused Server not ready yet
Network down or server down Unknown host
![Page 33: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/33.jpg)
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?
![Page 34: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/34.jpg)
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.
![Page 35: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/35.jpg)
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
![Page 36: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/36.jpg)
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
![Page 37: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/37.jpg)
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
![Page 38: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/38.jpg)
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
![Page 39: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/39.jpg)
Java Sockets
close()
readUTF()
socket()
writeUTF()
client socket()
accept()
accept()
readUTF()
writeUTF()
close()
server
Start a
thread
Wait for new
connection
![Page 40: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/40.jpg)
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?
![Page 41: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/41.jpg)
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
![Page 42: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/42.jpg)
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
![Page 43: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/43.jpg)
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.
![Page 44: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/44.jpg)
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
![Page 45: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/45.jpg)
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
![Page 46: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/46.jpg)
Case Study: Mach System
Developed in CMU Target: implement much of UNIX as
user-level processes Microkernel Support multiple systems
![Page 47: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/47.jpg)
Structure
Application processes/objects
Multiprocessor or uniprocessor
BSD4.3UNIX
CamelotDatabase OS/2
Object-orientedlanguagerun-time
MkLinux
Mach kernel
![Page 48: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/48.jpg)
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.
![Page 49: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/49.jpg)
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.
![Page 50: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/50.jpg)
Tasks, Ports And Communication
Uniprocessor Multiprocessor
Mach
Network
Networkservers
Port
Task
Thread
Processor
Key:
Communications
Thread mapping
Mach
![Page 51: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/51.jpg)
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.
![Page 52: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/52.jpg)
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
![Page 53: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/53.jpg)
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
![Page 54: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/54.jpg)
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.
![Page 55: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/55.jpg)
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
![Page 56: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/56.jpg)
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
![Page 57: Chapter 4 Inter-Process Communication (IPC). On The Same Machine Semaphors Mutexes Monitors.](https://reader036.fdocuments.us/reader036/viewer/2022081420/56649ed55503460f94be631d/html5/thumbnails/57.jpg)
External Pagers
Task’saddress
spaceExternal pager
Memorycacheobjects
Kernel
Network
PortMessages
Kernel
Region