Auf's Neue: Performance bei vielen VCL Komponenten - anderer Ansatz ?

[hochundweit]

FPC 3.0.0

Liebe Delphi-Community,
mich wuerden Euere Inputs zu folgende Aufgabenstellung aus dem Bereich der Halbleiderproduktion interessieren: ich moechte die Testergebnisse elektrischer Tests auf
Chips auf einem Wafer darstellen; ein Beispiel-Bild habe ich angehaengt.

Aktuell erstelle fuer jeden Chip, der getestet wurde, eine eigene, leicht adaptierte VCL-Komponente (bisher habe ich TPaintBox und TStaticTest als Vorlagen verwendet) und gebe diese dann als Schleife ueber alle Chips/Wafer aus. Die Chips werden farblich codiert, um das Testergebnis zu visualisieren. Gruen(clGreen)=gut, alle anderen Farben= schlecht.
Problematisch an dieser Vorgehensweise mit vielen VCL's ist, dass sie nicht wirklich performant ist, will sagen, wenn das mal mehr als 2000 Chips werden, warte ich schon einige Sekunden auf den Aufbau der 2000 Paintboxen bzw. StaticTexte.

Dass das Ressourcenbedarf mit der Zahl der VCL-Komponenten exponentiell anwaechst, ist ja schon oefters in dem Forum angesprochen worden. Warum ich diese dann ueberhauot verwende ? Nun, das liegt daran, dass ich gerne die MouseEnter/MouseLeave Ereignisse verwende moechte, um ein wenig Text-Informationen ueber den einzelnen Chip auszugeben, der gerade unter dem Mauszeiger liegt.

Meine Frage: gibt es vielleicht performantere Komponenten, die ich in groessere Anzahl verwenden koennte und die eine MouseEnter/Leave Methode haben ?

[bra]

Könntest du nicht anhand der Mausposition berechnen, über welchem Punkt sich die Maus gerade befindet und anhand dessen dann die Info ausgeben?

[Zacherl]

Zitat:

Zitat von hochundweit (Beitrag 1333519)

Problematisch an dieser Vorgehensweise mit vielen VCL's ist, dass sie nicht wirklich performant ist, will sagen, wenn das mal mehr als 2000 Chips werden, warte ich schon einige Sekunden auf den Aufbau der 2000 Paintboxen bzw. StaticTexte.

Das Problem liegt nicht bei der VCL, sondern an deinem Software-Design. 2000 PaintBoxes zu erstellen, nur um komfortabel OnMouseEnter/OnMouseLeave verwenden zu können, ist einfach Blödsinn.

Du brauchst eine einzige PaintBox, in der du alle Chips darstellst. Jetzt verwendest du das OnMouseMove Event der PaintBox, welches dir die Maus-Koordinaten übergibt und berechnest manuell welcher Chip sich darunter befindet.

[Der schöne Günther]

Ich kenne die Paintbox nicht und bin auch kein VCL-Guru, aber aus Spaß hatte ich einmal ein paar hunder relativ aufwändige TeeCharts in eine Scrollbox gepackt. Das hat selbst einen langsamen Rechner nicht gejuckt. Einmal musste natürlich alles gezeichnet werden, aber sobald das fertig war ging das bestens...

Kann es sein dass die Paintbox ein OnPaint-Event hat das dauernd aufgerufen wird, selbst man z.B. sein Formular nur scrollt obwohl die Box kein Stück sichtbar ist?

[stahli]

Ich muss mal nachfragen:

Dein Screenshot beinhaltet 2000 Paintboxen und jede Paintbox stellt eine Farbe dar? Ein "Pixel" repräsentiert quasi einen Chip?

Dann haben die Kollegen schon eine sinnvolle Lösung genannt.
Erzeuge ein Bitmap, kopiere das auf den Canvas und verwalte "virtuell" in einem Array wo sich welches Rechteck mit welchen Informationen befindet.
Über Mousemove ermittelst Du, die Daten welches Rechteckes eingeblendet werden müssen.

In ähnlicher Form habe ich mal einen kleinen GUI-Test gebaut (Quellen habe ich aber nicht mehr).

[hochundweit]

Zitat:

Zitat von Zacherl (Beitrag 1333525)

Zitat:

Zitat von hochundweit (Beitrag 1333519)

Problematisch an dieser Vorgehensweise mit vielen VCL's ist, dass sie nicht wirklich performant ist, will sagen, wenn das mal mehr als 2000 Chips werden, warte ich schon einige Sekunden auf den Aufbau der 2000 Paintboxen bzw. StaticTexte.

