Optimiser le temps de lecture d'un gros fichier

Version imprimable

28/12/2011, 13h36
wassim_boy

Optimiser le temps de lecture d'un gros fichier

bonjour,

voila je suis entrain de développer une petite application et, grosso-modo, j'ai en entrée un fichier (>300MO), je fais des traitements sur le fichier puis en sortie j'ai un nouveau fichier modifier.

mon problème est le temps d'exécution qui est considérablement grand (5h pour un fichier de 300MO). est ce que quelqu'un peut m'aider sur le sujet?

je suis entrain de chercher sur le net mais le temps presse et je serai très reconnaissant si l'un de vous pourra me faire gagner du temps :ccool:

merci

NB : je suis nouveau sur le forum et je vous demande de m'excuser si jamais j'ai fais une erreur ou que j'explique mal mon problème.
28/12/2011, 13h52
oneagaindoguys

Bonjour,

De quel type de fichier s'agit-il ? Quels sont les traitements à faire dessus ?
28/12/2011, 14h07
wassim_boy

le type de fichier n'est pas donné (texte, image, video, ...)

au fait je récupère les octets du fichier en entrée un par un et je modifie chaque octet, je l'écris puis je passe au suivant

je le traite octet par octet car si je veux récupérer tout le fichier dans un tableau j'aurai l'erreur outofmemory. je peux augmenter la taille de la JVM mais le problème c'est que ça marchera que sur ma machine et pas sur une autre.

merci pour votre réponse et j'espère que j'étais clair

Plutôt que de lire un octet après l'autre tu peux utiliser un buffer.

Code:

1
2
3
4
5
6
InputStream input = ...;
byte[] buffer = new byte[4096];
int nbRead = 0;
while((nbRead = input.read(buffer)) > 0) {
    // traiter les octets de 0 à nbRead dans le buffer
}

merci pour votre réponse le y@m's

j'ai juste une petite question le tableau buffer va contenir tout le fichier?

car j'ai essayé de mettre tout le fichier dans un tableau de byte mais étant donné que le fichier est grand je me retrouve avec une erreur outofmemory.

voici un extrait de mon code, espérant que cela vous aidera à trouver le problème :

Code:

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
 
...
try
        {  //Ouverture des flux e/s
            File f = new File(this.source);
            FileInputStream in = new FileInputStream(f);
            FileOutputStream os = new FileOutputStream(new File(dest));
            while(in.available()!=0)
            {
             //Recupere le premier octet du fichier
                next = in.read();
                b_fichier = (byte) next;
                next = 0;
              //traitement sur la variable b_fichier (opération arithmétique dans une boucle for)
                ....
                ....
              //Ecriture de l'octet dans le fichier de sortie
                os.write(b_fichier);
            } 
            //Fermeture des flux
            in.close();
            os.close();
        } 
        catch (Exception e){
            System.out.println(e.toString());
        }

voila si vous avez d'autre questions je suis la. merci

Salut,

Non le buffer va stocker une petite partie du fichier. Pour un "petit" coût en mémoire (en général on utilise un buffer de 8192 octet) cela diminue énormément le nombre d'accès IO...

Quelques remarques :

Il suffit d'utiliser un BufferedInputStream/BufferedOutputStream pour utiliser un buffer de manière totalement transparente (sans avoir rien à gérer donc).
Il faut utiliser les try/finally pour libérer proprement les ressources (ou le try-with-resources de Java 7)
N'utilises pas available() ! Non seulement son résultat n'est pas garantie mais cela implique également un accès supplémentaire au système de fichier. Il est préférable de lire le fichier jusqu'à recevoir un -1 en retour de read()
Ta gestion des exceptions est assez limité... Non ?

