Hallo,
ich habe folgendes Problem.
Ein Packed Record mit der Gesamtbytegröße von 1620000 Bytes.
Dieses will ich an ein Threadobjekt übergeben für die weitere Bearbeitung oder wofür auch immer.
Ein QT-Beispiel habe ich auch.

Sobald ich die Daten übergeben, kommt eine StackOverflow Exception.

zusammenfalten · markieren

Delphi-Quellcode:

unit Unit1;

interface

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

const
  maxSatz = 200;

type
  TMyRecord2 = packed record
  private
  public
    MyArray2 : array[1..100] of String[80];
  end;

  PMyRecord = ^TMyRecord;
  TMyRecord = packed record
  private
  public
    MyArray : array[1..maxSatz] of TMyRecord2;

    procedure Clear;
  end;

  TMyClass = class(TObject)
  public
    procedure TestFct(aParam : TMyRecord);
  end;

  TMyTask = class(TThread)
  private
    tmpMyClass: TMyClass;
    LokalRec: TMyRecord;
  protected
    procedure Execute; override;
  public
    Constructor Create (CreateSuspended : Boolean);
    destructor Destroy; override;

    procedure SetDaten(aParam: TMyRecord);
  end;

type
  TForm1 = class(TForm)
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
  private
    { Private-Deklarationen }
    tmpTask : TMyTask;
    tmpRec: TMyRecord;
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}
//------------------------------------------------------------------------------
procedure TForm1.FormCreate(Sender: TObject);
//var
// tmpValue: Integer;
begin
// tmpValue := SizeOf(TMyRecord);
// ShowMessage(tmpValue.ToString + ' Bytes');

  tmpRec.Clear;

  tmpTask := TMyTask.Create(True);
  tmpTask.SetDaten(tmpRec);
  tmpTask.Start;
end;
//------------------------------------------------------------------------------
procedure TForm1.FormDestroy(Sender: TObject);
begin
  if Assigned(tmpTask) then
    FreeAndNil(tmpTask);
end;
//------------------------------------------------------------------------------
{ TMyTask }
//------------------------------------------------------------------------------
constructor TMyTask.Create(CreateSuspended: Boolean);
begin
  inherited Create(CreateSuspended);

  tmpMyClass := TMyClass.Create;
  LokalRec.Clear;
end;
//------------------------------------------------------------------------------
destructor TMyTask.Destroy;
begin
  if Assigned(tmpMyClass) then
    FreeAndNil(tmpMyClass);

  inherited;
end;
//------------------------------------------------------------------------------
procedure TMyTask.Execute;
begin
  FreeOnTerminate := False;

  if Assigned(tmpMyClass) then
    tmpMyClass.TestFct(LokalRec);
end;
//------------------------------------------------------------------------------
procedure TMyTask.SetDaten(aParam: TMyRecord);
begin
  LokalRec := aParam;
end;
//------------------------------------------------------------------------------
{ TMyClass }
//------------------------------------------------------------------------------
procedure TMyClass.TestFct(aParam: TMyRecord);
begin

end;
//------------------------------------------------------------------------------
{ TMyRecord }
//------------------------------------------------------------------------------
procedure TMyRecord.Clear;
begin
  FillChar(Self, SizeOf(Self), 0);
end;
//------------------------------------------------------------------------------
end.

Fehler entsteht hier mit besagter Meldung:
procedure TMyTask.SetDaten(aParam: TMyRecord); Werden die Daten die übergeben werden, auf dem Stack abgelegt?
Wie würde eure Lösung für sowas aussehen?

Grüße

Wenn ich die Konstante maxSatz von 200 verringere, dann klappt es ab einem bestimmten Wert.

Das hat nichts mit dem Thread zu tun, sondern dass dein Record allein größer als der gesamte Stack ist.
Du solltest dir vllt. überlegen ob du so eine große Menge Daten wirklich brauchst oder du legst die Daten auf dem Heap ab und übergibst nur Pointer.

Versuch es doch mal so:
procedure TMyTask.SetDaten(const aParam: TMyRecord); Nach meinem löchrigen Wissen, wird dann der Stack nicht mit einer unnötigen Kopie der Daten belastet.

Gruß
K-H

Stimmt, const funktioniert und da ich die Daten darin nicht ändere, reicht mir das so auch.

Grüße

Zitat von Alex_ITA01:

Stimmt, const funktioniert und da ich die Daten darin nicht ändere, reicht mir das so auch.

Und falls doch, nimm einfach einen Pointer auf das entsprechende Struct. Eventuell funktioniert es sogar mit var statt const.

Zitat von Zacherl:

Zitat von Alex_ITA01:

Stimmt, const funktioniert und da ich die Daten darin nicht ändere, reicht mir das so auch.

Und falls doch, nimm einfach einen Pointer auf das entsprechende Struct. Eventuell funktioniert es sogar mit var statt const.

Soweit ich weiß sind var und const nur Mäntelchen um Pointer vor den Augen des Programmierers zu verbergen, mit Schreibschutz ein/aus.
Bliebe die Frage wo sich diese Riesenstruktur nun befindet.

Gruß
K-H

Zitat von p80286:

Soweit ich weiß sind var und const nur Mäntelchen um Pointer vor den Augen des Programmierers zu verbergen, mit Schreibschutz ein/aus.
Bliebe die Frage wo sich diese Riesenstruktur nun befindet.

Genau. Demnach sollte ein var also ebenso gut funktionieren, wie ein const. Wenn die Struktur auf dem Heap liegt, juckt das ja niemanden. Hauptsache nicht auf dem Stack.