Salut,

Je me demande si par hasard vous auriez une idée pour enregistrer rapidement sur un fichier la chose suivante :

j'ai un tableau de structure :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
 
 
struct particule{
float x, y, z;
float vx, vy, vz;
};
 
nb_particules = 10000000; /*10 millions de particules*/
struct particule *mon_tableau = malloc(nb_particules*(sizeof *mon_tableau));

J'aimerais enregistrer la position des particules dans un fichier, et ça rapidement (car je le fais très très souvent, et les accès disque c'est lent).

Je ne peux pas faire :


Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
 
fp = fopen("mon_fichier.dat", "wb");
fwrite (&nb_particules,sizeof (int), 1,fp);
fwrite (mon_tableau,sizeof(*mon_tableau),nb_particules,fp);
fclose(fp);

Car le programme qui va le lire le fichier impose qu'il soit formaté d'une certaine façon, il ne doit comporter que des tableaux de nombres (sans l'encapsulation dans une structure).


ce que je fais à présent :

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
 
float  *x = malloc(nb_particules *sizeof(*x));
float  *y = malloc(nb_particules *sizeof(*y));
float  *z = malloc(nb_particules *sizeof(*z));
float *vx = malloc(nb_particules *sizeof(*vx));
float *vy = malloc(nb_particules *sizeof(*vy));
float *vz = malloc(nb_particules *sizeof(*vz));
for (i=0; i < nb_particules; i++)
    {
    x[i] = mon_tableau[i].x;
    y[i] = mon_tableau[i].y;
    z[i] = mon_tableau[i].z;
    vx[i] = mon_tableau[i].vx;
    vy[i] = mon_tableau[i].vy;
    vz[i] = mon_tableau[i].vz;
    }
 
fwrite (x, sizeof(*x),nb_particules,fp);
fwrite (y, sizeof(*y),nb_particules,fp);
fwrite (z, sizeof(*z),nb_particules,fp);
fwrite (vx, sizeof(*vx),nb_particules,fp);
fwrite (vy, sizeof(*vy),nb_particules,fp);
fwrite (vz, sizeof(*vz),nb_particules,fp);
autrement dit, je recopie tout dans des buffers temporaires, que j'enregistre ensuite d'un coup dans le fichier.

Je vois deux problèmes à cette méthode :

  1. Je dois faire une boucle sur toutes les particules
  2. je dois demander à l'ordinateur le double de mémoire



Alors je vois une autre solution, qui économiserait la mémoire, et qui serait :


Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
 
for (i=0; i <nb_particules; i++)
    {
    fwrite (&(mon_tableau[i].x),  sizeof(mon_tableau[i].x), 1, fp);
    fwrite (&(mon_tableau[i].y),  sizeof(mon_tableau[i].y), 1, fp);
    fwrite (&(mon_tableau[i].z),  sizeof(mon_tableau[i].z), 1, fp);
    fwrite (&(mon_tableau[i].vx),  sizeof(mon_tableau[i].vx), 1, fp);
    fwrite (&(mon_tableau[i].vy),  sizeof(mon_tableau[i].vy), 1, fp);
    fwrite (&(mon_tableau[i].vz),  sizeof(mon_tableau[i].vz), 1, fp);
    }
Ca n'évite pas la boucle sur les particules, mais ça évite de gaspiller la mémoire (surtout qu'elle peut ne pas être suffisante pour stocker 2*nb_particules). Mais j'ai l'impression que ça sera plus long niveau accès disque ?


Est-ce qu'il y aurait une façon de stocker les données qui permette un enresgistrement rapide ?


merci