Discussion :

[Heimdall]

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

[jeroman]

Je ne sais pas ce que tu appelles rapide.
Par contre, c'est pas recommandé d'enregistrer dans un fichier le contenu tel quel de la mémoire, que ce soit membre par membre ou -pire !- la structure entière. C'est pas portable (à cause de l'endianess et des questions d'alignement) et et si tu changes de machine, tu risques d'avoir de grosses surprises. Je te conseille d'enregistrer dans un format propre et simple, tel que CSV par exemple.

[Heimdall]

Salut et merci de ta réponse. Par rapide, je voulais dire, parmi les différentes méthodes, laquelle est la plus rapide...

Sinon, j'ai bien conscience des problemes de l'endianess ou autre soucis de portabilité, mais je m'en fous un peu à vrai dire (en ce qui concerne mon travail) ça n'est pas l'objet de ma question :-)

[Heimdall]

Bon, j'ai fait un code de test de rapidité des deux méthode.

La méthode du buffer temporaire, qui double la mémoire mais qui fait un seul fwrite par membre de la structure, et la méthode où je ne duplique pas la mémoire et je fais autant de fwrite qu'il y a de structures dans mon tableau...

Comme on pourrait l'intuiter, c'est la seconde méthode qui est la moins rapide... En moyenne sur 100 tests, 0.13 secondes pour la première méthode contre 0.34s pour la seconde. (sur ma machine bien sur... mais le rapport des deux est parlant)

mais peut-être il y a plus rapide que ces deux méthodes ?


Nico