Textausgabe in Memo sehr langsam

[user64629]

Hallo liebes Forum,
diesmal habe ich eine recht simple Frage. Ich habe ein Programm zu Primzahlberechnung geschrieben, mit dem ich mit dem Standardverfahren die Primzahlen von 1 bis 1 Millionen in einer Sekunde errechne (wahrscheinlich normal).
Jetzt will ich die Ergebniss natürlich ausgeben lassen, indem ich ein Memo auf dem Formular habe und bei dem in jede Zeile eine Primzahl soll.
Dabei ist mir aufgefallen, dass das circa 2 Minuten dauert. Gibt es da irgendetwas schnelleres? Hier mal der Auszug:

Delphi-Quellcode:

var i: UInt64
    Primzahlen: Array of UInt64
begin
 Ergebniss.Lines.Clear;
 i := 0;
 while i < Length(Primzahlen)
  do begin
      Ergebniss.Lines.Add(IntToStr(Primzahlen[i]));
      i := i + 1;
     end;

Kann ja nicht sein, dass deswegen das ganze Programm uneffektiv wird...

[p80286]

BeginUpdate und EndUpdate sind Deine Stichworte.

Gruß
K-H

[Neutral General]

Anmerkung/Frage: Warum keine for-Schleife?

[samso]

TMemo ist nicht besonders schnell, aber Du wirst vermutlich ein bessers Ergebniss bekommen, wenn Du mit BeginUpdate und EndUpdate das Zeichnen der Einzelzeilen vermeidest.

Delphi-Quellcode:

 
  Ergebniss.Lines.BeginUpdate;
  try
    Ergebniss.Lines.Clear;
    i := 0;
    while i < Length(Primzahlen)
    do begin
       Ergebniss.Lines.Add(IntToStr(Primzahlen[i]));
       i := i + 1;
    end;
  finally
    Ergebniss.Lines.EndUpdate;
  end;

N.B. Da TMemo auch nicht unendlich viel Text verwalten kann (die Grenze lag, glaube ich bei 32KByte (?)) wirst Du eventuell nicht alle Primzahlen sehen können.

[himitsu]

Es waren 64 KB (eine Codepage) und diese Grenze ist schon seit Jahren nicht mehr vorhanden.

[user64629]

Danke himitsu, hab jetzt aber trotzdem einfach mal ein RichEdit verwendet (ist das eventuell langsamer?)

Habe es jetzt mit BeginUpdate und EndUpdate gemacht, ist aber trotzdem seit einer Minute am ausgeben... (Ich hab mir ein Formular gemacht, das solange gezeigt wird wie die Ergebnisse ausgegeben werden).

Immerhin sind es auch 78498 Primzahlen, also auch soviele Zeilen. Was wäre denn eine Alternative?

Und zu der Schleife: Delphi kann keine for Schleife mit einer 64bit Integer...

[himitsu]

Bei einem Array brauchst du aber auch keinen 64-bittigen Index :zwinker:

Belbst bei einem ByteArray kommt man aktuell (bis XE2) nicht bis an die 2 Milliardengrenze (31 Bit) ran.

Schreib es in eine TStringList und am Ende nur ein

Delphi-Quellcode:

Memo.Text := StringList.Text;

Noch schneller wäre es (bei sehr sehr vielen Werten), wenn man es via PChar in einen ausreichend groß allokierten String reinkopiert, da die Kopieraktion der Stringlisten leider nicht sehr optiomal ist.

[juergen]

Hallo,

wennn du bei den Delphi Standard Komponeten bleiben möchtest würde ich dir eine Listbox empfehlen. Allerdings dann im Virtuellen Modus (Style := lbVirtual) !
Ansonsten ist eigentlcih immer der Virtual TreeView zu empfehlen; hier bedarf es allerdings auch einer gewissen Einarbeitung.

Edit: richtig, himitsu hat für die Datenhaltung eine TStringList empfohlen (getreu dem Motto: trenne Daten von der Oberfläche!) Vor etwas längerer Zeit hatte ich es auch mit Memo getestet, war aber trotzdem langsam meine ich...

