Shared Memory

 

Shared memory is memory that may be simultaneously accessed by multiple programs with an intent to provide communication among  them or avoid redundant copies.

Shared memory is extensively used for inter process communication (IPC), i.e. a way of exchanging data between two programs running at the same time.One process creates an area in RAM which other processes can access.

Shared memory is the fastest form of IPC since data does not need to be copied between communication processes Often, semaphores are used to synchronize shared memory access.

Shared memory machines have been classified as UMA and NUMA, based upon memory access times.

Shared Memory (UMA)

                               

Shared Memory (NUMA)

         

          

Shared Memory is an efficient means of passing data between programs. One program will create a memory portion, which other processes (if permitted) can access. A shared memory segment is described by a control structure with a unique ID that points to an area of physical memory

Shared memory is a feature supported by UNIX System V, including Linux, SunOS and Solaris. One process must explicitly ask for an area, using a key, to be shared by other processes. This process will be called the server. All other processes, the clients that know the shared area can access it.

A shared memory segment is identified by a unique integer, the shared memory ID.

A process creates a shared memory segment using shmget()|. The original owner of a shared memory segment can assign ownership to another user with shmctl(). It can also revoke this assignment. Other processes with proper permission can perform various control functions on the shared memory segment using shmctl(). Once created, a shared segment can be attached to a process address space using shmat(). It can be detached using shmdt() (see shmop()). The attaching process must have the appropriate permissions for shmat(). Once attached, the process can read or write to the segment, as allowed by the permission requested in the attach operation. A shared segment can be attached multiple times by the same process. A shared memory segment is described by a control structure with a unique ID that points to an area of physical memory. The identifier of the segment is called the shmid. The structure definition for the shared memory segment control structures and prototypes can be found in <sys/shm.h>.

Parallel tasks share a global address space which they read and write to asynchronously, which requires protection mechanisms such as locks, semaphores and monitors to control concurrent access.

Advantages:

• Global address space provides a user-friendly programming perspective to memory

• Data sharing between tasks is both fast and uniform due to the proximity of memory to CPUs

Disadvantages:

• Primary disadvantage is the lack of scalability between memory and CPUs. Adding more CPUs can geometrically increases traffic on the shared memory-CPU path, and for cache coherent systems, geometrically increase traffic associated with cache/memory management.

• Programmer responsibility for synchronization constructs that ensure "correct" access of global memory.

• Expense: it becomes increasingly difficult and expensive to design and produce shared memory machines with ever increasing numbers of processors.

IPC using Shared Memory

http://faculty.kfupm.edu.sa/ics/garout/Teaching/ICS431/Lab14.pdf

http://www.cs.cf.ac.uk/Dave/C/node27.html

Shared and distributed memory

http://www.slideshare.net/MrSMAk/lecture-6-12062242

Programming with Shared Memory

http://www.cs.nthu.edu.tw/~ychung/slides/para_programming/slides8.  

Programs available at the following links

https://publib.boulder.ibm.com/infocenter/iseries/v5r3/index.jsp?topic=%2Fapis%2Fapiexusmem.htm

http://www.kohala.com/start/unpv22e/unpv22e.chap12.pdf

Message Passing Model

          

         This model demonstrates the following characteristics:

• A set of tasks that use their own local memory during computation. Multiple tasks can reside on the same physical machine and/or across an arbitrary number of machines.

• Tasks exchange data through communications by sending and receiving messages.

• Data transfer usually requires cooperative operations to be performed by each process. For example, a send operation must have a matching receive operation.

Implementations:

• From a programming perspective, message passing implementations usually comprise a library of subroutines. Calls to these subroutines are embedded in source code. The programmer is responsible for determining all parallelism.

Since interactions are accomplished by sending and

receiving messages, the basic operations in the

message-passing programming paradigm are send and

receive.

• In their simplest form, the prototypes of these operations are defined as follows:

• send(void *sendbuf, int nelems, int dest)

• receive(void *recvbuf, int nelems, int source)

sendbuf points to a buffer that stores the data to be sent,

• recvbuf points to a buffer that stores the data to be received,

• nelems is the number of data units to be sent and received,

• dest is the identifier of the process that receives the data,

• source is the identifier of the process that sends the data.

Message Passing Interface (MPI)

https://computing.llnl.gov/tutorials/mpi/

Comparison of message passing and shared memory  http://www.dauniv.ac.in/downloads/CArch_PPTs/CompArchCh12L12MsgPassingSharing.pdf

References:

http://en.wikipedia.org/wiki/Shared_memory

https://computing.llnl.gov/tutorials/parallel_comp/

http://siber.cankaya.edu.tr/ParallelComputing/week4/week4p.pdf

Submitted by

Somil Srivastava 341/CO/11

Sonam Kumari 343/CO/11