Discussion :

[petitours]

Bonjour

J'ai besoin de lire des fichiers binaires qui contiennent le contenu de petites mémoires dans des systèmes d'enregistrement electroniques. La taille de ces fichiers est donc de max la taille des mémoires soit 256Mo.

Je dois traiter ces données en partant du début du fichier et en avant byte par byte (ou plus, pour lire des int32 ou doubles si je suis sur une trame de donnée) et mon problème est que ca prend une infinité de temps, plusieurs minutes sur un i7 récent, un temps insoutenable sur des plus petites machines.

Ci dessous un des codes que j'ai fait, un des plus simple puisqu'il ne fait que tester le contenu d'un fichier de test contenant 0 1 2 3.....252 253 254 0 1 2 3....

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
        private void btTesterFichierTest_Click(object sender, EventArgs e)
        {
            richTextBox2.Clear();
            long i = 0;
 
            const string fileName = "toto2.dav";
 
            if (!File.Exists(fileName))
            {
                MessageBox.Show("Le fichier n'existe pas encore. Il faut lire la mémoire en HighPSeed");
            }
            else
            {
                using (BinaryReader MonReader = new BinaryReader(File.Open(fileName, FileMode.Open)))
                {
                    MonReader.BaseStream.Position = 0;
                    int ReferenceTest = 0;
 
                    int comptageAdresseReelleMemoireFlash = 0;
 
                    bool stop = false;
 
                    while (MonReader.BaseStream.Position < MonReader.BaseStream.Length && stop == false)
                    {
 
                        if (comptageAdresseReelleMemoireFlash < 2048)
                        {
                            int valeur = MonReader.ReadByte();
                            if (valeur != ReferenceTest)
                            {
                                   stop = true;
                                StatusProgressTextColor(100, System.Drawing.Color.LimeGreen, "TestFichier. Pos : " + (MonReader.BaseStream.Position - 1).ToString() + " ValeurAttendue :" + ReferenceTest.ToString() + " Valeur :" + valeur.ToString() + " \r\n");
                            }
                        }                       
 
 
                        ReferenceTest +=1;
                        comptageAdresseReelleMemoireFlash += 1;
                        if (ReferenceTest == 255) ReferenceTest = 0;
                        if (comptageAdresseReelleMemoireFlash == 2112) comptageAdresseReelleMemoireFlash = 0;
                    }
                }

Comment puis je m'y prendre pour lire mes fichiers autrement ? Une manière radicalement différente qui me permettrait d'aller infiniment plus vite ?
Je me demandais si charger le tableau en ram serait plus rapide ? avec une crainte sur l'alignement en mémoire qui ferait que mes 256Mo prendrait 8fois plus de place sur une machine 64bit et peut être pas la même efficacité pour lire le flux (pas de readbyte, readdouble, readInt32...)

Merci par avance pour vos conseils

[jopopmk]

Salut,

j'ai eu le même souci hier (mais en C) : je devais faire du char à char sur des gros fichier et j'avais des temps d'enfants chiens femelles. Je pouvais atteindre pas loin de 7" pour une fichier de 100Mo. J'ai refait le code en full mémoire et maintenant je suis en-dessous de la seconde. Ça m'a pris moins de 5' à coder (sans casser l'existant, avec un tit #define/#ifdef semé de partout). Du coup ça vaudrait le coup pour toi de faire le test. Il faut évidemment que la machine qui fait tourner ton appli supporte la charge.

Si les perfs sont toujours cracra faudra creuser l'opti du traitement, voire du prog en général.

[petitours]

Je viens à l'instant de finir un test avec chargemetn en mémoire

bonne nouvelle ,les tableaux de byte semblent ne pas souffrir de l'alignement, ca me prend trés peu de ram (les 256Mo)
La mauvaise nouvelle c'est que le temps de traitement est encore plus long ! ca parle en minutes, prés de 5 ( 300secondes) là pour 200Mo !

il y a forcément un truc que je fais mal
Dans mon premier post le code avec des readbyte successif sur le fichier

et ici le code avec un chargement dans un tableau de byte puis traitement du tableau

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
                using (BinaryReader MonReader = new BinaryReader(File.Open(fileName, FileMode.Open)))
                {
                    byte[] contenu = new byte[MonReader.BaseStream.Length];
 
                    MonReader.Read(contenu, 0, (Int32)MonReader.BaseStream.Length);
 
 
                    Int32 Position = 0;
                    byte ReferenceTest = 0;
 
                    Int32 comptageAdresseReelleMemoireFlash = 0;
 
                    bool stop = false;
 
                    while (Position < MonReader.BaseStream.Length && stop == false)
                    {
 
                        if (comptageAdresseReelleMemoireFlash < 2048)
                        {
                            if (contenu[Position++] != ReferenceTest)
                            {
                                stop = true;
                                StatusProgressTextColor(100, System.Drawing.Color.LimeGreen, "TestFichier. Pos : " + (Position-1).ToString() + " ValeurAttendue :" + ReferenceTest.ToString() + " Valeur :" + contenu[Position -1].ToString() + " \r\n");
                            }
                        }
 
                        ReferenceTest += 1;
                        comptageAdresseReelleMemoireFlash += 1;
                        if (ReferenceTest == 255) ReferenceTest = 0;
                        if (comptageAdresseReelleMemoireFlash == 2112) comptageAdresseReelleMemoireFlash = 0;
                    }
                }

ça fonctionne mais c'est pire en temps de traitement !

Merci

[ebastien]

Bonjour,

Evite le test sur la taille du fichier à chaque boucle en stockant sa valeur dans une variable :

Code :

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

1
2
3
long Eof = MonReader.BaseStream.Length;
while (Position < Eof && !stop)
{...}

Tu vas sentir la différence !!

[Pol63]

readbyte doit en effet être à éviter


le plus simple à coder et qui devrait être déjà beaucoup plus performant c'est
system.io.file.readAllBytes (qui retourne un tableau d'octets de tout le fichier directement)
la lecture devrait se faire sans pause et après tu fais ton traitement sur le tableau (256Mo à lire à 20Mo/s (dd lent) ca fait une grosse dizaine de secondes))
l'avantage aussi c'est de pouvoir utiliser le stopwatch pour savoir le temps de lecture puis le temps de traitement, et savoir lequel optimiser

après ce qui doit etre le plus performant et qui ne prendrait pas 256Mo de ram serait de lire et de traiter le tout sur 2 threads différents (en lisant quelques Mo à la fois, à mettre dans un queue, et l'autre thread dequeue)
mais bon de nos jours 250Mo de ram ca n'est rien (le Go étant autour de 10€ je crois) donc ca serait plus compliqué à coder mais seulement si tu veux gagner 5 secondes ^^

[petitours]

Il faut que j'affine mes tests peut être entre RAM et pas RAM mais en supprimant la recherche de la taille du fichier à chaque boucle je viens de passer de 5min à 2s environ (j'ai un SSD performant)

je savais bien que j'avais fait une énormité...

merci beaucoup

je vais fignoler mais la révolution est là !

re merci

[DonQuiche]

EDIT : non, rien.