Scrive dati di grandi dimensioni per il problema di memorizzazione nella cache dei file

Question

Ho un problema quando scrivo una grande quantità di dati < 2GB in un file. I primi dati da 1,4 GB vengono scritti velocemente (100 MB/s) rispetto a quando il codice diventa molto lento (0-2 MB/s).

Il mio codice (semplificato) è:

//FileOptions FILE_FLAG_NO_BUFFERING = (FileOptions)0x20000000; 
    FileOptions fileOptions = FileOptions.SequentialScan; 

    int fileBufferSize = 1024 * 1024; 
    byte[] Buffer = new byte[32768]; 

    Random random = new Random(); 
    long fileSize = 2588490188; 
    long totalByteWritten = 0; 

    using (FileStream fs = File.Create(@"c:\test\test.bin", fileBufferSize, fileOptions)) 
    { 
     while (totalByteWritten < fileSize) 
     { 
      random.NextBytes(Buffer); 
      fs.Write(Buffer, 0, Buffer.Length); 
      totalByteWritten += Buffer.Length; 
      //Thread.Sleep(10); 
     } 
    } 

io ci credo sia un problema relativo al problema di caching, infatti durante "le prestazioni in scrittura veloce" RAM utilizzata aumento così, quando l'arresto utilizzo della RAM per aumentare lì è un calo di prestazioni.

Quello che ho cercato:

• modifica asincrona scrittura -> Nessun cambiamento significativo

• cambiamento matrice di dimensione del buffer -> cambiare senza significativamente

• cambiamento fileBufferSize - > nessun cambiamento significativo, ma con un buffer di grandi dimensioni ~ 100 MB, le prestazioni in scrittura sono veloci e quando l'utilizzo della RAM si ferma per aumentare, scrivi p erformance va a 0 e poi, dopo un po ', risale a 100 MB, cuciture che buffer della cache è "arrossato"

• cambiamento fileOption-WriteThrough -> prestazioni sono sempre lento ..

• aggiungendo dopo xx loop fs.Flush(true) -> cambio No significativamente

• uncomment Thread.Sleep(10) -> velocità di scrittura è sempre bene ..... questo è strano

Answer 1

E 'in qualche modo che prova a scrivere prima di aver finito di scrivere il pezzo precedente e di avere un casino? (sembra improbabile, ma è molto strano che lo Thread.Sleep dovrebbe accelerarlo e questo potrebbe spiegarlo). Cosa succede se modifichi il codice all'interno dell'istruzione using per bloccare il filestream, come questo?

using (FileStream fs = File.Create(@"c:\testing\test.bin", fileBufferSize, fileOptions)) 
{ 
    while (fs.Position < fileBufferSize) 
    { 
    lock(fs) // this is the bit I have added to try to speed it up 
    { 
     random.NextBytes(Buffer); 
     fs.Write(Buffer, 0, Buffer.Length); 
    } 
    } 
} 

EDIT: Ho ottimizzato il codice di esempio per includere il ciclo while necessaria per renderlo scrivere un file di dimensioni corrette.

Per inciso, quando eseguo il codice di esempio è molto veloce con o senza l'istruzione lock e l'aggiunta del sonno rallenta notevolmente.