Discussion :

[Shypster]

Quel boulet que je fais, punaise !!!

En revanche, avec le code modifié, la copie n'avance plus ou très très lentement.


Qu'est ce qui se passe ?

[cboun94]

Je pense à une petite erreur d'écriture de ton coté car j'ai pris le temps de faire le test avec 2 méthodes :

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
50
        private void SyncCopyButton_Click(object sender, EventArgs e)
        {
            System.Diagnostics.Stopwatch stop = System.Diagnostics.Stopwatch.StartNew();
            using (FileStream inputStream = File.OpenRead(TestFileName))
            {
                using (FileStream outputStream = File.OpenWrite(SyncCopyFileName))
                {
                    byte[] buffer = new byte[this.BufferSize];
                    int nbRead = inputStream.Read(buffer, 0, buffer.Length);
                    while (nbRead > 0)
                    {
                        outputStream.Write(buffer, 0, nbRead);
                        nbRead = inputStream.Read(buffer, 0, buffer.Length);
                    }
                }
            }
            stop.Stop();
 
            this.SynchroneTempsCopieLabel.Text = stop.Elapsed.ToString();
 
        }
 
        private void AsyncCopyButton_Click(object sender, EventArgs e)
        {
            System.Diagnostics.Stopwatch stop = System.Diagnostics.Stopwatch.StartNew();
            using (FileStream inputStream = File.OpenRead(TestFileName))
            {
                using (FileStream outputStream = File.OpenWrite(AsyncCopyFileName))
                {
                    byte[] bufferWork = new byte[this.BufferSize];
                    byte[] bufferLoad = new byte[this.BufferSize];
                    byte[] bufferTmp;
                    IAsyncResult asyncResult;
 
                    int nbRead = inputStream.Read(bufferWork, 0, bufferWork.Length);
                    while (nbRead > 0)
                    {
                        asyncResult = inputStream.BeginRead(bufferLoad, 0, bufferLoad.Length, null, null);
                        outputStream.Write(bufferWork, 0, nbRead);
                        nbRead = inputStream.EndRead(asyncResult);
 
                        bufferTmp = bufferWork;
                        bufferWork = bufferLoad;
                        bufferLoad = bufferTmp;
                    }
                }
            }
 
            this.AsynchroneTempsCopieLabel.Text = stop.Elapsed.ToString();
        }

Et ça marche bien.

Et je suis bien inférieur à 10 s (même si je suis sur un seul disque) pour 300 Mo

Tient nous au courant

[Shypster]

Pour tes tests de copie, tu met combien en taille de buffer ?
Peux-tu tester sur un fichier d'environ la même taille que moi cad 3,7 go ?
Sinon je viens de tester, et j'ai apparemment le même problème.

Est-il important de spécifier que je fais la copie de mon disque local vers un disque externe ?

Merci.

[cboun94]

Bon ...

Taille du fichier 3700 Mo
Taille d'un buffer : 64 Ko

Copie sur le même disque :
Synchrone : à peu près 5 min
Asynchrone : à peu près 4 min 30 s

Le tout avec le code collé tout à l'heure.

Si tu as toujours un problème, poste ton code.

[Shypster]

bon j'ai crée un projet tout simple, voici le code :

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
 
private void AsyncCopyButton_Click_1(object sender, EventArgs e)
        {
            int BufferSize = 64 * 1024;
 
            System.Diagnostics.Stopwatch stop = System.Diagnostics.Stopwatch.StartNew();
            using (FileStream inputStream = File.OpenRead(TestFileName.Text))
            {
                using (FileStream outputStream = File.OpenWrite(AsyncCopyFileName.Text))
                {
                    byte[] bufferWork = new byte[BufferSize];
                    byte[] bufferLoad = new byte[BufferSize];
                    byte[] bufferTmp;
                    IAsyncResult asyncResult;
 
                    int nbRead = inputStream.Read(bufferWork, 0, bufferWork.Length);
                    while (nbRead > 0)
                    {
                        asyncResult = inputStream.BeginRead(bufferLoad, 0, bufferLoad.Length, null, null);
                        outputStream.Write(bufferWork, 0, nbRead);
                        nbRead = inputStream.EndRead(asyncResult);
 
                        bufferTmp = bufferWork;
                        bufferWork = bufferLoad;
                        bufferLoad = bufferTmp;
                    }
                }
            }
 
            this.AsynchroneTempsCopieLabel.Text = stop.Elapsed.ToString();
        }

