Come si mantiene un int e un array nella memoria condivisa in C?

Question

Sto tentando di scrivere un programma in cui i processi figli comunicano tra loro su Linux.

Questi processi sono tutti creati dallo stesso programma e come tali condividono il codice.

Ho bisogno che abbiano accesso a due variabili integer e a un array intero.

Non ho idea di come funzioni la memoria condivisa e ogni risorsa che ho cercato non abbia fatto altro che confondermi.

Qualsiasi aiuto sarebbe molto apprezzato!

Modifica: Ecco un esempio di codice che ho scritto finora solo per condividere un int ma probabilmente è sbagliato.

int segmentId; 
int sharedInt; 
const int shareSize = sizeof(int); 
/* Allocate shared memory segment */ 
segmentId = shmget(IPC_PRIVATE, shareSize, S_IRUSR | S_IWUSR); 

/* attach the shared memory segment */  
sharedInt = (int) shmat(segmentId, NULL, 0); 

/* Rest of code will go here */ 

/* detach shared memory segment */ 
shmdt(sharedInt); 
/* remove shared memory segment */ 
shmctl(segmentId, IPC_RMID, NULL); 

Answer 1

È necessario aumentare la dimensione della memoria condivisa. Quanto è grande un array di cui hai bisogno? Qualunque sia il valore, è necessario selezionarlo prima di creare il segmento di memoria condivisa - la memoria dinamica non funzionerà troppo bene qui.

Quando si collega alla memoria condivisa, si ottiene un puntatore all'indirizzo iniziale. Sarà sufficientemente ben allineato per essere utilizzato per qualsiasi scopo. Quindi, è possibile creare puntatori ai due variabili e serie in questo senso (cribbing alcuni dello scheletro dal tuo esempio di codice) - Si noti l'uso di puntatori per accedere alla memoria condivisa:

enum { ARRAY_SIZE = 1024 * 1024 }; 
int segmentId; 
int *sharedInt1; 
int *sharedInt2; 
int *sharedArry; 

const int shareSize = sizeof(int) * (2 + ARRAY_SIZE); 
/* Allocate shared memory segment */ 
segmentId = shmget(IPC_PRIVATE, shareSize, S_IRUSR | S_IWUSR); 

/* attach the shared memory segment */  
sharedInt1 = (int *) shmat(segmentId, NULL, 0); 
sharedInt2 = sharedInt1 + 1; 
sharedArry = sharedInt1 + 2; 

/* Rest of code will go here */ 
...fork your child processes... 
...the children can use the three pointers to shared memory... 
...worry about synchronization... 
...you may need to use semaphores too - but they *are* complex... 
...Note that pthreads and mutexes are no help with independent processes... 

/* detach shared memory segment */ 
shmdt(sharedInt1); 
/* remove shared memory segment */ 
shmctl(segmentId, IPC_RMID, NULL); 

Answer 2

Questa guida sembra utile: http://www.cs.cf.ac.uk/Dave/C/node27.html. Include alcuni programmi di esempio.

Ci sono anche Linux man pages online.

Answer 3

La memoria condivisa è solo un segmento di memoria assegnato da un processo, con un ID univoco, e l'altro processo farà anche l'allocazione, con lo stesso id, e la dimensione della memoria è la dimensione della struttura che stanno usando, quindi avresti una struttura con 2 numeri interi e un array intero.

Ora entrambi hanno un puntatore alla stessa memoria, quindi le scritture di una sovrascriveranno qualsiasi altra cosa c'era e l'altra avrà accesso immediato ad essa.

Answer 4

Dal tuo commento sembra che tu stia usando IPC_PRIVATE, e che sicuramente sembra sbagliato (i tipi "privati" suggeriscono che non è pensato per la condivisione, no? -). Prova qualcosa del tipo:

#include <sys/ipc.h> 
#include <sys/shm.h> 

... 

int segid = shmget((key_t)0x0BADDOOD, shareSize, IPC_CREAT); 
if (segid < 0) { /* insert error processing here! */ } 
int *p = (int*) shmat(segid, 0, 0); 
if (!p) { /* insert error processing here! */ }