Discussion :

[qouify]

salut à tous,
la mémoire allouée à mon programme semble exploser alors que, théoriquement, elle devrait être bornée (et raisonnable).
après pas mal de tests et un petit coup de valgrind dessus qui ne me rapporte pas de fuite mémoire je commence a saturer.
est ce que ca pourrait venir de pointeurs sur des fichiers. je m'explique : j'ai un millier de fichiers ouverts en permanence en mode "a+", et ces fichiers peuvent faire jusqu'à une 10 mega chacun.
pensez vous que ca pourrait venir de la?

merci

[droggo]

Jio,

Un millier de fichiers ouverts en permanence, ça me paraît bien excessif.

[souviron34]

de plus il existe une limite système au nombre de fichier ouverts en permanence, sans oublier une limite soft (en général de l'ordre de 1024).

Si tu es sur linux, voici des FAQ :

http://kbase.redhat.com/faq/FAQ_80_1540.shtm

http://www.cyberciti.biz/faq/linux-i...of-open-files/

http://www.x-tend.be/~stijn/blog/?p=3

[muad'dib]

Jio,

Un millier de fichiers ouverts en permanence, ça me paraît bien excessif.

+1

Tu comptes ~ 1000 fichiers à ~ 10 mo chacun = ~ 10 000 mo = ~ 10 Go en mémoire !!!

PS: droggo, ça veut dire quoi Jio ?

[souviron34]

Tu comptes ~ 1000 fichiers à ~ 10 mo chacun = ~ 10 000 mo = ~ 10 Go en mémoire !!!

Attention.. Il n'a pas dit qu'il les mettait en mémoire... Juste qu'il les ouvrait...

[droggo]

Sia,

PS: droggo, ça veut dire quoi Jio ?

Absolument rien de spécial.

J'ai simplement l'habitude d'écrire un petit mot de 3 lettres au début de chaque message, quasiment toujours 1 consonne + 2 voyelles, lettres variables en fonction de l'humeur du moment, le tout pour dire "bonjour".

[muad'dib]

le tout pour dire "bonjour".

Ok, et pour faire parler les curieux comme moi

[qouify]

merci pour vos réponses.
mais pensez vous qu'une structure de type FILE puisse occuper bcp de mémoire?
j'imagine que des fonctions fread ou fwrite bufferisent les données afin d'optimiser les accès disque alors je me demande si de nombreux pointeurs FILE ouvert sur des gros fichier ne pourrait pas expliquer la mémoire importante consommée par mon prog.

[odsen.s]

De toutes façons, tu ne déclares pas des FILE mais des pointeurs sur FILE.
Chez moi :
FILE : 32 bytes
FILE* : 4 bytes

Mais comme on t'a dit plus haut, il existe des limites de fichiers ouverts à la fois (cf les liens).

[qouify]

oui mais sizeof(FILE) veux pas dire grand chose. sizeof(char *) = 4 chez moi et un pointeur sur char peut pointer sur une zone de 100 mega.
quant à la question de limite du nb de fichiers ouverts j'ai bien vérifié et elle est loin d'etre atteinte par mon prog.

[souviron34]

ben poste ton code alors...

On peut pas t'aider dans le vide...

[qouify]

ok, voici le pb. j'ai une table de fichiers. tous ces fichiers forment un dictionnaire de mots de N caractères. chaque fichier est une liste de mots. à chaque fichier est associé un arbre équilibré qui contient des mots à lui insérer.

ma table de fichiers :

Code :

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

1
2
3
 
#define FILES 1000
FILE * ss[FILES];

les arbres associés aux fichiers :

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
 
#define N 20
typedef struct storage_buffer_tree_struct {
   char word[N];  /*  le mot  */
   bool to_flush;  /*  TRUE si le mot doit etre insere dans le fichier, FALSE sinon */
   char skew;
   struct storage_buffer_tree_struct * left;
   struct storage_buffer_tree_struct * right;
} storage_buffer_tree_struct;
typedef struct storage_buffer_tree_struct * storage_buffer_tree;
typedef struct {
   int size;   /*  taille de l'arbre  */
   storage_buffer_tree items;
} storage_buffer;
storage_buffer buffers[FILES];

la fonction suivante est appelée en début de programme pour créer les fichiers.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
void SS_init
()
{
   int i = 0;
   char file[255];
   for(i = 0; i < FILES; i ++) {
      buffers[i].size  = 0;
      buffers[i].items = NULL;
      sprintf(&file[0], "SS-%d", i);
      ss[i] = fopen(file, "a+");
      assert(s[i]);
   }
}

enfin la fonction STORAGE_BUFFER_flush permet d'inserer les mots de l'arbre dans le fichier correspondant. dans un premier temps on lit séquentiellement tous les mots du fichier on les cherche dans l'arbre avec STORAGE_BUFFER_search. si le mot est trouvé on met le booléen to_flush à FALSE. enfin on parcourt l'arbre avec STORAGE_BUFFER_insert et on écrit dans le fichier tous les mots pour lesquels to_flush == TRUE. on "free" l'arbre en même temps. en début de fonction on se positionne en début de fichier.

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
 
void STORAGE_BUFFER_flush
(int file_id)
{
   FILE * f = ss[file_id];
   char * word = (char *) malloc(N);
   rewind(f);
   while(fread(word, N, 1, f)) {
      STORAGE_BUFFER_search(buffers[file_id].items, word);
   }
   STORAGE_BUFFER_insert(buffers[file_id].items, f);
   buffers[file_id].size  = 0;
   buffers[file_id].items = NULL;
   free(word);
}
void STORAGE_BUFFER_search
(storage_buffer_tree tree,
 char * word)
{
   if(tree) {
      int cmp;
      cmp_string(N, word, tree->word, cmp);
      switch(cmp) {
         case EQ :
            tree->to_flush = FALSE;
            break;
         case INF:
            STORAGE_BUFFER_search(tree->left,  word);
            break;
         case SUP:
            STORAGE_BUFFER_search(tree->right, word);
            break;
      }
   }
}
void STORAGE_BUFFER_insert
(storage_buffer_tree tree,
 FILE *ss)
{
   if(tree) {
      STORAGE_BUFFER_insert(tree->left, ss);
      STORAGE_BUFFER_insert(tree->right, ss);
      if(tree->to_flush) {
         fwrite(tree->word, N, 1, ss);
      }
      free(tree);
   }
}

sachant que la taille de mes arbres est bornée (à chaque fois qu'ils ont une certaine taille, j'appelle STORAGE_BUFFER_flush), que c'est la seule structure dynamique de mon programme, et qu'apparemment je n'ai pas de fuite mémoire, est ce que vous pensez qu'à mesure que mes fichiers grossisent la mémoire allouée pour la table ss puisse exploser?

[Emmanuel Delahaye]

<...>j'ai un millier de fichiers ouverts en permanence en mode "a+"<...>

STOP ! Conception à la gomme. A revoir.

[qouify]

tu peux développer un peu stp?

[souviron34]

Ce qu'Emmanuel veut dire, et ça se confirme à l'exposé du code et du problème (ce qu'on disait depuis le début), c'est que ta conception de l'algorithme est erronée...

• Primo, si chaque fichier contient M mots de N caractères, pourquoi ne sont-ils pas regroupés en un seul ?
  
• Secondo, si ce sont des fichiers séparés, pourquoi ne pas compter le nombre de fichiers avant de les ouvrir, et faire une allocation dynamique au lieu de déclarer FILES=1000 ?
  
• Tertio, en admettant que ce soit cette construction-là, pourquoi ne pas lire les fichiers dans l'ordre, et stocker les mots dans la structure, et refermer les fichiers une fois les mots lus ?
  
• Quarto, si il faut se souvenir dans quel fichier ils étaient, il suffit de rajouter un indice dans la structure...
  
• Quinto, tes fonctions, en particulier _insert, fait un free de tree qui me semble hautement suspicieux....

En conclusion, pour développer un peu ce qu"Emmanuel disait :

• reprends sur le papier, en écriture, ce que tu veux faire
• déduis-en l'algo
• re-code
• demande de l'aide, éventuellement

Mais tu n'as CERTAINEMENT pas besoin d'avoir tes 1000 fichiers ouverts pour faire ce que tu veux faire...

[qouify]

merci je vais revoir l'algo