Bref ca devrait donner quelque chose comme cela :
Code:

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 try { // Ouverture des flux e/s File f = new File(this.source); InputStream in = new BufferedInputStream(new FileInputStream(f)); try { OutputStream os = new BufferedOutputStream(new FileOutputStream(new File(dest))); try { while (true) { int r = in.read(); if (r<0) break; // Fin du fichier byte b = (byte) r; // traitement sur la variable b_fichier (opération arithmétique dans une boucle for) // ... // Ecriture de l'octet dans le fichier de sortie os.write(b); } } finally { os.close(); } } finally { in.close(); } } catch (Exception e) { // N'y aurait-il pas mieux à faire ???? System.out.println(e.toString()); }
Il faudrait également savoir ce que tu fais dans ta boucle for, car il est également possible que ce soit la source de ton problème : pour un fichier de 300Mo tu va exécuter cette boucle 300 000 000 fois...

a++

28/12/2011, 15h04
deathness

Il faut savoir que les accès IO ralentisse considérablement tes traitements. D'ou tes 5h de traitements... Moins tu en feras mieux ce sera!

Les conseils d'adiGuba sont donc très judicieux.
28/12/2011, 15h25
wassim_boy

merci adiGuba pour cette réponse bien détaillé.

effectivement j'y connais pas grand chose sur les IO et c'est la première fois que je les utilise. pour ce qui est des exceptions idem je sais pas comment bien les utiliser :oops: mais bon ce n'est jamais trop tard pour apprendre.

je vais essayer la méthode que vous m'avez proposé tout de suite et je vous dirais ce que ça donne.

une dernière question (peut être bête), dans votre méthode vous utilisé pas de tableau de byte, alors comment le buffer va stocker qu'une petite partie du fichier?

encore merci pour vos réponses.
28/12/2011, 15h49
oneagaindoguys

Au lieu de copier octet par octet comme tu le fais, il va faire des paquet de 4096 octets et les copieras uns à uns dans le flux. Ainsi les performances seront nettement meilleurss
28/12/2011, 17h26
adiGuba

Citation:

Envoyé par wassim_boy

pour ce qui est des exceptions idem je sais pas comment bien les utiliser :oops: mais bon ce n'est jamais trop tard pour apprendre.

Ben disons qu'afficher un message en cas d'erreur ca ne sert un peu à rien : le message risque d'être perdu parmi les autres, et du coté du programme on ne peut pas savoir si le traitement a réussi ou pas.

Il est préférable de laisser remonter l'exception plus haut là où on peut la traiter ou carrément faire planter le programme.

Citation:

Envoyé par wassim_boy

une dernière question (peut être bête), dans votre méthode vous utilisé pas de tableau de byte, alors comment le buffer va stocker qu'une petite partie du fichier?

Le tableau de byte est géré automatiquement à l'intérieur du BufferedInputStream. Lors du premiers "read" il va lire le buffer entier (8192 bytes par défaut). Puis tous les read suivant se feront à partir de ce tableau jusqu'à ce qu'il soit vide...

a++
28/12/2011, 17h32
wassim_boy

excusez moi si je répond tard j'étais entrain de tester les méthodes que vous m'avez proposé.

pour la méthode proposé par adiGuba (que je remercie :)) m'a fait gagné du temps. sur un fichier de 5Mo je mettais 6min et avec cette méthode je met que 10 secondes :)

pour la méthode proposé par le y@m's (que je remercie aussi :)) pour le même fichier je met que 9 secondes :)

