Hilfe bei einer Simulation

[ConstantGardener]

Hallo BamMatze,

ich hab mir die Quellen jetzt nicht so genau angeschaut aber mir fehlt noch ein TreeView1.Items.BeginUpdate bzw. TreeView1.Items.EndUpdate vor bzw. nach dem aktualisieren des Treeview. Das sollte das aktualisieren des Baums signifikant beschleunigen.


cu cg

[Uwe Raabe]

In dieser Methode kannst du dich schon mal recht lange aufhalten:

Delphi-Quellcode:

procedure Bewegen(var Objekt: TLebensform);
var i: integer;
begin
  repeat
    case random(3) of
    0: Objekt.ix := Objekt.ix - 1;
    1: Objekt.ix := Objekt.ix;
    2: Objekt.ix := Objekt.ix + 1;
    end;
  until Objekt.ix > 1;

  repeat
    case random(3) of
    0: Objekt.iy := Objekt.iy - 1;
    1: Objekt.iy := Objekt.iy;
    2: Objekt.iy := Objekt.iy + 1;
    end;
  until Objekt.iy > 1;
end;

Nehmen wir mal an, ix ist am Anfang 1 (passiert dann, wenn der Elternteil auf 2 sitzt) und der erste Aufruf von Random(3) gibt 0 zurück, dann kann es recht lange dauern, bis ix > 1 wird. Wenn das Ganze erstmal ins Negative abdriftet, brauchst du schon eine ganze Menge 2er Ergebnisse um über 1 zu kommen, denn jede 0 zieht dich wieder zurück. Da du eh nur Werte > 1 akzeptierst, kannst due das Ganze auch direkt nach unten begrenzen anstatt das dem Zufallsgenerator zu überlassen.

Delphi-Quellcode:

procedure Bewegen(var Objekt: TLebensform);
begin
  case random(3) of
    0: Objekt.ix := Objekt.ix - 1;
    1: Objekt.ix := Objekt.ix;
    2: Objekt.ix := Objekt.ix + 1;
  end;
  if Object.ix < 2 then Object.ix := 2;

  case random(3) of
    0: Objekt.iy := Objekt.iy - 1;
    1: Objekt.iy := Objekt.iy;
    2: Objekt.iy := Objekt.iy + 1;
  end;
  if Object.iy < 2 then Object.iy := 2;
end;

Nebenbei, was ist eigentlich mit den oberen Schranken?

Ein weiterer Geschwindigkeitsvorteil läßt sich herausholen, wenn du die Sequenz

Delphi-Quellcode:

              SetLength(LebenTemp,Length(Lebensform1));
              for iIndex := 0 to Length(LebenTemp)-1 do
                begin
                  LebenTemp[iIndex].ix := Lebensform1[iIndex].ix;
                  LebenTemp[iIndex].iy := Lebensform1[iIndex].iy;
                  LebenTemp[iIndex].iNahrung := Lebensform1[iIndex].iNahrung;
                  LebenTemp[iIndex].iWasser := Lebensform1[iIndex].iWasser;
                  LebenTemp[iIndex].iSchwanger := Lebensform1[iIndex].iSchwanger;
                  LebenTemp[iIndex].bFortpflanzen := Lebensform1[iIndex].bFortpflanzen;
                end;
              SetLength(Lebensform1, Length(LebenTemp)+8);
              for iIndex := 0 to Length(LebenTemp)-1 do
                begin
                  Lebensform1[iIndex].ix := LebenTemp[iIndex].ix;
                  Lebensform1[iIndex].iy := LebenTemp[iIndex].iy;
                  Lebensform1[iIndex].iNahrung := LebenTemp[iIndex].iNahrung;
                  Lebensform1[iIndex].iWasser := LebenTemp[iIndex].iWasser;
                  Lebensform1[iIndex].iSchwanger := LebenTemp[iIndex].iSchwanger;
                  Lebensform1[iIndex].bFortpflanzen := LebenTemp[iIndex].bFortpflanzen;
                end;
              iIndez := 0;

durch folgendes ersetzt:

Delphi-Quellcode:

              
              iIndez := Length(Lebensform1);
              SetLength(Lebensform1, iIndez + 8);

Allerdings wird dir das Ganze irgendwann auch nichts mehr nützen, da bei entsprechend vielen Lebensformen der Berechnungsuafwand halt immer größer wird und auch mehr Zeit beansprucht. In dem Fall muss das Simulationsintervall Wohl oder Übel erhöht werden.

[omata]

Dein größtes Problem sind die dynamischen Arrays. Dort muss das Array immer komplett umkopiert werden, wenn sich die Größe ändert. Dies ist erforderlich, damit die Elemente garantiert hintereinander liegen und man so indiziert darauf zugreifen kann.
Dieser direkte Indexzugriff ist für das Programmieren ja ganz angenehm, aber hier führt es eben zu den erwähnten Nachteilen.
Bau dir verkette Listen, damit wirst du auf jeden Fall glücklicher. Trotzdem wird dir auch ein Speicherproblem entgegen treten. Deine Struktur wächst immens, das solltest du ebenfalls bedenken.
Die Verwendung von Threads klingt ja ganz interessant, allerdings sollte man in einer Anwendung niemals mehr als 15 Threads benutzen. Das ist natürlich nur ein Richtwert, bei dir wird das dann aber eher >1000 Threads und das wird Windows nicht lange mitmachen.

Also du siehst, dieses Problem kann man nur mit einer adäquaten Datenstruktur lösen. Und diese muss gut durchdacht sein.

[omata]

Schade das du dich nicht mehr gemeldet hast. Ich habe mich mal dran versucht und das ganze ein bischen umgebaut. Hoffe ich habe nicht zu viel von der urspünglichen Funktionalität rausgenommen.

[BAMatze]

Hallo Omata,

schaue mir jetz mal an, was du mir geschickt hast, hab gestern um die Zeit schon im Bett gelegen, konnte mich also nicht mehr melden :D. Aber danke schon mal für deine Hilfe.

[BAMatze]

@Omata super Ding das.

Genau so hab ich mir das vorgestellt. Hab gerade nur mal laufen lasse, bis 50000 Lebensformen existiert haben und in der Rechnerperformence war über haupt nichts auszusetzen. Muss zwar jetzt erstmal deinen Quellcode analysieren, um zu verstehen, wie du die Effektivietät mehr als verfünfzig facht hast, aber noch mal ein großes Danke.

BAMatze