Floating Point Exception oder Access Violation, je nach Schreibweise

[Der schöne Günther]

Kann mir jemand folgendes Verhalten erklären?

uses System.Generics.Collections; Prozedur p1 wirft eine Access Violation, p2 hingegen eine Floating point invalid operation. Warum? Da ist doch kein Unterschied!

Delphi-Quellcode:

procedure p1();
type
   TFloat = type Single;
var
   values:   TArray<TFloat>;
begin
   values := [1.0, Single.Nan, 2.0];
   TArray.Sort<TFloat>(values);
end;

procedure p2();
type
   TFloat = Single;
var
   values:   TArray<TFloat>;
begin
   values := [1.0, Single.Nan, 2.0];
   TArray.Sort<TFloat>(values);
end;

[Zacherl]

Doch schon. Mit X = type Y deklarierst du ja einen neuen Strong-Type und nicht nur einen Alias. Vergleiche über TypInfo, RTTI, oder eben die Intrinsics im Zusammenhang mit der generischen TArra<T>.Sort Methode werden hierbei dann keine Gleichheit mehr ergeben.

Edit:
Die generischen Container haben in Delphi für die meisten Standard-Typen spezifische Behandlungsroutinen. Dadurch, dass der RTL TFloat bzw. type Single unbekannt ist, wird hier dann vermutlich auf eine Fallbackroutine zurückgegriffen.

[himitsu]

Aber "Zugriffsverletzung" kommt mir dennoch etwas komisch vor.

[himitsu]

Ratet mal, wofür es den Debugger gibt.

Wie Zacherl bereits erwähnte, gehört dein neuer Typ nicht zu den bekannten "Default"-Typen, für Welche in Delphi passende Comparer existieren,
also wird hier ganz einfach nur auf Type-Size gegangen und der Inhalt "Binär" verglichen.

Delphi-Quellcode:

class procedure TArray.Sort<T>(var Values: array of T);
begin
  QuickSort<T>(Values, TComparer<T>.Default, Low(Values), High(Values));
end;

class function TComparer<T>.Default: IComparer<T>;
begin
  Result := IComparer<T>(_LookupVtableInfo(giComparer, TypeInfo(T), SizeOf(T)));
end;

class procedure TArray.QuickSort<T>(var Values: array of T; const Comparer: IComparer<T>; L, R: Integer);
begin
  ...
      while Comparer.Compare(Values[I], pivot) < 0 do


// Single
function Compare_R4(Inst: Pointer; const Left, Right: Single): Integer;
begin
  if Left < Right then

// type Single
function Compare_U4(Inst: Pointer; const Left, Right: Cardinal): Integer;
begin
  if Left < Right then

Du mußt dir also selber einen Comparer erstellen, für solche Typen.
TArray.Sort<TFloat>(Values, Comparer);

Die Zugriffsverletzung ist aber ein schwerwiegender Bug im QuickSort.
Ich bin echt erstaunt, daß es nicht öfters knallt.

Mit Single knallt es schon im Compare, wegen des NAN und weil die FPU so eingestellt ist.
> Set8087CW SetExceptionMask

Bei type Single funktioniert der Vergleich, da "NAN" dort nicht behandelt wird, und es knallt im QuickSort.
Das erste while Comparer.Compare(Values[I], pivot) < 0 do Inc(I); findet kein Ende und trifft hier "zufällig" irgendwann auf nicht zugewiesenen Speicher.
Das Selbe wird man auch bei anderen Typen hinbekommen. Der BufferOverflow wird zum Glück abgefangen, da die Array-Grenzen im Anschluss geprüft werden und somit keine Schreibzugriffe außerhalb des Arrays auftreten.
Es knallt also immer wenn im Array und davor oder dahinter auch kein fremder reservierter Speicher mit einem passenden Wert gefunden wird.

Delphi-Quellcode:

class procedure TArray.QuickSort<T>(var Values: array of T; const Comparer: IComparer<T>; L, R: Integer);
var
  I, J: Integer;
  pivot, temp: T;
begin
  if (Length(Values) = 0) or ((R - L) <= 0) then
    Exit;
  repeat
    I := L;
    J := R;
    pivot := Values[L + (R - L) shr 1];
    repeat
      while Comparer.Compare(Values[I], pivot) < 0 do
        Inc(I);
      while Comparer.Compare(Values[J], pivot) > 0 do
        Dec(J);

Sehr eigenartig ist auch, dass in diesem Generic die Bereichsprüfung nicht funktioniert.
> {$RANGECHECKS ON} bzw. in den Projektoptionen aktiviert

[himitsu]

https://quality.embarcadero.com/brow...22quicksort%22

[himitsu]

LOL, grade gefunden.
http://www.delphipraxis.net/182907-d...-overflow.html

Der Witz dabei ist, das du hier schon mit dem Bugfix arbeitest. (neuer Code, der ebenfalls nicht funktioniert)

[Stevie]

Zitat von himitsu:

Sehr eigenartig ist auch, dass in diesem Generic die Bereichsprüfung nicht funktioniert.
> {$RANGECHECKS ON} bzw. in den Projektoptionen aktiviert

Guck mal ganz oben in System.Generics.Collections ...

[Der schöne Günther]

Danke für die Erklärung, jetzt verstehe ich es zumindest.

Und ja, ein Floating Point-Error wäre mir auf jeden Fall lieber als eine AV.

PS: Dein Kommentar in
https://quality.embarcadero.com/browse/RSP-19091
ist wohl nochmal einen neuen Eintrag wert, die haben das Ticket danach einfach zu gemacht

[himitsu]

Zitat von Der schöne Günther:

PS: Dein Kommentar in
https://quality.embarcadero.com/browse/RSP-19091
ist wohl nochmal einen neuen Eintrag wert, die haben das Ticket danach einfach zu gemacht

Sorry, hatte nur in 'er 10.2 Release 1 geguckt , aber JIRA is och nich dat Schnellste.
Es gibt 'nen Bugfix ... du mußt ihn dir nur kaufen.

Muß nur nochmal wer Testen, ob's wirklich geht.

Zitat:

List of new features and customer reported issues fixed in RAD Studio 10.2 Tokyo Release 2

RSP-19091
Stackoverflow error in TArray.QuickSort and System.Classes.QuickSort
RTL, RTL\Delphi

http://edn.embarcadero.com/article/44770