maintenant pour gagner quelques millisecondes je pense que je dois réduire le coup de mon traitement (aucune idée pour l'instant mais je vais chercher).

une dernière remarque svp, j'ai essayé après d'ajouter une barre de progression pour faire patienter l'utilisateur mais l'utilisation de cette dernière à augmenter le temps de traitement. je passe de 10 secondes à 3min.:cry:

encore merci à vous deux et à tous ceux qui ont posté un message.
28/12/2011, 17h38
wassim_boy

Citation:

Envoyé par adiGuba

Ben disons qu'afficher un message en cas d'erreur ca ne sert un peu à rien : le message risque d'être perdu parmi les autres, et du coté du programme on ne peut pas savoir si le traitement a réussi ou pas.

Il est préférable de laisser remonter l'exception plus haut là où on peut la traiter ou carrément faire planter le programme.

d'accord je vois ce que vous voulez dire mais je ne vois pas comment faire en java. :oops:
il ne faut pas utiliser le sop dans le catch? est ce qu'il faut mettre des if pour chaque traitement pour mieux cibler et trouver l'erreur?
29/12/2011, 11h14
dinobogan

Citation:

Envoyé par wassim_boy

maintenant pour gagner quelques millisecondes je pense que je dois réduire le coup de mon traitement (aucune idée pour l'instant mais je vais chercher).

Avant de chercher les millisecondes, combien de temps met ton programme pour traiter les 300 Mo ?

Citation:

une dernière remarque svp, j'ai essayé après d'ajouter une barre de progression pour faire patienter l'utilisateur mais l'utilisation de cette dernière à augmenter le temps de traitement. je passe de 10 secondes à 3min.:cry:

Laisse tomber l'esthétique pour l'instant. Concentre toi sur le code de traitement. Tu pourrais peut-être nous le transmettre pour voir ce qu'il serait possible de faire.

Pour la barre de progression, tu pourrais envisager une animation infinie (genre un cercle tournant comme pour une page en chargement sur un navigateur par exemple). Bien souvent, une animation indiquant à l'utilisateur que le programme n'est pas planté suffit, surtout lorsqu'il est habitué à utiliser un programme et qu'il sait intuitivement le temps approximatif qu'il prendra pour fournir un résultat.
29/12/2011, 12h29
tchize_

La barre ne devrait pas ralentir, sauf si tu la met à jour trop souvent. Tu peux te contenter de mettre à jour ta barre tous les M ou lorsque la dernière mise à jour à été faite il y a plus de 1 seconde.
29/12/2011, 15h31
wassim_boy

bonjour,

merci pour vos réponses.

Citation:

Envoyé par dinobogan

Avant de chercher les millisecondes, combien de temps met ton programme pour traiter les 300 Mo ?

pour un fichier de 300Mo je mets 8min (531 secondes). c'est mieux qu'avant mais je pense qu'on peux faire mieux :)

Citation:

Envoyé par dinobogan

Laisse tomber l'esthétique pour l'instant. Concentre toi sur le code de traitement.

je suis tout à fait d'accord le plus important pour moi c'est d'optimiser mon code.

Citation:

Envoyé par dinobogan

Tu pourrais peut-être nous le transmettre pour voir ce qu'il serait possible de faire.

pour que vous puissiez mieux m'aider voici mon code :

avant, j'ai deux classe une fenetre JFrame avec un champs pour charger le fichier, un bouton valider et un barre de progression. voici le code du bouton valider :

Code:

1
2
3
4
5
6
 
    this.barre.setStringPainted(true);
    this.barre.setValue(0); 
    // création d'un Thread d'exécution
    Thread t = new Thread(new traitement(this.barre, this.chemin.getText()));
    t.start();

l'utilisation du thread me permet de sortir de l'événement du bouton et ainsi actualiser ma barre. la classe traitement implement runnable.

voici le code pour ma classe traitement (juste la fonction principale) :

Code:

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
49
 
.....
//pour calculer le temps exacte
long time = System.currentTimeMillis();
try{
            File f = new File(this.chemin);
            InputStream input = new BufferedInputStream(new FileInputStream(f));
            byte[] buffer = new byte[4096];
            int nbRead = 0;
            try 
                {OutputStream os = new BufferedOutputStream(new FileOutputStream(new File(new_chemin)));
                try{
            while((nbRead = input.read(buffer)) > 0) {
                System.out.println("buffer "+nbRead + " taille "+buffer.length);
                for(int k = 0; k < nbRead; k++)
                {
                    cpt++;
                    b_fichier = (byte) buffer[k];
                    next = 0;
                    //récupère le premier octet de la clé (8 bits de la graine --> 1 octet de la clé)
                                for(int j = 0; j < 8; j++)
                                {
                                    next =  next + (graine[0] * ((int) Math.pow(2, 7-j)));
                                }
                                b_cle = (byte)next;
                                //on compléte la clé avec la formule donné au sujet
                                for(int i = 0; i < 8; i++)
                                {
                                    //Applique la formule
                                    next = graine[16-5] ^ graine[16-6] ^ graine[16-15] ^ graine[16-16];
                                    //Copie la nouvelle valeur (next) à la fin de la graine, 
                                    //tout en decalant les valeurs de la graine à gauche
                                    //cette operation est répété 8 fois, ainsi on génére un nouveau octet pour la clé 
                                    graine = this.Decalage(graine, next);
                                }
                                //modification de l'octet du fichier 
                                b_fichier = (byte) (b_fichier ^ b_cle);
                                //Ecriture de l'octet modifié dans le fichier de sortie
                                os.write(b_fichier);
                                //ici j'actualise ma barre
                                //this.barre.setValue((int)Math.round(((cpt*100)/f.length())));
                }
            }}finally { os.close();}
            }finally { input.close();}
            }
            catch (Exception e){
                System.out.println(e.toString());
            }
System.out.println("Temps d'exécution : " + (System.currentTimeMillis() - time)/1000 + "secondes");

dans le sujet la taille de la clé est égal à la taille du fichier et je dois faire un ou exlusive entre chaque octet de la clé et du fichier.

voila j'espère que c'est plus clair le problème pour vous. et je suis la si vous avez d'autre questions.

merci et à bientôt.

29/12/2011, 16h22
dinobogan
Sort ce code "((int) Math.pow(2, 7-j))" de ta boucle.
Tente de construire un tableau d'entier juste avant ton traitement pour calculer en dur une fois pour toute les 8 puissances de 2.
Par exemple :
Code:

1 2 3 4 5 6 int puissance[] = new int[ 8 ]; for( int i = 0 ; i < 8 ; ++i ) { puissance[ i ] = (int) Math.pow( 2, 7 - i ); }
Tu économisera plus de 2.5 milliards de calculs de puissance sur des flottants et autant de cast en entier pour ton fichier de 300 Mo.
29/12/2011, 18h37
wassim_boy

merci dinobogan pour votre aide j'ai suivi votre conseil et je passe de 8min (531 secondes) à 1min40s!!!!!:ccool:

c'est magnifique comment le fait de sortir cette boucle permet de gagner un temps énorme. merci beaucoup je commence à voir c'est quoi l'optimisation :)

maintenant je peux attaquer la barre de progression? je n'ai aucune idée pour l'instant

encore merci
29/12/2011, 18h57
tchize_

De la même manière que tu lit bloc par bloc, il vaut mieux écrire bloc par bloc. C'est moins problématique dans le sens ou tu utiliser un BufferedOutputStream, mais autant prendre les bonnes habitude.
29/12/2011, 19h07
adiGuba

Citation:

Envoyé par tchize_

De la même manière que tu lit bloc par bloc, il vaut mieux écrire bloc par bloc. C'est moins problématique dans le sens ou tu utiliser un BufferedOutputStream, mais autant prendre les bonnes habitude.

Pas forcément : en fait il faut soit lire/ecrire par bloc, soit utiliser des BufferedInputStream/BufferedOutputStream.

Par contre il est inutile de lire par bloc lorsqu'on utilise un BufferedInputStream, car du coup on utilise deux buffers inutilement.

Mais tu peux tout à fait faire plusieurs write(byte) sur un BufferedOutputStream sans soucis : il n'y auras qu'un accès IO tous les 8192 bytes (taille du buffer par défaut).

Sinon pour la barre de progression il est plus simple de passer par un SwingWorker qui intègre une méthode setProgress(), et de lui associer un PropertyListener...

Mais attention car le calcul de la progression peut nuire aux performances...

a++
29/12/2011, 19h37
wassim_boy

Merci pour vos réponses :)

Pour le swingworker j'ai lus des articles à gauche à droite rapidement mais j'ai abandonné car je n'ai pas réussi à l'utiliser.

Malheureusement j'ai pas fais de sauvegarde des testes que j'ai fais avec le swingworker mais je vais réessayer et poster mon code (j'espère poster un code qui marche).

En tout cas, si la barre de progression réduit les performances de mon programme j'opterai pour une animation pour faire patienter l'utilisateur et le rassurer que le programme n'a pas planté.:D

à bientôt