Discussion :

[evilynux]

Mise en contexte:
- J'utilise la mémoire partagé (POSIX) pour partager de l'information entre un producteur et un consommateur.
- À l'initialisation je cré mes shm avec les flags "O_RDWR | O_CREAT | O_EXCL".
- À chaque ouverture subséquente, O_CREAT et O_EXCL ne sont pas utilisés.
- À chaque lecture/écriture 1) j'ouvre la mémoire partagée (shm_open), 2) je fait un mmap(), j'unmap (munmap) et je ferme la mémoire partagé (close).

Après avoir remarqué que la consommation mémoire ne cessait d'augmenter, j'ai cherché le problème. Si je comprends bien, à chaque nouveau shm_open, un nouvel emplacement mémoire est ajouté au bout.

Après avoir fouillé pendant des heures et essayé plein d'affaires... une idée m'est venu en tête: et si c'était à ça que servait O_TRUNC? Après avoir essayé, je constate que non...

Alors je suis désespéré... qu'est-ce qui cause mon erreur d'allocation mémoire...?
L'erreur est: mmap: Cannot allocate memory
(Le start est NULL et le size est 11).

Toute piste pour m'aider sera bien apprécié.
Il me fera un plaisir de fournir mon code en cas de besoin.

Voici des morceaux de mon code qui pourraient vous aider à m'aider...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
 
/* mmap with error checking */
char* Mmap(void *start, size_t length, int prot , int flags, int fd, off_t offset)
{
  char* h = (char*)mmap(start, length, prot, flags, fd, offset);
 
  if( h == MAP_FAILED ) {
    perror("mmap");
    printf("mmap: start=%d, length=%d\n", (int)start, length);
  }
 
  return h;
}
 
/* Un-memorymap */
void Munmap(void *start, size_t length)
{
  if( munmap(start, length) < 0 ) perror("munmap");
}
 
/* Création des shm */
void shmcreate(char* name, int flags, int length)
{
  char* ptr;
  int fd = Shm_open(name, flags, FILE_MODE);
  Ftruncate(fd, length);
  ptr = Mmap( NULL, length, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0 );
  memset((void *)ptr, 0, length);
  /* Unmemory map shared memory */
  Munmap(NULL, length);
  Close(fd);
}
 
/* Écriture en shm */
void shmwrite(char* name, vector<unsigned char> &data)
{
  int fd;
  unsigned int i;
  struct stat stat;
  char *ptr;
 
  /* open, get size, map */
  fd = Shm_open(name, O_RDWR, FILE_MODE);
  Fstat(fd, &stat);
  ptr = Mmap( NULL, stat.st_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0 );
 
  if( (unsigned int)stat.st_size < data.size() )
    fprintf( stderr , "Warning: shmsize < vectorsize!\n");
 
  // attn: shm size must be >= data.size()
  for( i = 0; i < data.size(); i++ ) {
    *ptr++ = data[i];
  }
 
  /* Unmemory map shared memory */
  Munmap(NULL, stat.st_size);
  Close(fd);
}
 
/* Lecture de la shm */
void shmread(char* name, vector<unsigned char>& data)
{
  int i, fd;
  struct stat stat;
  char *ptr;
 
  /* open, get size, map */
  fd = Shm_open(name, O_RDONLY, FILE_MODE);
  Fstat(fd, &stat);
  ptr = Mmap( NULL, stat.st_size, PROT_READ, MAP_SHARED, fd, 0 );
 
  for( i = 0; i < stat.st_size; i++ ) {
    data[i] = *ptr++;
  }
 
  /* Unmemory map shared memory */
  Munmap(NULL, stat.st_size);
  Close(fd);
}

[evilynux]

J'ai trouvé!!

Faut pas faire un shm_open/mmap à chaque fois qu'on veut faire des lectures/écritures => C'est MAL!!
Faut faire le shm_open/mmap UNE FOIS et traîner le pointeur mémoire avec nous.