Discussion :

[wassim_boy]

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

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.

[oneagaindoguys]

Bonjour,

De quel type de fichier s'agit-il ? Quels sont les traitements à faire dessus ?

[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

[le y@m's]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
}

[wassim_boy]

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 :

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
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

[adiGuba]

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 :

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
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++

[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.

[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 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.

[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

[adiGuba]

pour ce qui est des exceptions idem je sais pas comment bien les utiliser 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.

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++

[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.

encore merci à vous deux et à tous ceux qui ont posté un message.

[wassim_boy]

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.
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?

[dinobogan]

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 ?

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.

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.

[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.

[wassim_boy]

bonjour,

merci pour vos réponses.

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

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.

[wassim_boy]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

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
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.

[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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[wassim_boy]

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

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

[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.

[adiGuba]

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++