asm für meine VeryLongInteger-Unit

[Talia]

Hallo,

ich habe gerade meine alte VLInt auf Operatoren-Überladung umgestellt. Da sie nun nach einigen Schwierigkeiten mit BitwisAAnd (grr, Embacadero!) nach außen durch einfache Bedienbarkeit glänzt, will ich jetzt die inneren Werte aufpolieren und einige Prozeduren durch Assembler ersetzen.

Die Ziffern sind in einer TList namens FDigits mit der Basis 2^32 organisiert, 0 = nil, das Vorzeichen steckt in einem Boolean.

Meine alte TVLInt.Implicit sieht so aus:

Delphi-Quellcode:

class operator TVLInt.Implicit(const a: Cardinal): TVLInt;
begin
  Result.Create;       // FDigits := TList.Create;  FIsNegative := False;
  Result[0] := a;      // FDigits[Ind] := Pointer(Val);
end;

Hier versammeln sich meine asm-Probleme: (Rechnen klappt teilweise schon ganz gut)

1. Das Anlegen von FDigits
2. Zuweisen von FDigits.Capacity
3. FDigits <= a

Delphi-Quellcode:

class operator TVLInt.Implicit(const a: Cardinal): TVLInt;
  asm
    // eax <= a

                             // mov [edx], eax     ???

    // edx = @Result[0]
  end;

Kann mir vielleicht jemand zeigen, wie das geht?


Gruß Talia

[Neutral General]

Hallo,

Ganz ehrlich?
Du hast nichts davon.
Du wirst es mit Assembler nicht schneller bekommen.
Lass es einfach so ;)

Gruß
Neutral General

[Talia]

Hallo, Herr General!

Ich will gar nicht unbedingt die schnellste VLInt des Planeten schreiben, ist bloß grundsätzliches, "akademisches" Interesse, wie sowas geht. :wink:

Gruß Talia

[Neutral General]

Hallo,

Habs jetzt auch nicht direkt hinbekommen.
Aber als Tipp:
Schreib den Code mal ganz normal in Delphi und setz dann nen Breakpoint auf die 1. Anweisung.
Wenn der Debugger anhält dann drück mal Strg+Alt+C.
Dann siehst du welcher Assembler-Code dahinter steckt! ;)

[himitsu]

Es gibt Codes, da hat man absolut nichts von Assembler, außer daß der Code eher unübersichtlicher wird.
Und diese eine Funktion gehört mit dazu.
Ob sich andere Methoden durch ASM optimieren lassen, kann man nicht sagen, da wir ja sonst noch nichts gesehn haben.

Wie ist denn Create definiert?
Entweder das ist ein Create und gibt den neuen "Integer" als Result zurück,
oder es sollte besser Init heißen ... so sieht es eher "falsch" aus,
jedenfalls wenn man es mit dem bekannten Create der Objekte vergleicht.

[Talia]

Hallo,

danke für den Strg+Alt+C - Tipp. Ich habe mich gerade durch Delphis asm-Umsetzung geF7t und finde jetzt auch, daß das Ganze eine blöde Idee war. :oops:

Ich werde nur die grundlegenden Rechnungen umschreiben, damit habe ich genug zu tun.

Create erzeugt übrigens nur eine leere Liste FDigits und setzt FIsNegative auf False. Den Teil werde ich nicht verändern.

Gruß Talia

[himitsu]

PS: Die TList in deinem "Record".
Sicher das du keine Speicherlecks und andere Probleme damit verursachst?

Mein Vorschlag die Speicherverwaltung für derartige Records zu erweitern,
um derartige Objekte "ordentlich" innerhalb dieser Records verwalten zu können,
wurde bisher immernoch hartnäckig von Embarcadero ignoriert.

http://qc.embarcadero.com/wc/qcmain.aspx?d=82524

[Talia]

Hallo,

ich schwenke jetzt wohl doch um auf einen array of Cardinal für die Ziffern. Die TList war nur auf den ersten Blick so praktisch dadurch, daß sie sich selbst um ihre Länge kümmert und .Count liefert. Schade, nun habe ich doch die Probleme mit der blöden SetLengtherei am Hals.

Gruß Talia

[himitsu]

Und Achtung, "normale" dynamische Arrays haben keine Referenzkontrolle in den Schreibzugriffen implementiert.
(Strings sind zwar auch "nur" dynamische Arrays, aber diese besitzen soeine Kontrolle)

Delphi-Quellcode:

var
  a, b: array of Integer;

SetLength(a, 10);
a[5] := 20;
b := a;
b[5] := 30;
ShowMessage(IntToStr(a[5])); // a[5] = 30 ???

