Dateien schreiben Buffergröße optimieren

[himitsu]

für den Stack ... den hättest du ja auch einfach vergrößern können (mit {$M... glaub'sch) , aber ich denke mal der winzige Geschwindigkeitsvorteil, bei der Speicherreservierung, gegenüber von GetMem und Co. dürfte bei dir kaum auffallen, da's ja nur einmal (für eine Datei) benötigt wird.

Nach meinen Tests sind 0,5 bis 1 MB völlig ausreichend, bei mehr wird's oftmals eh wieder langsamer. Jedenfalls bei großen und kleinen Dateien gemischt, man könnte höchstens noch die Buffergröße an die Dateigröße anpassen



Was du aber noch machen könntest wäre ohne FileCache direkt auszulesen und zu schreiben, vorallem bei (sehr) großen Dateien bringt das recht viel, allerdings mußt du dann auf die Sectorgröße aufpassen, da nur ganze Sektoren ausgelesen werden können.

CreateFile, FILE_FLAG_NO_BUFFERING


Oder da du eh schön der Reihe nach die Dateien abarbeitest sollte (angeblich, laut MS) FILE_FLAG_SEQUENTIAL_SCAN etwas helfen (theoretisch sollte es aber zusammen mit FILE_FLAG_NO_BUFFERING keine Auswirkungen haben)

Und für's Schreiben dann das FILE_FLAG_SEQUENTIAL_SCAN mit FILE_FLAG_WRITE_THROUGH kombinieren.


Von Scatter/Gather hab ich zwar och mal was gehört, aber mir war so, als wenn negaH dort meinte es würde eh kaum, wenn überhaupt Vorteile bringen (könnte sein, daß darüber was im Forum rumschwirrt)

[add]
Im PSDK steht jedenfalls nicht viel dazu, hatte mich da gestern zufällig mal durch die Dateifunktionen gewurschtelt.


Aber ich bin mir relativ sicher, daß Hagen mal ein Wort darüber hier verloren hatte

[Luckie]

Zur Zeit benutze ich die API Funktionen FileRead und FileWrite. Ich werde erstmal eine Blockgröße ausprobieren, die der Seitengröße entspricht. Und dann eventuell auf CreateFile und den genannten Flags umstellen.

[Luckie]

ALSO:

Ich benutze jetzt zum Lesen:

Delphi-Quellcode:

hFile := CreateFile(PChar(Filename), GENERIC_READ , FILE_SHARE_READ, nil, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL
        or FILE_FLAG_NO_BUFFERING, 0);

und zum Schreiben:

Delphi-Quellcode:

hPart := CreateFile(PChar(Partname), GENERIC_WRITE , FILE_SHARE_WRITE, nil, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL
        or FILE_FLAG_SEQUENTIAL_SCAN or FILE_FLAG_WRITE_THROUGH, 0);

Das hat aber auch noch keine signifikanten Geschwindkeitsgewinne gebracht.

Jetzt experimentiere ich mit der Blockgröße. Allerdings, wenn ich ein dynamisches Array of Byte benutze und schreibe:

Delphi-Quellcode:

BytesRead := FileRead(hFile, MemBuffer[0], Min(sizeof(MemBuffer), BytesToRead));
BytesWritten := FileWrite(hPart, MemBuffer[0], BytesRead);

Delphi-Quellcode:

////////////////////////////////////////////////////////////////////////////////
// Procedure : FileRead
// Comment   : Reads the given amount of bytes into a buffer
function FileRead(Handle: Integer; var Buffer; Count: LongWord): Integer;
begin
  if not ReadFile(THandle(Handle), Buffer, Count, LongWord(Result), nil) then
    Result := -1;
end;

////////////////////////////////////////////////////////////////////////////////
// Procedure : FileWrite
// Comment   : Writes the buffer into the file
function FileWrite(Handle: Integer; const Buffer; Count: LongWord): Integer;
begin
  if not WriteFile(THandle(Handle), Buffer, Count, LongWord(Result), nil) then
    Result := -1;
end;

Ist BytesRead immer -1. Obwohl ich ihm das ertse Arrayelement angegeben habe. Was mache ich da noch falsch?

Nachtrag: Wenn ich FILE_FLAG_NO_BUFFERING nicht setze geht es. Ist allerdings sau langsam, weil er wohl immer nur 4 Byte liest.

Und lesen und schreiben mit
FILE_FLAG_NO_BUFFERING or FILE_FLAG_SEQUENTIAL_SCAN or FILE_FLAG_WRITE_THROUGH bringt auch anscheinend nicht wirklich was bei einer Blockgröße von 8KB.

[bigg]

Hast du es schonmal mit den Clustergrößen probiert?

[Luckie]

Also Blockgröße = Clustergröße? Nein, noch nicht. Aber das ist eine gute Idee. Das wären nur 512 Byte in meinem Fall. Ist das nicht etwas klein? Eventuell soolte man ein Vielfaches davon nehmen?

Und von welcher Partition soll ich die Clustergröße nehmen? Von der ich lese oder auf die ich schreiebe?

Dann müsste ich auch wieder mit einem dynamischen Array arbeiten, aber damit habe ich ja Probleme.

[himitsu]

Schau dir mal GetDiskFreeSpace an.
> SectorsPerCluster und BytesPerSector

Also ich nemhe mir da ein Vielfaches beider Dateien (die zu Lesende und der zu Schreibenden)

Mit ein bissl Mathe kann man diese Größen (da sie ja 2er-Potenzen entsprechen sollten) ganz prktisch per AND/OR kombinieren.

Size := -(-SizeRead and -SizeWrite and -1048576); i hoff es stimmt ... ergeben sollte es das kleineste gemeinsame Vielfache von SizeRead, SizeWrite und 1 MB


[edit]
and, nicht or -.-''

[Luckie]

Was ist SizeRead und SizeWrite?
SizeRead = Clustergröße zu lesende Datei?
SizeWrite = Clustergröße zu schreibende Datei?

[himitsu]

jupp

PS: hab dat OR ma ausgetauscht ._. (siehe oben)

[Chewie]

Zitat von Luckie:

Ist allerdings sau langsam, weil er wohl immer nur 4 Byte liest.

Klar, du liest ja auch nur 4 Bytes aus:

BytesRead := FileRead(hFile, MemBuffer[0], Min(sizeof(MemBuffer), BytesToRead)); Sizeof ist ein Operator, der die Anzahl Bytes zurückgibt, die eine Variable eines bestimmten Typs auf dem Stack belegt. Und das sind bei einem dynamischen Array nun mal 4 Byte, da die Variable ja nur einen Zeiger auf den entsprechenden Speicherbereich im Heap darstellt. Da sollte also eher sowas stehen wie
BytesRead := FileRead(hFile, MemBuffer[0], Min(sizeof(MemBuffer[0] * Length(MemBuffer), BytesToRead));

[Luckie]

Zitat von himitsu:

PS: hab dat OR ma ausgetauscht ._. (siehe oben)

Jupp. Ich hatte nämlich wieder 512 Byte raus. Jetzt bin ich bei einem MB, wenn die beiden Clustergrößen 512 Byte sind.

Jetzt bin ich wieder bei meinem dynamischen Array mit SetLength und er liest immer -1 Byte:

BytesRead := FileRead(hFile, MemBuffer[0], Min(sizeof(MemBuffer[0]) * length(MemBuffer), BytesToRead));

Delphi-Quellcode:

function FileRead(Handle: Integer; var Buffer; Count: LongWord): Integer;
begin
  if not ReadFile(THandle(Handle), Buffer, Count, LongWord(Result), nil) then
    Result := -1;
end;

Nachtrag: var Buffer hat ihn FileRead den Wert no Value.