进程间通信之数据共享--共享内存

偏执的太偏执、 2021-11-23 03:44 416阅读 0赞

# Shared Memory #

--------------------

Shared memory is a memory shared between two or more processes. However, why do we need to share memory or some other means of communication?

To reiterate, each process has its own address space, if any process wants to communicate with some information from its own address space to other processes, then it is only possible with IPC (inter process communication) techniques. As we are already aware, communication can be between related or unrelated processes.

Usually, inter-related process communication is performed using Pipes or Named Pipes. Unrelated processes (say one process running in one terminal and another process in another terminal) communication can be performed using Named Pipes or through popular IPC techniques of Shared Memory and Message Queues.

We have seen the IPC techniques of Pipes and Named pipes and now it is time to know the remaining IPC techniques viz., Shared Memory, Message Queues, Semaphores, Signals, and Memory Mapping.

In this chapter, we will know all about shared memory.

![Shared Memory][]

We know that to communicate between two or more processes, we use shared memory but before using the shared memory what needs to be done with the system calls, let us see this −

*  Create the shared memory segment or use an already created shared memory segment (shmget())
 *  Attach the process to the already created shared memory segment (shmat())
 *  Detach the process from the already attached shared memory segment (shmdt())
 *  Control operations on the shared memory segment (shmctl())

Let us look at a few details of the system calls related to shared memory.

#include <sys/ipc.h> #include <sys/shm.h> int shmget(key_t key, size_t size, int shmflg)

The above system call creates or allocates a System V shared memory segment. The arguments that need to be passed are as follows −

The first argument, key, recognizes the shared memory segment. The key can be either an arbitrary value or one that can be derived from the library function ftok(). The key can also be IPC\_PRIVATE, means, running processes as server and client (parent and child relationship) i.e., inter-related process communiation. If the client wants to use shared memory with this key, then it must be a child process of the server. Also, the child process needs to be created after the parent has obtained a shared memory.

The second argument, size, is the size of the shared memory segment rounded to multiple of PAGE\_SIZE.

The third argument, shmflg, specifies the required shared memory flag/s such as IPC\_CREAT (creating new segment) or IPC\_EXCL (Used with IPC\_CREAT to create new segment and the call fails, if the segment already exists). Need to pass the permissions as well.

Note − Refer earlier sections for details on permissions.

This call would return a valid shared memory identifier (used for further calls of shared memory) on success and -1 in case of failure. To know the cause of failure, check with errno variable or perror() function.

#include <sys/types.h> #include <sys/shm.h> void * shmat(int shmid, const void *shmaddr, int shmflg)

The above system call performs shared memory operation for System V shared memory segment i.e., attaching a shared memory segment to the address space of the calling process. The arguments that need to be passed are as follows −

The first argument, shmid, is the identifier of the shared memory segment. This id is the shared memory identifier, which is the return value of shmget() system call.

The second argument, shmaddr, is to specify the attaching address. If shmaddr is NULL, the system by default chooses the suitable address to attach the segment. If shmaddr is not NULL and SHM\_RND is specified in shmflg, the attach is equal to the address of the nearest multiple of SHMLBA (Lower Boundary Address). Otherwise, shmaddr must be a page aligned address at which the shared memory attachment occurs/starts.

The third argument, shmflg, specifies the required shared memory flag/s such as SHM\_RND (rounding off address to SHMLBA) or SHM\_EXEC (allows the contents of segment to be executed) or SHM\_RDONLY (attaches the segment for read-only purpose, by default it is read-write) or SHM\_REMAP (replaces the existing mapping in the range specified by shmaddr and continuing till the end of segment).

This call would return the address of attached shared memory segment on success and -1 in case of failure. To know the cause of failure, check with errno variable or perror() function.

#include <sys/types.h> #include <sys/shm.h> int shmdt(const void *shmaddr)

The above system call performs shared memory operation for System V shared memory segment of detaching the shared memory segment from the address space of the calling process. The argument that needs to be passed is −

The argument, shmaddr, is the address of shared memory segment to be detached. The to-be-detached segment must be the address returned by the shmat() system call.

