BlockRead, BlockWrite und die richtige Buffer-Größe

[dGeek]

Ich habe eben mal ein bisschen mit der Buffer-Größe rumgespielt, die ich bei BlockRead und BlockWrite verwende.
Angefangen bei 7*4069 (A) bis jetzt zu 50*4096 (B).

Ich schreibe eine einzige Datei, welche 7GB groß ist, auf einen im Netzwerk hängenden Datenträger.
Bei der Buffer-Größe A wird die Datei mit etwa 5MB die Sekunde geschrieben. Mit der Buffer-Größe B mit 10 10MB bis 11MB die Sekunde. Also volle Geschwindigkeit (100 MBit).

Ich stelle mir jetzt eine Frage..
sollte man den buffer fix auf, sagen wir mal wie oben, 50*4096 stehen lassen oder je nach Datei entscheiden?

[Zacherl]

Die Datei ist nicht das Kriterium, sondern eher wie viele Daten dein physikalisches Medium am Stück schreiben kann. Bei HDDs hat man mal gesagt, dass ein Vielfaches der Sektorgröße gut sei.

[Der schöne Günther]

Das ist jetzt vielleicht eine ganz dumme Frage, aber: Wozu nimmt man diese alten Pascal-Routinen und nicht einfach einen TFileStream (oder TBufferedFileStream)?

[dGeek]

Wenn du mir sagst, wie ich Streams mit einem repeat-Loop benutzen kann, her damit =)
Ich benutze BlockRead und BlockWrite in einem repeat-Loop-Konstrukt. Will mir die Qual niht antun, wo man einen Callback benutzt.

Zitat:

Zitat von Zacherl (Beitrag 1345546)

Die Datei ist nicht das Kriterium, sondern eher wie viele Daten dein physikalisches Medium am Stück schreiben kann. Bei HDDs hat man mal gesagt, dass ein Vielfaches der Sektorgröße gut sei.

Schadet es denn, wenn der Buffer einfach 50*4096 groß ist?

[Der schöne Günther]

Hier ein kleiner Test. Wenn ich hier auf ein Netzlaufwerk schreibe ist der TFileStream sogar schneller. Und mit einer anderen Blockgröße sogar noch schneller.

Zitat:

Time taken for block write: 2693 ms
Time taken for filestream, block size = 1: 8647 ms
Time taken for filestream, block size = 1024: 1341 ms
Time taken for filestream, block size = 50 * 4096: 1631 MS

Delphi-Quellcode:

program BlockWriteBenchmarkProject;

{$APPTYPE CONSOLE}
{$R *.res}

uses
  System.SysUtils,
  System.Diagnostics,
  System.IoUtils,
  System.Classes
;

const
   filePath      = 'T:\benchmark';
   bytesToWrite   = 100 * 1024 * 1024; // 100 MB
var
   fileStreamBlockSize: Integer;

procedure measureTime(const proc: TProcedure; const title: String);
var
   stopWatch: TStopwatch;
begin
   stopWatch := TStopwatch.StartNew();
   proc();
   stopWatch.Stop();
   WriteLn('Time taken for ', title, ': ', stopWatch.ElapsedMilliseconds, ' ms');
end;

procedure blockWriteThings();
const
   blockSize = 50 * 4096;
var
   legacyFile:      file;
   buffer:         TBytes;
   bytesWritten:   Int64;
begin
   SetLength(buffer, blockSize);
   bytesWritten := 0;

   AssignFile(legacyFile, filePath+'\blockwrite.abc');
   Rewrite(legacyFile, 1);
   try
      repeat
         BlockWrite(legacyFile, buffer[0], blockSize);
         Inc(bytesWritten, blockSize);
      until (bytesWritten = bytesToWrite);
   finally
      CloseFile(legacyFile)
   end;
end;

procedure fileStreamThings();
var
   fileStream:      TStream;
   bytesWritten:   Int64;
   buffer:         TBytes;
begin
   SetLength(buffer, fileStreamBlockSize);
   bytesWritten := 0;

   fileStream := TFile.Open(filePath + '\fileStream.abc', TFileMode.fmOpenOrCreate);
   try
      repeat
         fileStream.WriteData(buffer, fileStreamBlockSize);
         Inc(bytesWritten, fileStreamBlockSize)
      until (bytesWritten = bytesToWrite);
   finally
      fileStream.Destroy();
   end;
end;

begin
   measureTime(blockWriteThings, 'block write');

   fileStreamBlockSize := 1024;
   measureTime(fileStreamThings, 'filestream, block size = 1');

   fileStreamBlockSize := 1024 * 100;
   measureTime(fileStreamThings, 'filestream, block size = 1024');

   fileStreamBlockSize := 50 * 4096;
   measureTime(fileStreamThings, 'filestream, block size = 50 * 4096');


   readln;
end.

Jetzt bleibt nur noch die Frage, wie man die Blockgröße wählen sollte wenn man z.B. weiß dass man 100 MB schreiben möchte. Ich habe da nämlich auch keine Ahnung :stupid:

[dGeek]

Ich gucke mir das gleich mal an!
Du hast das mit dem Filestream ja sogar mit einer repeat-Loop gemacht.

Ich gucke es gleich an und baue es bei mir mal ein. Mal gucken. Vielleicht kann man vorher ja gucken, wie groß die Durchschnittsgröße aller Dateien ist die man kopieren möchte ... oder so ähnlich :lol:

Wie gesagt, gleich erst. Hund muss raus ;)

[Zacherl]

Zitat:

Zitat von dGeek (Beitrag 1345549)

Schadet es denn, wenn der Buffer einfach 50*4096 groß ist?

Meiner Erfahrung nach sind zu große Buffer zumindest weniger schlimm für die Performance, als ganz ganz Kleine. Aber nochmal: Die Buffergröße wählt man nicht anhand der Dateigröße! Es ist vollkommen egal, ob man 10MiB oder 1000MiB schreiben will.

[Luckie]

Zitat:

Zitat von dGeek (Beitrag 1345553)

Du hast das mit dem Filestream ja sogar mit einer repeat-Loop gemacht.

Warum auch nicht? Ich bin etwas verwirrt, ob deiner Verwunderung.

[dGeek]

Zitat:

Zitat von Luckie (Beitrag 1345557)

Zitat:

Zitat von dGeek (Beitrag 1345553)

Du hast das mit dem Filestream ja sogar mit einer repeat-Loop gemacht.

Warum auch nicht? Ich bin etwas verwirrt, ob deiner Verwunderung.

Musst du nicht. Ich dachte immer nur, dass so ein Stream direkt die ganze Datei in einem Rutsch kopiert.

[t.roller]

Theoretisches:
Copying large files on Windows

Slow Large File Copy Issues


Man kann auch XCOPY verwenden, z.B.
xcopy /J - Kopiert ohne E/A-Puffer. Für große Dateien empfohlen.