Elemente in Mengen mit ASM zählen

[himitsu]

Code:

00001000 00000000 10000001 => Counter wird inkrementiert 
00000100 00000000 01000000 => Counter bleibt gleich 
...
00000000 00100000 00000010 => Counter bleibt gleich 
00000000 00010000 00000001 => Counter wird inkrementiert 
00001000 00001000 [color=#ff0000]00000000[/color] => Schleife beendet

[marabu]

Hi folks,

[0,255] wird durch die Bytes [01, 00, 00, 00, 00, 00, 00, 80] repräsentiert, wenn ich nicht irre. Die Anzahl der Bytes, die einen Set repräsentieren, kann man übrigens mit SizeOf() bestimmen.

@Manuel: alle wollen dir nur mitteilen, dass dein Code nur register sets (maximal 32 Elemente) verabeitet. Dabei kann unter gewissen Umständen (packed) auch ein zu großer Wert als Ergebnis ausgewiesen werden.

Freundliche Grüße

[3_of_8]

Jetzt versteh ichs, ich hatte einen Denkfehler, ich dachte ein set of [0..255] ist 1 Byte groß...

Mein Code funktioniert natürlich nur bist zu 32 Elementen...

[Hawkeye219]

Manuel, deine Funktion erwartet Mengen mit mehr als 32 Elementen, sie verarbeitet dann aber nur die ersten 32 Elemente. Wenn du die erste Zeile entfernst, können Mengen mit bis zu 32 Elementen verarbeitet werden.

Zitat von LucasL:

Was mir noch aufgefallen ist: Für bis zu 4 Byte/32 Bit (dementsprechend bis zu 32 Elementen) wird eine Menge als Werte-, ab 33 Elementen als Referenzparameter übergeben.

Gruß Hawkeye

[LucasL]

Mit SizeOf klappts. Habs jetzt mal wie folgt gemacht und es scheint zu funktionieren, egal wieviel Platz die Menge benötigt (1 - 32 Byte).

Delphi-Quellcode:

function MySizeOf(var Menge: TMySet): Byte;
  function CountBits(C: Byte; P: Pointer): Byte;
  asm
    MOV CL, AL         // Byteanzahl nach CL
    MOV EAX, 0         // Bitzähler EAX initialisieren
    @loop1:
      MOV EBX, [EDX]   // Bits nach EBX laden
      MOV CH, 8        // Bitanzahl nach CH
      @loop2:
        ROR EBX, 1     // Niedrigstes Bit von EBX nach CF schieben
        JNC @nocarry
        ADD EAX, 1     // CF gesetzt? Dann EAX inkrementieren
        @nocarry:
        DEC CH
        JNZ @loop2
      ADD EDX, 1       // nächstes Bit adressieren
      DEC CL
      JNZ @loop1
  end;
begin
  MySizeOf := CountBits(SizeOf(Menge), @Menge);
end;

Gruß,
Lucas

[Flocke]

@LucasL: kleine Optimierung: statt

Code:

JNC @nocarry
ADD EAX, 1     // CF gesetzt? Dann EAX inkrementieren
@nocarry:

kannst du auch einfach

Code:

ADC EAX, 0     // EAX um CF inkrementieren

schreiben.

[LucasL]

Thx, und man sollte die Register, welche nicht sowieso von der Funktion als Parameter belegt werden, vorher noch mit Push bzw. am Ende mit Pop retten... So:

Delphi-Quellcode:

function Length(Menge: TMySet): Byte; overload;
    function CountBits(C: Byte; P: Pointer): Byte;
    asm
     PUSH EBX
     PUSH ECX
     MOV CL, AL         // Byteanzahl nach CL
      MOV EAX, 0         // Bitzähler EAX initialisieren
      @loop1:
        MOV EBX, [EDX]   // Bits nach EBX laden
        MOV CH, 8        // Bitanzahl nach CH
        @loop2:
          ROR EBX, 1     // Niedrigstes Bit von EBX nach CF schieben
          ADC EAX, 0     // CF zu EAX addieren
          DEC CH
          JNZ @loop2
        ADD EDX, 1       // nächstes Bit adressieren
        DEC CL
        JNZ @loop1
      POP ECX
      POP EBX
    end;
  begin
    Result := CountBits(SizeOf(Menge), @Menge);
  end;

[3_of_8]

Soweit ich das sehe, sind alle zu sichernden Register hier vom Caller zu retten. Bei ebx bin ich mir ned ganz sicher, aber die anderen iirc schon.

[LucasL]

EAX (C) und EDX (P) werden automatisch gerettet, das stimmt. EBX und ECX müssen noch zusätzlich gesichert werden, zumindest schließe ich das aus den heftigen Nebenwirkungen, wenn ich sie nicht rette ...