This call would return 0 on success and -1 in case of failure. To know the cause of failure, check with errno variable or perror() function.

#include <sys/ipc.h> #include <sys/shm.h> int shmctl(int shmid, int cmd, struct shmid_ds *buf)

The above system call performs control operation for a System V shared memory segment. The following arguments needs to be passed −

The first argument, shmid, is the identifier of the shared memory segment. This id is the shared memory identifier, which is the return value of shmget() system call.

The second argument, cmd, is the command to perform the required control operation on the shared memory segment.

Valid values for cmd are −

*  IPC\_STAT − Copies the information of the current values of each member of struct shmid\_ds to the passed structure pointed by buf. This command requires read permission to the shared memory segment.
 *  IPC\_SET − Sets the user ID, group ID of the owner, permissions, etc. pointed to by structure buf.
 *  IPC\_RMID − Marks the segment to be destroyed. The segment is destroyed only after the last process has detached it.
 *  IPC\_INFO − Returns the information about the shared memory limits and parameters in the structure pointed by buf.
 *  SHM\_INFO − Returns a shm\_info structure containing information about the consumed system resources by the shared memory.

The third argument, buf, is a pointer to the shared memory structure named struct shmid\_ds. The values of this structure would be used for either set or get as per cmd.

This call returns the value depending upon the passed command. Upon success of IPC\_INFO and SHM\_INFO or SHM\_STAT returns the index or identifier of the shared memory segment or 0 for other operations and -1 in case of failure. To know the cause of failure, check with errno variable or perror() function.

Let us consider the following sample program.

*  Create two processes, one is for writing into the shared memory (shm\_write.c) and another is for reading from the shared memory (shm\_read.c)
 *  The program performs writing into the shared memory by write process (shm\_write.c) and reading from the shared memory by reading process (shm\_read.c)
 *  In the shared memory, the writing process, creates a shared memory of size 1K (and flags) and attaches the shared memory
 *  The write process writes 5 times the Alphabets from ‘A’ to ‘E’ each of 1023 bytes into the shared memory. Last byte signifies the end of buffer
 *  Read process would read from the shared memory and write to the standard output
 *  Reading and writing process actions are performed simultaneously
 *  After completion of writing, the write process updates to indicate completion of writing into the shared memory (with complete variable in struct shmseg)
 *  Reading process performs reading from the shared memory and displays on the output until it gets indication of write process completion (complete variable in struct shmseg)
 *  Performs reading and writing process for a few times for simplication and also in order to avoid infinite loops and complicating the program

Following is the code for write process (Writing into Shared Memory – File: shm\_write.c)