Das Problem liegt nicht bei der VCL, sondern an deinem Software-Design. 2000 PaintBoxes zu erstellen, nur um komfortabel OnMouseEnter/OnMouseLeave verwenden zu können, ist einfach Blödsinn.

Du brauchst eine einzige PaintBox, in der du alle Chips darstellst. Jetzt verwendest du das OnMouseMove Event der PaintBox, welches dir die Maus-Koordinaten übergibt und berechnest manuell welcher Chip sich darunter befindet.

Korrekt, ist die komfortable Loesung, aber eben nicht die beste, deshalb frage ich ja. Ich sehe schon, Deine und auch die weiteren Antworten laufen auf das Schema: mach einen Canvas, hol dir die Mauskoordinaten X/Y -> berechne welcher Chip -> mal was raus.

[hochundweit]

Zitat:

Zitat von Der schöne Günther (Beitrag 1333528)

Ich kenne die Paintbox nicht und bin auch kein VCL-Guru, aber aus Spaß hatte ich einmal ein paar hunder relativ aufwändige TeeCharts in eine Scrollbox gepackt. Das hat selbst einen langsamen Rechner nicht gejuckt. Einmal musste natürlich alles gezeichnet werden, aber sobald das fertig war ging das bestens...

Kann es sein dass die Paintbox ein OnPaint-Event hat das dauernd aufgerufen wird, selbst man z.B. sein Formular nur scrollt obwohl die Box kein Stück sichtbar ist?

Hmm, gute Frage, ich weiss nicht. Wie koennte ich das checken, ob hier laufend die OnPaint-Events feuern ?

[Zacherl]

Hier mal mein auf die Schnelle gebastelter Ansatz:

Delphi-Quellcode:

type
  TChipData = record
  public
    Quality: Integer;
    HasFocus: Boolean;
  end;

var
  ChipData: array[0..29] of array[0..29] of TChipData;
  FocusedChip: TPoint;

procedure TForm2.FormCreate(Sender: TObject);
var
  I, J: Integer;