[blauweiss]

Hallo user64629,

Zitat:

Zitat von user64629 (Beitrag 1108988)

Habe es jetzt mit BeginUpdate und EndUpdate gemacht, ist aber trotzdem seit einer Minute am ausgeben... (Ich hab mir ein Formular gemacht, das solange gezeigt wird wie die Ergebnisse ausgegeben werden).

Immerhin sind es auch 78498 Primzahlen, also auch soviele Zeilen. Was wäre denn eine Alternative?

das kann nicht so wirklich sein, es sei denn Dein PC ist wirklich extrem langsam. Auf meinem 4 Jahre alten, nicht sonderlich schnellen Rechner (Intel Core2 1.8 GHz) dauert es so lange um 78498 Zeilen einzufügen:
a) ohne Begin/EndUpdate: 20 sec
b) mit Begin/EndUpdate: 5 sec
Zeig doch mal Deinen Code her, da ist was faul :shock:

Zitat:

Zitat von user64629 (Beitrag 1108988)

Und zu der Schleife: Delphi kann keine for Schleife mit einer 64bit Integer...

Aber Du willst ja auch nicht die FOR-Schleife über den Int64-Wertebereich laufen lassen, sondern nur über die Anzahl der Einträge des Arrays. Das Array ist nur 78498 Einträge lang, also locker im 32Bit-Integer Bereich. Die Inhalte des Arrays sind dagegen natürlich Int64.

Gruß,
blauweiss

[shmia]

Zitat:

Zitat von himitsu (Beitrag 1109006)

Schreib es in eine TStringList und am Ende nur ein

Delphi-Quellcode:

Memo.Text := StringList.Text;

Bei meinen Messungen hat folgende Vorgehensweise einen Faktor 50 an Geschwindigkeit gebracht:

Delphi-Quellcode:

var
  stringlist : TStringList;
...
  // stringlist befüllen
...
  Memo1.Lines.Assign(stringlist);

Maximale Geschwindigkeit lässt so so erreichen:

Delphi-Quellcode:

// 100000 Zeilen in weniger als 0,5 Sekunden
var
   s : TStringList;
   i : Integer;
begin
   s := TStringList.Create;
   for i := 1 to 100000 do
      s.Add(Format('Zeile %d',[i]));
   SendMessage(Memo1.Handle, WM_SETTEXT, 0, Longint(s.Text));
   s.Free;
end;

[user64629]

So ich habe jetzt mal versucht eine ListBox zu nehmen, allerdings zeigt die meine Einträge nicht korrekt an! Irgendwann gegen Ende fängt sie einfach wieder von vorne an, ohne jedoch meine letzten Einträge anzuzeigen!

Jetzt meine Frage, wie befülle ich eine StringList?

Und meine PC hat ein Q8200, zwar auch nicht der shcnellste aber 2,33 GHz. Kerne sind ja egal unterstützt Delphi ja eh nicht.

Außerdem kann man bei meinem Programm ja eingeben, bis wo der die Primzahlen berechnen soll und es wäre ja schön wenn das über 4 Milliarden geht :-)

Hier mal der gesamte Auszug der Prozedur (jetzt im verbesserten Zustand)

Delphi-Quellcode:

var Primzahlen: Array of UInt64;

procedure TPrimzahlberechnung.BerechnenClick(Sender: TObject);
var Bis, i, j: UInt64;
    Primzahl: Boolean;
    Zwischenspeicher: TStringList;
