ASM-Funktion Verständnisfrage und anpassen (asm > Delphicode? bzw asm x86 > x64?)

[DieDolly]

Aus einem interessanten aber relativ komplizierten Algorithmus habe ich diese Funktion

Delphi-Quellcode:

function randInt_MT19937(Range: LongInt): LongInt;
asm
 PUSH  EAX
 CALL  genrand_MT19937
 POP   EDX
 MUL   EDX
 MOV   EAX,EDX
end;

Das ist im Prinzip ein Random().
Der parameter Range wird in EAX geschrieben. Wie würde diese Funktion aber aussehen, wenn als Parameter Min, Max: LongInt dort stände?

https://www.guidogybels.eu/asmch2.html
Hier steht man schreibt den zweiten Parameter in EDX aber der wird schon verwendet.

Danach wird genrand_MT19937 aufgerufen. Aber woher weiß die Funktion, was Range ist?

Delphi-Quellcode:

function genrand_MT19937: LongInt;
const
 mag01: array [0 .. 1] of LongInt = (0, MT19937MATRIX_A);
var
 y: LongInt;
 kk: Integer;
begin
 if mti >= MT19937N{generate MT19937N longints at one time}
 then
  begin
   if mti = (MT19937N + 1) then // if sgenrand_MT19937() has not been called,
    sgenrand_MT19937(4357); // default initial seed is used
   for kk := 0 to MT19937N - MT19937M - 1 do
    begin
     y := (mt[kk] and MT19937UPPER_MASK) or (mt[kk + 1] and MT19937LOWER_MASK);
     mt[kk] := mt[kk + MT19937M] xor (y shr 1) xor mag01[y and $00000001];
    end;
   for kk := MT19937N - MT19937M to MT19937N - 2 do
    begin
     y := (mt[kk] and MT19937UPPER_MASK) or (mt[kk + 1] and MT19937LOWER_MASK);
     mt[kk] := mt[kk + (MT19937M - MT19937N)] xor (y shr 1) xor mag01[y and $00000001];
    end;
   y := (mt[MT19937N - 1] and MT19937UPPER_MASK) or (mt[0] and MT19937LOWER_MASK);
   mt[MT19937N - 1] := mt[MT19937M - 1] xor (y shr 1) xor mag01[y and $00000001];
   mti := 0;
  end;
 y := mt[mti];
 inc(mti);
 y := y xor (y shr 11);
 y := y xor (y shl 7) and TEMPERING_MASK_B;
 y := y xor (y shl 15) and TEMPERING_MASK_C;
 y := y xor (y shr 18);
 Result := y;
end;

Die Unit gibt es hier
http://www.gokiburi.de/MT19937.pas

[Uwe Raabe]

Zitat von DieDolly:

Danach wird genrand_MT19937 aufgerufen. Aber woher weiß die Funktion, was Range ist?

Das muss sie gar nicht. genrand_MT19937 liefert einen zufälligen Longint zurück, der in Folge mit Range multipliziert wird. Da diese Multiplikation in 32-Bit durchgeführt wird, entspricht das einem impliziten modulo 2^32. Man kann nachweisen, daß das Ergebnis kleiner als die beiden Multiplikanden ist (kann den Nachweis nur gerade nicht finden).

Der ASM-Code liest sich in etwa so:

Delphi-Quellcode:

 PUSH EAX               { Parameter 1 = Range auf Stack sichern }
 CALL genrand_MT19937   { Random Longint aufrufen, Ergebnis steht in EAX (keine Parameter)}
 POP EDX                { Range vom Stack in EDX holen }
 MUL EDX                { EAX mit EDX multiplizieren }
 MOV EAX,EDX            { Ergebnis in result = EDX zurückgeben }

Wenn du einen Range-Min/Max willst, würde ich einen Wrapper um diese Funktion machen:

Delphi-Quellcode:

function RandInt_Range(AMin, AMax: Longint): Longint;
begin
  Result := randInt_MT19937(AMax - AMin) + AMin;
end;

[DieDolly]

Zitat:

Da diese Multiplikation in 32-Bit durchgeführt wird

Das merke ich gerade, wo ich mit 64bit kompilieren möchte. Da scheint es PUSH wohl nicht zu geben.

Wenn ich randInt_MT19937 mit Hilfe deiner Kommentare in normalen Delphi-Code umwandle, hat das irgendwelche Nachteile?
Wenn nicht, würde ich das machen.

Delphi-Quellcode:

function randInt_MT19937(Range: LongInt): LongInt;
begin
 Result := Range * genrand_MT19937;
end;

function randInt_MT19937(Min, Max: LongInt): LongInt;
begin
 Result := randInt_MT19937(Max - Min) + Min;
end;

Diese Funktion schmeiße ich dann raus

Delphi-Quellcode:

function randFloat_MT19937: Double;
const
 Minus32: Double = -32.0;
 asm
  CALL    genrand_MT19937
  PUSH    0
  PUSH    EAX
  FLD     Minus32
  FILD    qword ptr [ESP]
  ADD     ESP,8
  FSCALE
  FSTP    ST(1)