begin
  FocusedChip := Point(-1, -1);
  // Generate random chip distribution and qualities
  Randomize;
  FillChar(ChipData, SizeOf(ChipData), #0);
  for I := Low(ChipData) to High(ChipData) do
  begin
    for J := Low(ChipData[I]) to High(ChipData[I]) do
    begin
      ChipData[I][J].Quality := Random(4);
    end;
  end;
end;

const
  CHIPSIZE = 12; // The width and height of a single chip rect in pixels

procedure TForm2.FormMouseMove(Sender: TObject; Shift: TShiftState; X, Y: Integer);
var
  CX, CY: Integer;
begin
  CX := X div CHIPSIZE;
  CY := Y div CHIPSIZE;
  if (CY <= High(ChipData)) and (CX <= High(ChipData[0])) then
  begin
    if (FocusedChip.X <> CX) or (FocusedChip.Y <> CY) then
    begin
      if (FocusedChip.X >= 0) and (FocusedChip.Y >= 0) then
      begin
        ChipData[FocusedChip.Y][FocusedChip.X].HasFocus := false;
        MouseLeave(FocusedChip.X, FocusedChip.Y);
        FocusedChip := Point(-1, -1);
      end;
      FocusedChip.X := CX;
      FocusedChip.Y := CY;
      ChipData[CY][CX].HasFocus := true;
      MouseEnter(CX, CY);
    end;
  end else if (FocusedChip.X >= 0) and (FocusedChip.Y >= 0) then
  begin
    ChipData[FocusedChip.Y][FocusedChip.X].HasFocus := false;
    MouseLeave(FocusedChip.X, FocusedChip.Y);
    FocusedChip := Point(-1, -1);
  end;
end;

procedure TForm2.FormPaint(Sender: TObject);
var
  X, Y: Integer;
  R: TRect;
begin
  Canvas.Brush.Color := Color;
  Canvas.FillRect(ClientRect);
  for Y := Low(ChipData) to High(ChipData) do
  begin
    for X := Low(ChipData[Y]) to High(ChipData[Y]) do
    begin
      case ChipData[Y][X].Quality of
        0: Canvas.Brush.Color := clWhite;
        1: Canvas.Brush.Color := clGreen;
        2: Canvas.Brush.Color := clBlue;
        3: Canvas.Brush.Color := clRed;
      end;
      R := Rect(X * CHIPSIZE, Y * CHIPSIZE, X * CHIPSIZE + CHIPSIZE,
        Y * CHIPSIZE + CHIPSIZE);
      Canvas.FillRect(R);
      if (ChipData[Y][X].HasFocus) then
      begin
        Canvas.TextRect(R, R.Left, R.Top, IntToStr(ChipData[Y][X].Quality));
      end;
    end;
  end;
end;

procedure TForm2.MouseEnter(CX, CY: Integer);
begin
  // This is a custom method! NOT the OnMouseEnter event of the form
  RepaintChip(CX, CY);
end;

procedure TForm2.MouseLeave(CX, CY: Integer);
begin
  // This is a custom method! NOT the OnMouseLeave event of the form
  RepaintChip(CX, CY);
end;

procedure TForm2.RepaintChip(CX, CY: Integer);
var
  R: TRect;
begin
  R := Rect(CX * CHIPSIZE, CY * CHIPSIZE, CX * CHIPSIZE + CHIPSIZE,
    CY * CHIPSIZE + CHIPSIZE);
  InvalidateRect(WindowHandle, R, false);
end;

Die Daten zu den einzelnen Chips befinden sich im 2-dimensionalen

Delphi-Quellcode:

ChipData

Array (ChipData[Y][X] erlaubt den Zugriff auf einen spezifischen Chip). Die Größe des Arrays ist zu testzwecken statisch, kann aber auch ohne Probleme dynamisch festgelegt werden.

Da du bei einem MouseEnter und MouseLeave neu zeichnen willst (Text anzeigen oder wieder entfernen), machen die Events momentan nichts weiter, als das OnPaint Event des Formulars neu auszulösen. Um Flackern zu vermeiden, benutze ich hierfür InvalidateRect.

[hochundweit]

Zitat:

Zitat von stahli (Beitrag 1333531)

Ich muss mal nachfragen:

Dein Screenshot beinhaltet 2000 Paintboxen und jede Paintbox stellt eine Farbe dar? Ein "Pixel" repräsentiert quasi einen Chip?

Ja, das ist korrekt.

Zitat:

Zitat von stahli (Beitrag 1333531)

Dann haben die Kollegen schon eine sinnvolle Lösung genannt.
Erzeuge ein Bitmap, kopiere das auf den Canvas und verwalte "virtuell" in einem Array wo sich welches Rechteck mit welchen Informationen befindet.
Über Mousemove ermittelst Du, die Daten welches Rechteckes eingeblendet werden müssen.

Das muss dann wohl so. Danke !

[hochundweit]

@Zacherl: wow, danke fuer den Einsatz, fertiger Code, womit habe ich das verdient. Wird sogleich ausprobiert !

[Sir Rufo]

Obwohl ich irgendwie das Gefühl habe, dass jeder Chip nicht als ein Pixel sondern als Fläche angezeigt werden soll.

Das Prinzip ist aber das Gleiche :stupid:

[himitsu]

Fertig ... naja

Statt in der Form das in eine TPaintBox.

Im Paint/OnPaint wird gezeichnet.
In einem Array stehen die Daten.
Und bei Datenänderung oder beim OnMouseEnter/OnMouseMove/OnMouseLeave wird ein Repaint ausgelöst.

Alternativ malt man auf ein TBitmap. die TPaintBox gibt im OnPaint das Bitmap aus und bei Änderungen am Bitmap wird anschließend das Repaint ausgelöst.
(Man kann auch ein TImage verwenden, was im Prinzip das Selbe macht, falls dich dessen negative Geschwindigkeit nicht stört)


1 Pixel: Sooo viele Chips sind selten auf einem Wafer und ich denk nicht, daß er den Wafer zu klein zeichnen will.

Ach ja, viele Grüße aus dem Silicon Saxony. :hi:

[Sir Rufo]

Es macht auch Sinn, das in ein Control (sichtbare Komponente) zu packen.

Die dargestellten Items beinhalten dann nur die benötigten Daten für die Anzeige:

Delphi-Quellcode:

TFooItem = class
published
  property Color: TColor;
  property Text: string;
  property Hint: string;
end;

Das Control selber liefert einem das aktuell gewählte Item bzw. das Item, was sich unter der Maus befindet (was halt benötigt wird).

Um jetzt einen Chip anzuzeigen leitet man sich ein entsprechendes Item ab:

Delphi-Quellcode:

TChipItem = class( TFooItem )
...
end;

und befüllt intern die Eigenschaften.

[hochundweit]

Gruesse zurueck nach Silicon Saxony !

In der Tat haben wir uebrigens wirklich so kleine "Nano-Gate" Chips, von denen 400.000 auf einen 8-Zoll Wafer passen.

Meist sind sie aber deutlich groesser, einige unserer AD-Converter haben einen Wafer-Count von knapp 500. Dagegen sind
die meisten CPU's schon Winzlinge....

[Bentissimo]

Ich hatte vor langer Zeit (Delphi 5) einen ähnlichen Anwendungsfall. Damals hatte ich für die Darstellung ein TGrid verwendet. Die Linien ausblenden und je nach Wafergrösse und Anzahl Chips Breite und Höhe der Spalten und Zeilen einstellen. Die Koordinaten erhältst Du damit praktisch automatisch geliefert. :-D

[Zacherl]

Zitat:

Zitat von himitsu (Beitrag 1333542)

Statt in der Form das in eine TPaintBox.

Hatte ich erst so, allerdings macht das keinen Unterschied, da die PaintBox sowieso nur auf das Canvas vom Parent (in diesem Falle das Form) zeichnet. Direkt das Form zu benutzen hat mir einen

Delphi-Quellcode:

ClientToParent

Aufruf vor dem InvalidateRect erspart. Sinnvoll wäre höchstens die Kapselung in eine komplett eigene Komponente.

Zitat:

Zitat von himitsu (Beitrag 1333542)

Im Paint/OnPaint wird gezeichnet.
In einem Array stehen die Daten.
Und bei Datenänderung oder beim OnMouseEnter/OnMouseMove/OnMouseLeave wird ein Repaint ausgelöst.

Die ersten beiden Punkte macht mein Beispielcode ja nicht anders. Full Repaint im OnMouseMove erzeugt massives Flackern (nur getestet mit DoubleBuffered = false, aber warum komplett neu zeichnen, wenn man nur die geänderten Bereiche aktualisieren muss?).

Wäre es Produktivcode, würde ich die Zeichen-Routinen definitiv in einer eigenen Komponente kapseln.

Des Weiteren sollte man eventuell noch Caching einbauen. InvalidateRect clippt zwar den nicht geänderten Bereich (sorgt also dafür, dass unveränderte Teile nicht neu gezeichnet werden), die OnPaint Routine wird allerdings trotzdem komplett durchlaufen. Das komplette Zeichnen ist aber prinzipiell nur einmalig beim Start des Programms notwendig.

[stahli]

Zitat:

Zitat von Zacherl (Beitrag 1333562)

Des Weiteren sollte man eventuell noch Caching einbauen. InvalidateRect clippt zwar den nicht geänderten Bereich (sorgt also dafür, dass unveränderte Teile nicht neu gezeichnet werden), die OnPaint Routine wird allerdings trotzdem komplett durchlaufen. Das komplette Zeichnen ist aber prinzipiell nur einmalig beim Start des Programms notwendig.

Das ist eine Frage von Aufwand/Nutzen (und persönlichem Geschmack).
Einfacher ist es sicherlich, bei Änderungen ein komplettes neues Bild zu generieren. Bei den vorliegenden Anforderungen geht das sicherlich auch rappelschnell. (In meinem Demo bewegen sich tausende "Controls" auch schnell und absolut flüssig.)
Wenn man die geänderten Bereiche ermittelt und nur die neu zeichnet, muss das bei der geplanten Bildgröße und Komplexität nicht schneller sein.
Ich würde zunächst erst mal den einfachen Weg versuchen.

[himitsu]

Die PaintBox kann man aber beliebig verschieben (Position und Parent), ohne dass sich der Start der Zeichenposition ändert
und beim Debuggen/Fehlersuche macht es sich auch besser, wenn man den code immer schön trennt.

PS: TPaintBox zeichnet nicht auf dem eigenen Canvas (es hat Keines), sondern leitet die Zeichenbefehle an seinen Parent weiter. (TLabel und TImage ebenso)

[Zacherl]

Zitat:

Zitat von himitsu (Beitrag 1333579)

Die PaintBox kann man aber beliebig verschieben (Position und Parent), ohne dass sich der Start der Zeichenposition ändert
und beim Debuggen/Fehlersuche macht es sich auch besser, wenn man den code immer schön trennt.

Beim Verschieben und Parent ändern gebe ich dir recht. Beide Vorteile hat man aber auch bei der sauberen Kapselung in eine eigene Komponente, was definitiv meine bevorzugte Lösung wäre, denn Codetrennung kann ich bei der PaintBox ehrlich gesagt nicht wirklich sehen. Sowohl dort, als auch in meinem Testcode, landen die Routinen irgendwo als Methoden des Formulars.

@hochundweit:
Mit wie vielen Chips muss man denn realistisch rechnen? Also welche Höhe und Breite kann das Grid maximal haben? Und ändern sich die Eigenschaften der Chips noch nachträglich, oder beeinflusst wirklich nur die Mausposition die Darstellung?

[alex517]

Ist es nicht einfacher wie schon erwähnt ein TDrawGrid zu verwenden?

Delphi-Quellcode:

unit Unit1;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.Grids, Vcl.ExtCtrls, Vcl.StdCtrls;


type
  TChipData = Integer; // oder auch Record ...

  TForm1 = class(TForm)
    DrawGrid1: TDrawGrid;
    Panel1: TPanel;
    Button1: TButton;
    procedure FormCreate(Sender: TObject);
    procedure DrawGrid1DrawCell(Sender: TObject; ACol, ARow: Integer; Rect: TRect; State: TGridDrawState);
    procedure DrawGrid1MouseMove(Sender: TObject; Shift: TShiftState; X, Y: Integer);
    procedure Button1Click(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
  private
    { Private-Deklarationen }
    FRowCount: Integer;
    FColCount: Integer;
    FChipData: array of array of TChipData;
    procedure LoadChipData;
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation
uses
  Math;

{$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);
begin
  FColCount := 100;
  FRowCount := 100;

  SetLength(FChipData, FColCount, FRowCount);

  DrawGrid1.RowCount := FRowCount;
  DrawGrid1.ColCount := FColCount;

  DrawGrid1.FixedRows := 0;
  DrawGrid1.FixedCols := 0;
  DrawGrid1.DefaultColWidth := 6;
  DrawGrid1.DefaultRowHeight := 6;
end;

procedure TForm1.FormDestroy(Sender: TObject);
begin
  SetLength(FChipData, 0, 0);
end;

procedure TForm1.LoadChipData;

  function PosImKreis(x, y, r: Integer): Boolean;
  begin
    Result := Power(x, 2) + Power(y, 2) <= Power(r, 2)
  end;

var
  x, y, q: Integer;
  x0, y0, r: Integer;
begin
  x0 := FColCount div 2;
  y0 := FRowCount div 2;
  r := FRowCount div 2;

  Randomize;

  SetLength(FChipData, 0, 0);
  SetLength(FChipData, FColCount, FRowCount);

  for x := 0 to FColCount -1 do
    for y := 0 to FRowCount -1 do
    begin
      if PosImKreis(x - x0, y - y0, r) then
      begin
        q := Random(100) +1;
        if q > 3 then // damit nicht so viel Ausschuß entsteht ;)
          q := 1;
      end else
        q := 0;

      FChipData[ x,y] := q;
    end;
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
  LoadChipData;
  DrawGrid1.Invalidate;
end;

procedure TForm1.DrawGrid1DrawCell(Sender: TObject; ACol, ARow: Integer; Rect: TRect; State: TGridDrawState);
begin
  if InRange(ACol, 0, FColCount) and InRange(ARow, 0, FRowCount) then
    case FChipData[ACol, ARow] of
      0: DrawGrid1.Canvas.Brush.Color := clWhite;
      1: DrawGrid1.Canvas.Brush.Color := clLime;
      2: DrawGrid1.Canvas.Brush.Color := clBlue;
      3: DrawGrid1.Canvas.Brush.Color := clRed;
    end;

  DrawGrid1.Canvas.FillRect(Rect);
end;

procedure TForm1.DrawGrid1MouseMove(Sender: TObject; Shift: TShiftState; X, Y: Integer);
var
  P: TGridCoord;
begin
  P := DrawGrid1.MouseCoord(X, Y);
  if InRange(P.X, 0, FColCount) and InRange(P.Y, 0, FRowCount) then
    Panel1.Caption := Format('Chip: %d-%d Quality: %d', [P.X, P.Y, FChipData[P.X, P.Y]])
  else
    Panel1.Caption := '';
end;



end.

[hochundweit]

Zitat:

Zitat von Zacherl (Beitrag 1333599)

@hochundweit:
Mit wie vielen Chips muss man denn realistisch rechnen? Also welche Höhe und Breite kann das Grid maximal haben? Und ändern sich die Eigenschaften der Chips noch nachträglich, oder beeinflusst wirklich nur die Mausposition die Darstellung?

@Zacherl: ich werde ueber das eine Abfrage in der Routine, die die csv-Testoutput Datei einliest, die Zahl der Chips auf max. 10000 begrenzen. Mehr fuer die
Anwendung keinen Sinn. Die paar Chip-Sets, die kleinere Groessen haben, kommen in der Prozess-Technologie, fuer die ich das Ganze bastele, nicht vor.

[hochundweit]

@Zacherl: ach so, ja, Frage 2. Nein, die Properties eines Chips aendern sich nach dem erstmaligen Einlesen nicht mehr.