Große Textdateien spitten

[nahpets]

Hab' mal ein bisserl rumgespielt, rausgekommen ist dashier:

Delphi-Quellcode:

program Project1;

{$APPTYPE CONSOLE}

uses
  SysUtils,
  Classes;

const
//  BUFFER_SIZE = 16384; // 1:19
//  BUFFER_SIZE = 65536;   // 1:07
//  BUFFER_SIZE = 65536 * 2; // 1:03
  BUFFER_SIZE = 65536 * 4; // 0:53
//  BUFFER_SIZE = 65536 * 8; // 2:07
  arLow  = 0;
  arHigh = 3;
var
  i        : Integer;
  f        : array[arLow..arHigh] of TextFile;
  ff       : TextFile;
  inf_buf  : array[1..BUFFER_SIZE] of Byte;
  utf_buf  : array[1..BUFFER_SIZE] of Byte;
  sIn      : String;
  sOut     : Array[arLow..arHigh] of String;
  sZeile   : String;
  dtStart  : TDateTime;
  dtEnde   : TDateTime;
begin
  dtStart := Now;
  WriteLn('Start : ' + DateTimeToStr(dtStart));
  sIn     := ParamStr(1);

  For i := Low(f) to High(f) do begin
    sOut[i] := ExtractFilePath(ParamStr(0)) + 'Test_' + IntToStr(i) + '.txt';
    AssignFile(F[i],sOut[i]);
    SetTextBuf(F[i],utf_buf, BUFFER_SIZE);
    ReWrite(F[i]);
  end;

  i := 0;
  AssignFile(ff,sIn);
  SetTextBuf(ff,inf_buf,BUFFER_SIZE);
  Reset(ff);
  while not eof(ff) do begin
    ReadLn(ff, sZeile);
    WriteLn(F[i],sZeile);
    inc(i);
    If i > arHigh Then i := arLow;
  end;
  dtEnde := Now;
  WriteLn('Ende  : ' + DateTimeToStr(dtEnde));
  WriteLn('Zeit  : ' + TimeToStr(dtEnde - dtStart));
  WriteLn('Buffer: ' + IntToStr(Buffer_Size));
  WriteLn('Dateigroessen:');
  WriteLn('Eingabe: ',FileSize(ff) * Buffer_Size,' (',sIn,')');
  CloseFile(ff);
  for i := Low(f) to High(f) do begin
    WriteLn('Ausgabe: ',FileSize(f[i]) * Buffer_Size,' (',sOut[i],')');
    CloseFile(F[i]);
  end;
end.

Hinter der Konstante Buffer_Size steht jeweils, wielange mein Rechner für die Aufteilung einer Datei von 1.250.375.501 Byte benötigt hat.

Eventuell kannst Du damit ja was anfangen.

[muhael]

Hallo Nahpets,

Ich konnte damit die benötigte Zeit von 102 Sekunden auf 25 Sekunden verringern.

Vielen Dank

Start : 29.10.2017 20:59:44
Ende : 29.10.2017 21:00:10
Zeit : 00:00:25
Buffer: 262144
Dateigroessen:
Eingabe: 1535639552 (TestDaten\dbtest_PINAG.txt)
Ausgabe: 383778816 (Test_0.txt)
Ausgabe: 383778816 (Test_1.txt)
Ausgabe: 383778816 (Test_2.txt)
Ausgabe: 383778816 (Test_3.txt)

[Glados]

Versuch doch trotzdem mal http://www.delphipraxis.net/151898-s...ei-reader.html .

Das ist sicher noch schneller.

[Luckie]

Und wie wäre es mit der TFileStream klasse?

[muhael]

Zitat von Luckie:

Und wie wäre es mit der TFileStream klasse?

Läd der Filestream dann nicht die Datei in den Ram?

[Fritzew]

Jetzt gebe ich auch noch meinen Senf dazu...
pragmatischer Ansatz
schon mal versucht die Datei im shared readmode für die einzelnen Threads zu öffnen und jedem thread mitzugeben welche
wievielte Zeile er zu lesen hat. Also so was wie
mytread := Tworkethread.create(onlyLine...)

wo dann onlyLine immer der Step ist den er liest also nur 1, 2,3,4... was auch immer Zeile?
Dann kannst Du dir die ganze splitterei sparen, die Information ist ja da..........

[Luckie]

Das Problem dürfte dann aber sein, dass du zwar vier Threads hast, aber die Platte nur einen Schreibkopf. Müsste man aber wohl ausprobieren.

[nahpets]

TFileStream hab' ich zuerst ausprobiert, war auf meinem Rechner deutlich langsamer (vorausgesetzt, dass ich es vernünftig gemacht haben sollte).

Man muss ja dann im Stream immer nach dem Zeilenumbruch suche und, wenn gefunden, die Ausgabedatei wechseln.

Sowas in der Art?

Delphi-Quellcode:

var
  output : Array[0..3] of TFileStream;
  input  : TFileStream;
  i      : Integer;
  ch     : Char;
begin
  input := TFileStream.Create(ParamStr(1),fmOpenRead);
  for i := 0 to 3 do begin
    output[i] := TFileStream.Create(ExtractFilePath(ParamStr(0)) + 'Test_' + IntToStr(i) + '.txt',fmCreate);
  end;
  i := 0;
  input.Position := 0;
  input.Read(ch,1);
  repeat
    output[i].Write(ch,1);
    case ch of
      #10 : begin
              i := i + 1;
              if i > 3 then i := 0;
            end;
    end;
  until input.Read(ch, 1) = 0;
  for i := 0 to 3 do output[i].Free;
  input.Free;
end.

[Luckie]

Wieso suchen? Ans Ende springen müsste doch reichen.

[nahpets]

Zitat von Luckie:

Wieso suchen? Ans Ende springen müsste doch reichen.

An das Ende von was springen?

1. Zeile -> Datei 1
2. Zeile -> Datei 2
3. Zeile -> Datei 3
4. Zeile -> Datei 4

Und wieder von vorne, bis die Datei vollständig aufgeteilt ist.

Irgendwie muss ich also für jede Zeile wissen, wo sie anfängt und wo sie aufhört. Da die Zeilen unterschiedlich lang sind, kann man ja nicht eine bestimmte Anzahl von Zeichen "am Stück" lesen.

Die Idee von Fritzew ist aber auch nicht von der Hand zu weisen. Man spart viel Plattenplatz und die entsprechenden Schreiboperationen.
Wenn wer jede vierte Zeile verarbeiten muss, kann er ja die übrigen Zeilen überlesen.
Und wo die erste Zeile für den Beginn ist, kann man ja mit einem Offset für die am Anfang zu überlesenden Zeilen angeben.

Und ob jetzt vier Threads vier Dateien lesen oder vier Threads eine Datei, dürfte für den Schreibkopf auch eher egal sein. Bzw.: Das was bei einer Datei gelesen wird, liegt physikalisch vermutlich näher beeinander, als bei auf mehrere Dateien verteilten Inhalten.

Die Sectorgröße ist doch abhängig vom Dateisystem und nicht von der Hardware. Oder irre ich da?

Eine Datei wird in 'ner Schleife gelesen und in vier wird geschrieben. Geöffnet wird am Anfang und am Ende alles geschlossen und nicht zeilenweise auf und zu.

Aber es wäre doch einen Versuch Wert, die Datei nicht zu splitten, sondern jeweils nur die vierte Zeile auszuwerten. Man muss nur am Anfang angeben, ob keine, eine, zwei oder drei Zeilen zu überlesen sind.