Process Communication

Shared Memory Systems

• In general, the memory to be shared in a shared-memory system is initially within the address space of a particular process, which needs to make system calls in order to make that memory publicly available to one or more other processes. 
• Other processes which wish to use the shared memory must then make their own system calls to attach the shared memory area onto their address space. 
• Generally a few messages must be passed back and forth between the cooperating processes first in order to set up and coordinate the shared memory access. 

Example" POSIX Shared Memory

• Step 1: one of the processes involved to allocate some shared memory, using shmget
• int segment_id = shmget(IPC_PRIVATE, size, S_IRUSR | S_IWUSR)
• The first parameter 
• specifies the key (identifier) of the segement. IPC_PRIVATE creates a new shared memory segment.
• The second parameter
• How big the shared memory segment is to be, in bytes.
• The third parameter
• A set of bitwise ORed flags. In this case, the segment is being created for reading and writing.
• The return value
• an integer identifier
• Step 2: Any process which wishes to use the shared memory must attach the sahred memory to their address space, using shmat
• char* shared_memory = (char *) shmat(segment_id, NILL, 0)
• The first parameter
• Specify the key of the segment that the process wishes to attack to its address space
• The second parameter
• Indicate where the process wishes to have the segment attacked. Null insicates the system should decide.
• The third parameter
• A flag for read-only operation. Zero indicates read-write; One indiciates Readonly.
• The return value
• The return value of shmat is a void *, which the process can use (type cast) as appropriae. In this example, it is being used as a character pointer. 
• Step 3: The process may access the memory using the pointer returned by shmat. For example, using sprintf
• sprintf(shared_memory, "Writing to shared memory\n");
• Step 4: When a process no longer needs a piece of shared memory, it can be detached using shmtd
• shmat(shared_memory)
• Step 5: And finally the process that originally allocated the shared memory can remove it from the system using shmctl.
• shmctl(segment_id, IPC_RMID)

Message-Passing

• Message passing systems must support at a minimum system calls for "send message" and "receive message"
• A communication link must be established between the corresponding process before message can be sent. 
• There are three key issues to be resolved in message passing systems
• Direct or indirect communication (naming)
• Synchronous or asynchronous communication
• Automatic or explicit buffering

Naming

• Direct communication
• With direct communication the sender must know the name of the receiver to which it wishes to send message
• Indirect communication
• Multiple processes can share the same mailbox or boxes.
• Only one process can read any given message in a mailbox. 
• The OS must provide system calls to create and delete mailboxes, and to send and receive messages to/from mailboxes.

Synchronization

• Either the sending or receiving of messages (or neither or both) may be either blocking or non-blocking.

Buffering

• Messages are passed via queues, which may have one or three capacity configurations
• Zero capacity
• Message cannot be stored in the queue, so senders must lock until receivers accept the messages.
• Bounded capacity
• There is a certain pre-determined finite capacity in the queue. Senders must block if the queue if full, until space becomes available in the queue, but may be either blocking or non-blocking otherwise. 
• Unbounded capacity
• The queue has a theoretical infinite capacity, so senders are never forced to block. 

Reference

[1] https://www.cs.uic.edu/~jbell/CourseNotes/OperatingSystems/3_Processes.html