Inter-process communication-shared memory

Inter-process communication-shared memory

We are familiar with inter-process communication methods, such as pipelines (named pipelines), signals (signal), shared memory, message queues, sockets (sockets ), semaphores are classified as inter-process synchronization mechanisms.
Next we will talk about the communication mode of shared memory. It is the fastest in IPC. Once the memory zone is mapped to the address space of the process that shares it, data transmission between these processes does not involve the kernel. However, data must be synchronized during access. the authoritative reference for shared memory is unix Network Programming Volume 2. we have explained the mmap Kernel Mechanism in the previous sections. This is the way posix v shares memory. System v is similar, but the interface is encapsulated.
Let's start with the posix v method. Its common function interfaces are as follows:
Open/shm_open + mmap, munmap, msync, shm_unlink, etc.
Since the file is open, not all files can be mapped. The Supported file types are as follows:
1. Common Disk Files
2. Device Files (except some special files)
3. memory files (such as tmpfs)
4. Anonymous ing (mainly used between unrelated processes)
First, let's talk about the commonly used anonymous ing. open/dev/zero ensures that all the ing areas are initialized to an anonymous ing of 0. You can also use mmap to map objects without opening any files:

 
 

  
  
mmap( NULL,size_of_map,PROT_READ|PROT_WRITE,MAP_SHARED | MAP_ANON, -1,0 );
 
 

The following figure shows the mmap function prototype:

 
 

  
  
void* mmap(void* start,size_t length,int prot,int flags,int fd,off_t offset);
 
 

The main difference between anonymous ing is that a MAP_ANON flag is added to flags, which is-1 passed by fd. For more mmap information, please query it by yourself.
Note the following when using mmap to share memory:
The size of the mapped memory area and file size. The size of the memory ing is an integer multiple of the page (PAGESIZE 4096 by default). For example, if the file size is 5000, It is mapped to 5000, therefore, you can access the memory area of 2 * PAGESIZE, but memory writes greater than 5000 are not synchronized to the file. The size of the accessible memory is also related to the file size. During the ing, the system automatically checks the underlying support, that is, the file size. however, we know that the advantage of mmap is that the file size can be dynamically changed. The function interfaces are ftruncate and fstat. for detailed usage, refer to unix Network Programming Volume 2.

The following briefly summarizes its features:
1. You can change the size at any time.
Operation Function interfaces: ftruncate and fstat
2. you must first create and open a file, which can be a disk file or a memory file, such as a file under tmpfs. If the shared memory configuration needs to be written to the disk, you can choose to open the disk file. If a flash file is used as a ing in the embedded system, shm is recommended since frequent file operations and disk read/write are required. After all, frequent flash reads and writes may affect the lifetime and lead to bad blocks.

System v does not require explicit open files, but there are many function operation interfaces.
Function interfaces: shmget, shmat, shmdt, and shmctl.
There are some restrictions on the shm method:
Shmax the maximum number of bytes in a shared memory area (the specific system is not the same)
Shmmnb the minimum number of bytes in a shared memory zone 1
The shmmni system has a maximum of 128 shared memory zone identifiers.
Shmseg the maximum number of shared memory zones attached to each process is 32.
This information can be viewed through the proc file system. Cat/proc/sys/kernel/shmmax and so on. You can view and operate the mapped memory zone using the ipcs command.

We also summarize its features:
1. No need to create or open a file
2. For multi-process communication, a key is required. Dynamic generation is not necessarily consistent.
3. The read/write speed is higher than that of mmap.
4. the shared memory space cannot be too large. After all, it directly occupies the memory space.
Either method involves communication between multiple processes and data interaction, so mutual exclusion and synchronization must be maintained. The most common method here is the semaphore method.
Semaphores: sem_init, sem_wait, and sem_post. Because semaphores are used for compilation, the thread library-lpthread needs to be linked.
The following code examples show their specific usage:
Posix v mode:
1. initialize the program, and write the program cyclically without interruption. The period is 1 s.

 
 

  
  
#include  
 
  
  
#include  
 
  
  
#include  
 
  
  
#include  
 
  
  
#include  
 
  
  


  
  


  
  
#define CLUSTER_SHARED_FILE "/tmp/cluster_share"

  
  


  
  
typedef struct{ 

  
  
char name[4]; 

  
  
int age; 

  
  
}people; 

  
  


  
  
struct stu {

  
  


  
  
sem_t mutex;

  
  
people s[10];

  
  


  
  
};

  
  


  
  
struct stu t;

  
  


  
  
main(int argc, char** argv) // map a normal file as shared mem: 

  
  
