IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C Discussion :

dump rapide d'un tableau de structures fichier


Sujet :

C

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre confirmé
    Homme Profil pro
    Collégien
    Inscrit en
    Mars 2003
    Messages
    192
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Afghanistan

    Informations professionnelles :
    Activité : Collégien

    Informations forums :
    Inscription : Mars 2003
    Messages : 192
    Par défaut 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 : 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

  2. #2
    Membre Expert
    Profil pro
    Inscrit en
    Août 2006
    Messages
    1 104
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Août 2006
    Messages : 1 104
    Par défaut
    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.

  3. #3
    Membre confirmé
    Homme Profil pro
    Collégien
    Inscrit en
    Mars 2003
    Messages
    192
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Afghanistan

    Informations professionnelles :
    Activité : Collégien

    Informations forums :
    Inscription : Mars 2003
    Messages : 192
    Par défaut
    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 :-)

  4. #4
    Membre confirmé
    Homme Profil pro
    Collégien
    Inscrit en
    Mars 2003
    Messages
    192
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Afghanistan

    Informations professionnelles :
    Activité : Collégien

    Informations forums :
    Inscription : Mars 2003
    Messages : 192
    Par défaut
    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

Discussions similaires

  1. Tableau de structures dans un fichier
    Par tchezan dans le forum Débuter
    Réponses: 7
    Dernier message: 12/04/2010, 12h15
  2. Charger un fichier dans un tableau de structures
    Par ysahel dans le forum Débuter
    Réponses: 7
    Dernier message: 17/01/2010, 13h18
  3. Réponses: 3
    Dernier message: 12/11/2009, 14h26
  4. Réponses: 4
    Dernier message: 29/04/2008, 09h52
  5. Réponses: 32
    Dernier message: 11/03/2007, 11h25

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo