Interprocessor Communication

We have already discuss one very limited form of communications, called signals. Signals are used primarily to control groups of processes.

System calls are atomic in Unix. That is either all of the effects of a system call are visible to other processes or none of them are. Hence, basic synchronization is performed using system calls.

There are two types of system calls; fast and slow. Fast system calls can be performed without any waiting; an example is reading the processes PID. Slow system calls may require waiting; for example, many file system syscalls (including all that use a pathname) may have one or more waits as they traverse directories and inodes.

A slow system call can be suspended, but only at well defined points which are explicitly coded into the kernel. Hence, the filesystem path accessing syscall may suspend and wake up after each inode or directory read. If the system call is suspended (as opposed to completed) the process will be blocked.

There are two ways to make slow system calls into fast (non-blocking) calls:

Non-blocking: these calls fail rather than block.
Asynchronous: these calls provide fast returns, even if they don't complete. The process (user space) continues executing after the system call returns. The process must later check whether the call completed, via system call or with a signal.

We now begin discussion of other forms of communications between processes. This communication includes:

Files: most basic form of communication (And the only one that survives system crashes).
Pipes: specialized file "streams"
POSIX 1.b (Formerly POSIX 4)

Message: atomic variable length communications
Shared Memory: multiple processes sharing the same physical memory
Semaphores: memory-based synchronization

Unix History
IPC Uses