SetLength(a, 10);
a[5] := 20;
b := a;
SetLength(b, Length(b)); // vor Schreibzugriffen auf ein Array
b[5] := 30;
ShowMessage(IntToStr(a[5])); // juhu, a[5] ist noch 20 :)

Auch gibt es ein immernoch nicht behobenes Compiler-Problem, wenn in dem Record nur ein Array und kein weiteres Feld enthalten ist.

PS: von mir gammeln in der DP einige Prototypen/Vorlagen rum, für derartige Typen.

[Talia]

So, ich habe schon wieder umdisponiert, bin wohl etwas flatterhaft:

Delphi-Quellcode:

const
  MaxDigits = 1039;    // (2^32)^1040 = 1,89782E10018 => 10.000 dezi Stellen o.K.

type
  TVLInt = packed record
  strict private
    Digits: array[0..MaxDigits] of Cardinal;
    IsNegative: Boolean;
    Length: Integer;
    ...
  public
    class operator Implicit(const a: Cardinal): TVLInt;
    ...


implementation

class operator TVLInt.Implicit(const a: Cardinal): TVLInt;
asm
  // eax <= a
  mov [edx], eax
  mov edx.IsNegative, 0
  xor ecx, ecx
  test eax, eax    // ZF if eax = 0
  jz @@IsZero
  add ecx, 1
@@IsZero:
  mov edx.Length, ecx
  // edx = @Result
end;

So läßt es sich leicht rechnen und ich muß mir keine Gedanken um Speicherlecks u. ä. machen. 10.000 dez Ziffern sind für alle meine Anwendungen mhr als genug. Den übertriebenen Speicherverbrauch werde ich wohl verschmerzen.

Gruß Talia

[himitsu]

Delphi-Quellcode:

mov [edx], eax
mov edx.IsNegative, 0

Ich bin mir grad nicht so sicher, ob das richtigrum ist.

EAX = Self (der Record selber)
EDX = 1. Parameter, also a

Bei dir sieht es so aus, als wenn du es andersrum machst. :gruebl:

[Talia]

Hallo himitsu,

ja, darüber habe ich mich auch gewundert, aber so funktioniert es wirklich. Im Internet habe ich hierzu 2 Infos gefunden:

1. Bei Methoden: EAX = Self, EDX, ECX

2. Liefert eine Funktion einen array als Ergebnis, wird er behandelt wie eine zusätzliche Var.

Keine Ahnung, warum hier 2. gilt.


Ich habe nochmal an meiner Deklaration rumgefummelt, würde doch lieber einen dyn array verwenden, um für alle Fälle gerüstet zu sein:

Delphi-Quellcode:

type
  TVLInt = record
  strict private
    Digits: array of Cardinal;
    IsNegative: Boolean;
    Length: Integer;
    ...
  public
    class operator Implicit(const a: Cardinal): TVLInt;
    ...
  end;


implementation 

class operator TVLInt.Implicit(const a: Cardinal): TVLInt;
begin
  SetLength(Result.Digits,1);
  Result.Digits[0] := a;
  Result.Length := Integer(a > 0);
end;

Dann habe ich mir mit Strg-Alt-c angeguckt, was Delphi beim Anlegen so treibt und folgendes geguttenbergt:

Delphi-Quellcode:

class operator TVLInt.Implicit(const a: Cardinal): TVLInt;
// eax <= a
asm
// MyVLInt.pas.41: begin
  push ebx
  push esi
  mov ebx,edx
  mov esi,eax
// MyVLInt.pas.42: SetLength(Result.Digits,1);
  push $01
  mov eax,ebx
  mov ecx,$00000001
  mov edx,[$00455c9c]  // ???  typeInfo??
  call System.@DynArraySetLength
  add esp,$04
// MyVLInt.pas.43: Result.Digits[0] := a;
  mov eax,[ebx]
  mov [eax],esi
// MyVLInt.pas.44: Result.Length := Integer(a > 0);
  test esi,esi
  setnbe al
  and eax,$7f
  mov [ebx+$05],eax
// MyVLInt.pas.71: end;
  pop esi
  pop ebx
  ret
end;

Es gibt hier Schwierigkeiten mit DynArraySetLength (Zugriffsverletzung).

Emba schreibt: DynArraySetLength(var a: Pointer; typeInfo: Pointer; dimCnt: Longint; lengthVec: PLongint);

aber wie man edx richtig bestückt ist mir nicht klar. Ich habe einiges ausprobiert, produziere aber immer Murks.


Gruß Talia

[Talia]

Hallo,

als Notlösung habe ich jetzt eine globale Variable eingeführt und unter initialization TypeInfo zugewiesen. Nicht besonders OOP, funktioniert aber.

Gruß Talia