end;

[Uwe Raabe]

Zitat von DieDolly:

Das merke ich gerade, wo ich mit 64bit kompilieren möchte. Da scheint es PUSH wohl nicht zu geben.

64-Bit Assembler ist anders als 32-Bit Assembler. Sind beide Ziele gewünscht, würde ich auf ASM weitestgehend verzichten.

Zitat von DieDolly:

Wenn ich randInt_MT19937 mit Hilfe deiner Kommentare in normalen Delphi-Code umwandle, hat das irgendwelche Nachteile?
Wenn nicht, würde ich das machen.

Klar geht das. Du solltest dann halt das Overflow-Checking abschalten, sonst gibt es höchstwahrscheinlich Exceptions.

[DieDolly]

Delphi-Quellcode:

function randInt_MT19937(Range: LongInt): LongInt;
begin
 Result := Range * genrand_MT19937;
end;

function randInt_MT19937(Min, Max: LongInt): LongInt;
begin
 Result := randInt_MT19937(Max - Min) + Min;
end;

Ist es normal, dass randInt_MT19937(50, 60) alles zurückgibt, außer eine Zahl zwischen 50 und 60?

Die erste Funktion verstehe ich aber auch nicht. Wenn ich randInt_MT19937(100) eingebe, bekomme ich auch alles zurück. Aber es stoppt nicht bei der 50.
Negative Zahlen kommen auch manchmal raus.
Der ASM-Code macht hingegen das was er soll.

Das hier mal Zeile für Zeile übersetzt

Delphi-Quellcode:

asm
 PUSH EAX {Parameter 1 = Range auf Stack sichern}
 CALL genrand_MT19937 {Random Longint aufrufen, Ergebnis steht in EAX (keine Parameter)}
 POP EDX {Range vom Stack in EDX holen}
 MUL EDX {EAX mit EDX multiplizieren}
 MOV EAX,EDX {Ergebnis in result = EDX zurückgeben}
end;

Erst kommt Range in EAX. Dann wird das Resultat von genrand_MT19937 in EAX geschrieben. Range in EAX wird überschrieben.
Jetzt ist Range plötzlich in EDX (?) und danach wird EAX mit EDX multipliziert.

[Uwe Raabe]

Ich muss die Beschreibung des MOV Befehls korrigieren (ist schon 'ne Weile her mit ASM): Die Richtung ist anders herum

Delphi-Quellcode:

asm
 PUSH EAX {Parameter 1 = Range auf Stack sichern}
 CALL genrand_MT19937 {Random Longint aufrufen, Ergebnis steht in EAX (keine Parameter)}
 POP EDX {Range vom Stack in EDX holen}
 MUL EDX {EAX mit EDX multiplizieren, Ergebnis steht in EDX,EAX }
 MOV EAX,EDX {Die höheren 32-Bits in EDX als result in EAX zurückgeben }
end;

Der Delphi-Code sähe dann so aus:

Delphi-Quellcode:

  
Result := Int64Rec(Int64(Range) * genrand_MT19937).Hi;

[DieDolly]

Mh ich verstehe es nicht.
Jetzt bekomme ich fast immer negative Zahlen wenn man zum Beispiel 10 als Range angibt und ich verstehe grundsätzlich nicht warum.

Bei Range 10 gehen die Ergebnisse ziemlich genau von -5 bis +5.

[Uwe Raabe]

Zitat von DieDolly:

Jetzt bekomme ich fast immer negative Zahlen wenn man zum Beispiel 10 als Range angibt und ich verstehe grundsätzlich nicht warum.

Bei Range 10 gehen die Ergebnisse ziemlich genau von -5 bis +5.

Das halte ich für unwahrscheinlich. Int64Rec.Hi ist als Cardinal deklariert. Da sind negative Werte eher selten zu erwarten.

[DieDolly]

Teste es =) Irgendwas ist hier ganz seltsam. Das verstehe ich ja auch nicht.

Delphi-Quellcode:

function randInt_MT19937(Range: LongInt): LongInt;
begin
 Result := Int64Rec(Int64(Range) * genrand_MT19937).Hi;
end;

procedure TForm1.FormCreate(Sender: TObject);
var
 i: Integer;
 x: string;
begin
 for i := 0 to 30 do
  x := x + sLineBreak + IntToStr(randInt_MT19937(10));
 
 ShowMessage(x);
end;

Code:

[Window Title]
Project1

[Content]

1
1
-4
3
-4
-4
3
-1
-3
3
-1
-3
-2
0
2
-5 ////////
-4
2
0
-1
-3
-2
-3
3
-3
5 ////////
2
-3
-4
3
3

[OK]

[Uwe Raabe]

Das Problem ist, daß genrand_MT19937 als LongInt deklariert ist, wo es das doch gar nicht sein sollte.

Result := Int64Rec(Int64(Range) * Cardinal(genrand_MT19937)).Hi;