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 memoryn”);
- 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