{ 

  
  
int fd,i; 

  
  
struct stu *p_map; 

  
  
char temp; 

  
  


  
  
fd=open(CLUSTER_SHARED_FILE,O_CREAT|O_RDWR|O_TRUNC,00777); 

  
  
lseek(fd,sizeof(t)-1,SEEK_SET); 

  
  
write(fd,"",1); 

  
  


  
  
p_map = (struct stu *) mmap( NULL,sizeof(t),PROT_READ|PROT_WRITE,MAP_SHARED,fd,0 ); 

  
  
close(fd); 

  
  
temp = 'a';

  
  
sem_init(&p_map->mutex,1,1);

  
  
int j=0;

  
  
while(1)

  
  
{

  
  
j++;

  
  
 printf("j 1\n");

  
  
 sem_wait(&p_map->mutex);

  
  
 printf("j 2\n");

  
  
for(i=1; i<10; i++) 

  
  
{ 

  
  
// temp += 1; 

  
  
 

  
  
memcpy(p_map->s[i].name, &temp,2 ); 

  
  
p_map->s[i].age = p_map->s[i].age +20+i+j; 

  
  
} 

  
  
printf("j 3\n");

  
  
sem_post(&p_map->mutex);

  
  
printf("j 4\n");

  
  
 sleep(1);

  
  
}

  
  
printf(" initialize over \n "); 

  
  
sleep(50); 

  
  
munmap( p_map, sizeof(t) ); 

  
  
printf( "umap ok \n" ); 

  
  
}
 
 

2. Read operation:

 
 

  
  
#include  
 
  
  
#include  
 
  
  
#include  
 
  
  
#include  
 
  
  


  
  
#include  
 
  
  


  
  
#include  
 
  
  


  
  
#define CLUSTER_SHARED_FILE "/tmp/cluster_share"

  
  


  
  
typedef struct{ 

  
  
char name[4]; 

  
  
int age; 

  
  
}people; 

  
  


  
  
struct stu {

  
  


  
  
sem_t mutex;

  
  
people s[10];

  
  
};

  
  


  
  
struct stu t;

  
  


  
  
main(int argc, char** argv) // map a normal file as shared mem: 

  
  
{ 

  
  
int fd,i; 

  
  
struct stu *p_map; 

  
  
char temp; 

  
  


  
  
fd=open(CLUSTER_SHARED_FILE,O_CREAT|O_RDWR,00777); 

  
  
// lseek(fd,sizeof(people)*5-1,SEEK_SET); 

  
  
// write(fd,"",1); 

  
  


  
  
p_map = (struct stu *) mmap( NULL,sizeof(t),PROT_READ|PROT_WRITE,MAP_SHARED,fd,0 ); 

  
  
 close( fd ); 

  
  


  
  
 while(1)

  
  
{

  
  
sleep(1);

  
  
printf("2.....s\n");

  
  
sem_wait(&p_map->mutex);

  
  
printf("2.....\n");

  
  
for(i=0; i<10; i++) 

  
  
{ 

  
  
printf("name:%s,age:%d\n",p_map->s[i].name,p_map->s[i].age); 

  
  


  
  
} 

  
  
printf("2.....0\n");

  
  
sem_post(&p_map->mutex);

  
  
printf("2.......1");

  
  
}

  
  
munmap( p_map, sizeof(t)); 

  
  
printf( "umap ok \n" ); 

  
  
}
 
 

As for the write operation, the program can be tested with a slight modification. There is no problem with multiple concurrency.
System V method, although the interface is not the same, but also very similar.
1. Initialization

 
 

  
  
# Include  
 
  
  
# Include  
 
  
  
# Include  
 
  
  
# Include  
 
  
  
# Include  
 
  
  
# Include  
 
  
  


  
  
// # Include "shmdata. h"

  
  


  
  


  
  


  
  


  
  
# Define TEXT_SZ 2048

  
  


  
  
Struct shared_use_st

  
  
{

  
  
Sem_t mutex;

  
  
Int written; // as a flag, non-0: Indicates readable, 0 indicates writable

  
  
Char text [TEXT_SZ]; // record the text written and read

  
  
Int cnt;

  
  
};

  
  


  
  


  
  
Int main ()

  
  
{

  
  
Int running = 1;

  
  
Void * shm = NULL;

  
  
Struct shared_use_st * shared = NULL;

  
  
Char buffer [4096] = "hello world ";

  
  
Int shmid;

  
  
Int I = 0;

  
  
// Create shared memory

  
  
# If 0

  
  
// Delete shared memory

  
  
If (shmctl (shmid, IPC_RMID, 0) =-1)

  
  
{

  
  
Fprintf (stderr, "shmctl (IPC_RMID) failed \ n ");

  
  
Exit (EXIT_FAILURE );

  
  
}

  
  
# Endif

  
  
Shmid = shmget (key_t) 12345, sizeof (struct shared_use_st), 0666 | IPC_CREAT );

  
  
