dump rapide d'un tableau de structures fichier
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:
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:
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:
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 :
- Je dois faire une boucle sur toutes les particules
- 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:
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
