在矩陣中使用共享內存

Question

我想在共享內存段中創建矩陣。在我的第二個程序中，我可以閱讀tailleX,tailleY，但我的矩陣的值只有'0'。我在功能initialiserSegMem創建我的矩陣和值確定...像往常一樣，我有一些問題，指針......

我的結構mem_share：

typedef struct mem_partage{ 
    int** carte; 
    int tailleY; 
    int tailleX; 
}mem_share; 

mem_share initialiserDonneeMem(grille* g){ 
    mem_share mem_share_carte; 
    int x = g->tailleX; 
    int y = g->tailleY; 
    int i,j; 
    mem_share_carte.carte = malloc(y*sizeof(int*)); 
    for(i=0;i < y;i++){ 
     mem_share_carte.carte[i] = malloc(x*sizeof(int)); 
    } 
    mem_share_carte.carte = g->carte; 
    mem_share_carte.tailleY = y; 
    mem_share_carte.tailleX = x; 

    return mem_share_carte; 
} 

void initialiserSegMem(mem_share *mem_share_carte){ 
    int shmid,id_memoire,i,j; 
    int test = 100; 

    int *adresse_mem; 
    key_t cle; 
    cle = 9999; 
    /* Creation of the shared memory segment */ 
    if(shmget(cle,(int) sizeof(mem_share) ,IPC_CREAT | IPC_EXCL | 0777)== -1) { 
     printf("Erreur : Segment de mémoire partagée existant"); 
    } 
    /*on attache le segment a notre espace memoire */ 
    id_memoire = shmget(cle,0,0); 
    adresse_mem = shmat(id_memoire,NULL,0); 
    /* les 2premiers int seront les tailles Y et X*/ 
    printf("tailleY %d zzzz",mem_share_carte->tailleY); 
    memcpy(adresse_mem,&mem_share_carte->tailleY,sizeof(int)); 
    adresse_mem+=sizeof(int); 
    memcpy(adresse_mem,&mem_share_carte->tailleX,sizeof(int)); 
    adresse_mem+=sizeof(int); 

    for(i=0;i<mem_share_carte->tailleY;i++){ 
     printf("\n"); 
      for(j=0;j<mem_share_carte->tailleX;j++){ 
       memcpy(adresse_mem,&(mem_share_carte->carte[i][j]),sizeof(int)); 
      adresse_mem+=sizeof(int); 
      } 
    } 
} 

在我的第二個方案，我想閱讀共同的記憶：

int shmid,tailleY,tailleX,y,x; 

int *adresse_mem; 
key_t cle; 
/* on recupere la cle du segment */ 
cle = 9999; 
if ((shmid = shmget(cle, 0, 0666)) < 0) { 
    perror("shmget"); 
    exit(1); 
    } 
/* 
    * on attache le segment a notre espace memoire 
*/ 
if ((adresse_mem = shmat(shmid, NULL, 0)) == (char *) -1) { 
    perror("shmat"); 
    exit(1); 
} 
/* 
* on lit le segment : 
* - on recupe la taille y 
* - puis la taille x 
* - puis la carte 
*/ 
memcpy(&tailleY,adresse_mem,sizeof(int)); 
adresse_mem+=sizeof(int); 
printf("tailleY %d",tailleY); 
memcpy(&tailleX,adresse_mem,sizeof(int)); 
printf("tailleX %d",tailleX); 
adresse_mem+=sizeof(int); 

int** carte; 
carte = malloc(tailleY*sizeof(int*)); 

for(y=0;y<tailleY;y++){ 
    carte[y] = malloc(tailleX*sizeof(int)); 
    for(x=0;x>tailleX;x++){ 
     memcpy(&carte[y][x],adresse_mem,sizeof(int)); 
     adresse_mem+=sizeof(int); 
    } 
} 
/* 
    affichage de la carte 
*/ 
for(y = 0;y<tailleY;y++){ 
    printf("\n"); 
    for(x = 0;x<tailleX;x++){ 
     printf("%d ",carte[y][x]); 
    } 
} 

順便說一句，在我的第一個程序，我必須在我的共享存儲器更新我的矩陣，這樣我就可以叫initialiserSegMem與我的新矩陣？

Answer 1

一個簡單的示例代碼。子系統和父系共享使用System V共享內存段的2D矢量。當數據類型改變時，sizeElement用於偏移估計。這裏使用雙。在函數返回的代碼上沒有錯誤處理。

#include <stdio.h> 
#include <unistd.h> 
#include <sys/shm.h> 
#include <sys/stat.h> 
#include <wait.h> 

unsigned int sizeof_dm(int rows, int cols, size_t sizeElement){ 
    size_t size = rows * (sizeof(void *) + (cols * sizeElement)); 
    return size; 
} 

void create_index(void **m, int rows, int cols, size_t sizeElement){ 
    int i; 
    size_t sizeRow = cols * sizeElement; 
    m[0] = m+rows; 
    for(i=1; i<rows; i++){  
     m[i] = (m[i-1]+sizeRow); 
    } 
} 

void print_matriz(double **matrix, int Rows, int Cols){ 
    printf("\n"); 
     for(int i=0; i<Rows; i++){ 
      for(int j=0; j<Cols; j++) 
       printf("%.2f\t",matrix[i][j]); 
      printf("\n"); 
     } 
} 

int main(int argc, char **argv){ 

    double **matrix; 
    int Cols = 10, Rows = 5, shmId; 

    size_t sizeMatrix = sizeof_dm(Rows,Cols,sizeof(double)); 
    shmId = shmget(IPC_PRIVATE, sizeMatrix, IPC_CREAT|0600);  
    matrix = shmat(shmId, NULL, 0); 
    create_index((void*)matrix, Rows, Cols, sizeof(double)); 


    if(fork()){ 
     int pos=0; 
     for(int i=0; i<Rows; i++){ 
      for(int j=0; j<Cols; j++) 
       matrix[i][j] = pos++; 
     }  
     wait(NULL); 
     print_matriz(matrix, Rows, Cols); //verify child's write 
     shmdt(matrix); 
     shmctl(shmId, IPC_RMID, 0); 
    } 
    else{ 
     sleep(3); //avoid race condition 
     print_matriz(matrix, Rows, Cols); 
     matrix[2][2] = -99.99; //writing test from child 
     shmdt(matrix); 
    } 
    return 0; 
}