If (shmid =-1)

  
  
{

  
  
Fprintf (stderr, "shmget failed \ n ");

  
  
Exit (EXIT_FAILURE );

  
  
}

  
  
// Connect the shared memory to the address space of the current process

  
  
Shm = shmat (shmid, (void *) 0, 0 );

  
  
If (shm = (void *)-1)

  
  
{

  
  
Fprintf (stderr, "shmat failed \ n ");

  
  
Exit (EXIT_FAILURE );

  
  
}

  
  
Printf ("Memory attached at % X \ n", (int) shm );

  
  
// Set the shared memory

  
  
Shared = (struct shared_use_st *) shm;

  
  
Sem_init (& shared-> mutex, 1, 1 );

  
  


  
  
While (running) // write data to the shared memory

  
  
{

  
  
Strncpy (shared-> text, buffer, TEXT_SZ );

  
  


  
  
Sem_wait (& shared-> mutex );

  
  
// Shared-> cnt = 0;

  
  
Shared-> cnt = shared-> cnt + I;

  
  
Sem_post (& shared-> mutex );

  
  
I ++;

  
  
Shared-> written = 1;

  
  


  
  
Sleep (1 );

  
  
}

  
  
// Detach the shared memory from the current process

  
  
If (shmdt (shm) =-1)

  
  
{

  
  
Fprintf (stderr, "shmdt failed \ n ");

  
  
Exit (EXIT_FAILURE );

  
  
}

  
  
Sleep (2 );

  
  
Exit (EXIT_SUCCESS );

  
  
}
 
 

2. Read operations

 
 

  
  
# Include  
 
  
  
# Include  
 
  
  
# Include  
 
  
  
# Include  
 
  
  
// # Include "shmdata. h"

  
  
# Include  
 
  
  


  
  


  
  


  
  


  
  
# Define TEXT_SZ 2048

  
  


  
  
Struct shared_use_st

  
  
{

  
  
Sem_t mutex;

  
  
Int written; // as a flag, non-0: Indicates readable, 0 indicates writable

  
  
Char text [TEXT_SZ]; // record the text written and read

  
  
Int cnt;

  
  
};

  
  


  
  
Int main ()

  
  
{

  
  
Int running = 1; // indicates whether the program continues to run.

  
  
Void * shm = NULL; // original first address of the allocated shared memory

  
  
Struct shared_use_st * shared; // point to shm

  
  
Int shmid; // shared memory identifier

  
  
// Create shared memory

  
  
Shmid = shmget (key_t) 12345, sizeof (struct shared_use_st), 0666 );

  
  
If (shmid =-1)

  
  
{

  
  
Fprintf (stderr, "shmget failed \ n ");

  
  
Exit (EXIT_FAILURE );

  
  
}

  
  
// Connect the shared memory to the address space of the current process

  
  
Shm = shmat (shmid, 0, 0 );

  
  
If (shm = (void *)-1)

  
  
{

  
  
Fprintf (stderr, "shmat failed \ n ");

  
  
Exit (EXIT_FAILURE );

  
  
}

  
  
Printf ("\ nMemory attached at % X \ n", (int) shm );

  
  
// Set the shared memory

  
  
Shared = (struct shared_use_st *) shm;

  
  
// Shared-> written = 0;

  
  
While (running) // read data in the shared memory

  
  
{

  
  


  
  
Sem_wait (& shared-> mutex );

  
  
Printf ("text: % s, cnt: % d \ n", shared-> text, shared-> cnt );

  
  
Sem_post (& shared-> mutex );

  
  
Sleep (1 );

  
  


  
  


  
  
}

  
  
// Detach the shared memory from the current process

  
  
If (shmdt (shm) =-1)

  
  
{

  
  
Fprintf (stderr, "shmdt failed \ n ");

  
  
Exit (EXIT_FAILURE );

  
  
}

  
  
# If 0

  
  
// Delete shared memory

  
  
If (shmctl (shmid, IPC_RMID, 0) =-1)

  
  
{

  
  
Fprintf (stderr, "shmctl (IPC_RMID) failed \ n ");

  
  
Exit (EXIT_FAILURE );

  
  
}

  
  
# Endif

  
  
Exit (EXIT_SUCCESS );

  
  
}
 
 

The overall usage is relatively simple and efficient.