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.

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.

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