1 /* Filename: shm_write.c */
     2 #include<stdio.h>
     3 #include<sys/ipc.h>
     4 #include<sys/shm.h>
     5 #include<sys/types.h>
     6 #include<string.h>
     7 #include<errno.h>
     8 #include<stdlib.h>
     9 #include<unistd.h>
    10 #include<string.h>
    11 
    12 #define BUF_SIZE 1024
    13 #define SHM_KEY 0x1234
    14 
    15 struct shmseg {
    16    int cnt;
    17    int complete;
    18    char buf[BUF_SIZE];
    19 };
    20 int fill_buffer(char * bufptr, int size);
    21 
    22 int main(int argc, char *argv[]) {
    23    int shmid, numtimes;
    24    struct shmseg *shmp;
    25    char *bufptr;
    26    int spaceavailable;
    27    shmid = shmget(SHM_KEY, sizeof(struct shmseg), 0644|IPC_CREAT);
    28    if (shmid == -1) {
    29       perror("Shared memory");
    30       return 1;
    31    }
    32    
    33    // Attach to the segment to get a pointer to it.
    34    shmp = shmat(shmid, NULL, 0);
    35    if (shmp == (void *) -1) {
    36       perror("Shared memory attach");
    37       return 1;
    38    }
    39    
    40    /* Transfer blocks of data from buffer to shared memory */
    41    bufptr = shmp->buf;
    42    spaceavailable = BUF_SIZE;
    43    for (numtimes = 0; numtimes < 5; numtimes++) {
    44       shmp->cnt = fill_buffer(bufptr, spaceavailable);
    45       shmp->complete = 0;
    46       printf("Writing Process: Shared Memory Write: Wrote %d bytes\n", shmp->cnt);
    47       bufptr = shmp->buf;
    48       spaceavailable = BUF_SIZE;
    49       sleep(3);
    50    }
    51    printf("Writing Process: Wrote %d times\n", numtimes);
    52    shmp->complete = 1;
    53 
    54    if (shmdt(shmp) == -1) {
    55       perror("shmdt");
    56       return 1;
    57    }
    58 
    59    if (shmctl(shmid, IPC_RMID, 0) == -1) {
    60       perror("shmctl");
    61       return 1;
    62    }
    63    printf("Writing Process: Complete\n");
    64    return 0;
    65 }
    66 
    67 int fill_buffer(char * bufptr, int size) {
    68    static char ch = 'A';
    69    int filled_count;
    70    
    71    //printf("size is %d\n", size);
    72    memset(bufptr, ch, size - 1);
    73    bufptr[size-1] = '\0';
    74    if (ch > 122)
    75    ch = 65;
    76    if ( (ch >= 65) && (ch <= 122) ) {
    77       if ( (ch >= 91) && (ch <= 96) ) {
    78          ch = 65;
    79       }
    80    }
    81    filled_count = strlen(bufptr);
    82    
    83    //printf("buffer count is: %d\n", filled_count);
    84    //printf("buffer filled is:%s\n", bufptr);
    85    ch++;
    86    return filled_count;
    87 }

## Compilation and Execution Steps ##

Writing Process: Shared Memory Write: Wrote 1023 bytes
    Writing Process: Shared Memory Write: Wrote 1023 bytes
    Writing Process: Shared Memory Write: Wrote 1023 bytes
    Writing Process: Shared Memory Write: Wrote 1023 bytes
    Writing Process: Shared Memory Write: Wrote 1023 bytes
    Writing Process: Wrote 5 times
    Writing Process: Complete

Following is the code for read process (Reading from the Shared Memory and writing to the standard output – File: shm\_read.c)

1 /* Filename: shm_read.c */
     2 #include<stdio.h>
     3 #include<sys/ipc.h>
     4 #include<sys/shm.h>
     5 #include<sys/types.h>
     6 #include<string.h>
     7 #include<errno.h>
     8 #include<stdlib.h>
     9 
    10 #define BUF_SIZE 1024
    11 #define SHM_KEY 0x1234
    12 
    13 struct shmseg {
    14    int cnt;
    15    int complete;
    16    char buf[BUF_SIZE];
    17 };
    18 
    19 int main(int argc, char *argv[]) {
    20    int shmid;
    21    struct shmseg *shmp;
    22    shmid = shmget(SHM_KEY, sizeof(struct shmseg), 0644|IPC_CREAT);
    23    if (shmid == -1) {
    24       perror("Shared memory");
    25       return 1;
    26    }
    27    
    28    // Attach to the segment to get a pointer to it.
    29    shmp = shmat(shmid, NULL, 0);
    30    if (shmp == (void *) -1) {
    31       perror("Shared memory attach");
    32       return 1;
    33    }
    34    
    35    /* Transfer blocks of data from shared memory to stdout*/
    36    while (shmp->complete != 1) {
    37       printf("segment contains : \n\"%s\"\n", shmp->buf);
    38       if (shmp->cnt == -1) {
    39          perror("read");
    40          return 1;
    41       }
    42       printf("Reading Process: Shared Memory: Read %d bytes\n", shmp->cnt);
    43       sleep(3);
    44    }
    45    printf("Reading Process: Reading Done, Detaching Shared Memory\n");
    46    if (shmdt(shmp) == -1) {
    47       perror("shmdt");
    48       return 1;
    49    }
    50    printf("Reading Process: Complete\n");
    51    return 0;
    52 }

转载于:https://www.cnblogs.com/miaoxiong/p/11077598.html

[Shared Memory]: /images/20211122/a72283d142b746f9a996c76bad61bef2.png