Temps de copie pour ISO de 3,7 go 10 min 52.
Tu dois avoir une machine de guerre pour obtenir de tels temps car même avec corbian backup j'obtiens environ 12 - 13 min pour le même fichier.

Enfin 10 min 52 me parait raisonnable.
Je n'ai pas encore testé du disque local vers disque réseau.

[Shypster]

Bon j'ai une piste, quand je copie sur le même disque physique, la copie se fait bien dans un temps raisonnable mais quand je copie du disque local vers un chemin réseau là j'atteins un temps de copie aberrant.

Alors que Corbian Backup que ce soit en local ou sur un chemin réseau, il met approximativement le même temps de copie.

Peux-tu tester le code que tu as posté en copiant sur un chemin unc pour voir ?
Faut il optimiser quelque chose pour les copies en réseau ?

Merci.

[cboun94]

Alors que Corbian Backup que ce soit en local ou sur un chemin réseau, il met approximativement le même temps de copie.

Ca me semble assez étrange ... une copie sur le réseau est a priori moins rapide que sur des disques locaux ...

Sinon j'ai fait le test et ça marche bien sur le réseau.
Le temps est quand même 3 à 3,5 fois plus long.
Globalement, la copie marche mieux avec un buffer de 1Mo pour le réseau alors que 64 Ko pour les disques c'est très bien.

PS : Pour éliminer les problèmes de perf liés au code, j'ai comparé avec le temps de copie avec la méthode du framework :

Code :

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

1
2
3
4
5
6
            FileInfo fi = new FileInfo(TestFileName);
            if (File.Exists(SystemCopyFileName))
            {
                File.Delete(SystemCopyFileName);
            }
            fi.CopyTo(SystemCopyFileName);

Avec la copie réseau + 1Mo de buffer on va plus vite.
Pour la copie locale, c'est TRES variable sur ma machine avec un coeff qui varie de 0,6 à 2 fois le temps moyen observé avec le code d'exemple ...

[tomlev]

Alors que Corbian Backup que ce soit en local ou sur un chemin réseau, il met approximativement le même temps de copie.

Euh... ben soit tu as un réseau méga rapide, soit Corbian Backup est vraiment très fort ! Les débits et temps d'accès en réseau sont très, très loin derrière ceux d'un disque local, c'est normal...

[Shypster]

Il y a quelque chose que je ne comprend pas, lors de la copie de fichiers volumineux, qu'elle taille de buffer faut-il mettre sur un fichier de 3,7 go, avec 4 ko de buffer c'est très très lent, alors que pour ce même fichier avec un buffer de 2 mo je met 16 min ce qui est raisonnable

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
 
public virtual void CopyStreams2(Stream a, Stream b, CopyProgressHandler handler)
{
    int BufferSize = 4 * 1024; // 4 Ko
    long done = 0;
    long total = a.Length;
    double percent = 0;
 
    byte[] bufferWork = new byte[BufferSize];
    byte[] bufferLoad = new byte[BufferSize];
    byte[] bufferTmp;
    IAsyncResult asyncResultRead, asyncResultWrite;
 
    int nbRead = a.Read(bufferWork, 0, bufferWork.Length);
    while (nbRead > 0)
    {
        asyncResultRead = a.BeginRead(bufferLoad, 0, bufferLoad.Length, null, null);
        asyncResultWrite = b.BeginWrite(bufferWork, 0, nbRead,null,null);
 
        // progression
        done += nbRead;
        percent = (double)done / (double)total;
        ProgressFile = Convert.ToInt16(Math.Round(percent * 100, 0));
 
        nbRead = a.EndRead(asyncResultRead);
 
        bufferTmp = bufferWork;
        bufferWork = bufferLoad;
        bufferLoad = bufferTmp;
 
        b.EndWrite(asyncResultWrite);
    }
 
    // this.AsynchroneTempsCopieLabel.Text = stop.Elapsed.ToString();
 
}