begin
 Primzahlberechnung.Enabled := False;
 Berechnung.Show;
 Application.ProcessMessages;

 SetLength(Primzahlen, 8);
 Primzahlen[0] := 2;
 Primzahlen[1] := 3;
 Primzahlen[2] := 5;
 Primzahlen[3] := 7;
 Primzahlen[4] := 11;
 Primzahlen[5] := 13;
 Primzahlen[6] := 17;
 Primzahlen[7] := 19;

 i := 20;
 Bis := StrToInt64(Bereich.Text);
 while i < Bis
  do begin
      Primzahl := True;
      j := 0;
      while (j < Length(Primzahlen) - 1) and (Primzahlen[j] <= sqrt(i)) 
                                         and (Primzahl = True)
       do begin
           if i Mod Primzahlen[j] = 0
              then Primzahl := False;
           j := j + 1;
          end;
      if Primzahl = True
         then begin
               SetLength(Primzahlen, Length(Primzahlen) + 1);
               Primzahlen[Length(Primzahlen) - 1] := i;
              end;
      i := i + 1;
     end;

 Berechnung.Close;
 Ausgabe.Show;

// Bei einer Millionen seh ich hier nach knapp einer Sekunde das andere Formular

 Ergebniss.Items.Clear;
 Anzahl.Text := IntToStr(Length(Primzahlen));
 Application.ProcessMessages;

// Hier beginnt die Ausgabe

 i := 0;
 Zwischenspeicher := TStringList.Create;
 while i < Length(Primzahlen)
  do begin
      Zwischenspeicher.Add(IntToStr(Primzahlen[i]));
      i := i + 1;
     end;
 SendMessage(Ergebniss.Handle, WM_SETTEXT, 0, Longint(Zwischenspeicher.Text));
 Zwischenspeicher.Free;

 Ausgabe.Close;

// Hier seh ich das es gefüllt ist, dauert jetzt nur deutlich weniger als eine Sekunde :-)

 Primzahlberechnung.Enabled := True;
 Ergebniss.SetFocus;
end;

Ich habe noch 2 Formulare die angezeigt werden, damit man weiß das gearbeitet wird...


Edit: Ach steht ja ein Post vorher mit der StringList... Allerdins hat die ListBox trotzdem das Problem, das nicht alles angezeigt wird, also wieder mit langsamen Memo arbeiten? :-D


Edit 2: Okay hab wieder ein Memo genommen. Selbst die Ausgabe aller 664579 Primzahlen bis 10 Millionen klappt in unter einer Sekunde :-) Jetzt könnte ich noch versuchen einen schnelleren Algorithmus für die Primzahlen zu suchen danke :-)

[himitsu]

Primzahlen bis über 4 miliarden gehen schon,
aber der Index (also die Anzahl der Werte in dem Array) ist eher begrenzt.

Int64 und Extended bieten schonmal mehr Platz und wenn nötig kann man auch noch auf spezielle Mathebibliotheken verwenden.
Da gibt es übrigens mehrere direkt hier im Forum zu finden.

[Aphton]

Probiers mal so:

Quellcode

Delphi-Quellcode:

{...}

var
  i: Integer;
  Primzahlen: Int64Arr;
  PrimzahlenStr: String;

{...}

Primzahlen := SieveOfErastothenes(1, 4000000);
for i := 0 to High(Primzahlen) do
  PrimzahlenStr := PrimzahlenStr + IntToStr(Primzahlen[i]) + #13#10;
Ergebniss.Lines.BeginUpdate;
Ergebniss.Lines.Text := PrimzahlenStr;
Ergebniss.Lines.EndUpdate;

[Gustav.R]

Bin mir jetzt nicht ganz sicher, wer es hier irgendwo schon geschrieben hatte (himitsu)?

Sinngemäß lieber TRichEdit statt TMemo verwenden, für schnelle Zeilen ab XP oder erst ab Vista?

GG

[blackfin]

Zitat:

Kerne sind ja egal unterstützt Delphi ja eh nicht.

Das stimmt so nicht. Wenn du deine Berechnung in mehrere parallele Threads aufspaltest, dann verwendet Delphi sehr wohl die anderen Kerne zur Berechnung :-)
Gut, hat nichts mit dem langsamen Memo zu tun, aber die Aussage, dass Delphi keine zusätzlichen CPU-Kerne verwenden kann, stimmt ja so nicht :-)