Windows.GetTickCount64 auch unter Windows XP?

[Zacherl]

Hier gibt es dazu noch einen Artikel mit Workarounds:
http://terryto-blog.tumblr.com/post/...4-alternatives

[Glados]

Zacherl, dein Artikel hat mich neugierig gemacht und die Schnelligkeit von _GetTickCount64 geprüft.

bei 999.999 aufrufen dauert die Ausführung schon knapp 400ms. Windows.GetTickCount54 braucht nur knapp 25ms.

[Zacherl]

Welche der Versionen hast du denn verwendet? Die mit dem manuellen Overflow Check sollte die Performance nicht nennenswert verschlechtern (laut Artikel ist sie ja angablich sogar besser als die native GetTickCount64 API).

[Glados]

Ich habe himitu's Version (Link erster Beitrag) verwendet. Mit den anderen kann ich nichts anfangen, da es kein Delphi-Code ist.

Mehr als das hier bekomme ich nicht hin und selbst das ist bestimmt noch falsch

Delphi-Quellcode:

var
 high, lastLow: Int64;
begin
 high := 0;
 low := GetTickCount();

 if lastLow > low then
  // high += 0x100000000I64; ...

 lastLow = low;

 // return high | (ULONGLONG)low;
end;

[Zacherl]

Sollte in etwa so aussehen:

Delphi-Quellcode:

threadvar
  High: UInt64;
  LastLow: Cardinal;

function _GetTickCount64: UInt64; inline;
var
  Low: Cardinal;
begin
  Low := GetTickCount;
  if (LastLow > Low) then
  begin
    High := High + $0000000100000000;
  end;
  LastLow := Low;
  Result := High or Low;
end;

Ist etwas weniger als halb so performant wie die native Funktion, aber immer noch deutlich schneller als mit QueryPerformanceCounter. Wenn du garantiert nur einen Thread hast, kannst du das threadvar auch durch var ersetzen - dann ist die Funktion in etwa gleich schnell wie die native Variante.

[Glados]

Ich habe das jetzt so gelößt

Delphi-Quellcode:

unit uGetTickCount64;

interface

uses
 Winapi.Windows, System.SysUtils;

threadvar High: UInt64;
LastLow:
Cardinal;

type
 TGetTickCount = class
 public
  class function GetTickCount64: UInt64; inline;
 end;

implementation

class function TGetTickCount.GetTickCount64: UInt64;
var
 Low: Cardinal;
begin
 if System.SysUtils.TOSVersion.Major >= 6 then // alles ab Windows Vista
  Result := Winapi.Windows.GetTickCount64
 else // alles vor Windows Vista
  begin
   Low := GetTickCount;
   if (LastLow > Low) then
    High := High + $0000000100000000;

   LastLow := Low;
   Result := High or Low;
  end;
end;

end.

[Neutral General]

PS: Klassen sind optional und nicht immer notwendig oder sinnvoll

[Zacherl]

Zitat von Neutral General:

PS: Klassen sind optional und nicht immer notwendig oder sinnvoll

Würde stattdessen auch einfach eine freistehende Funktion (ggfls. in einer seperaten Unit) bevorzugen.

Wenn es doch umbedingt in einer "Klasse" sein soll, dann klatsch noch ein static vor das inline und mach das class zu record , dann sparst du dir noch ein (verstecktes) Funktionsargument und zusätzlich die (nicht benötigten) RTTI-Infos für die Klasse. Und dann kannst du auch die threadvar s direkt noch mit in den Record übernehmen.

[Zacherl]

Delphi-Quellcode:

type
  TTest = record
  strict private
    class threadvar High: UInt64;
    class threadvar LastLow: Cardinal;
  public
    class function GetTickCount64: UInt64; static; inline;
  end;

{ TTest }

class function TTest.GetTickCount64: UInt64;
begin
  // ...
end;

[TRomano]

Also habe ich das richtig verstanden, dass Du einfach nur die Ticks auslesen willst ? Wenn ja, wieso dann so kompliziert ?

Delphi-Quellcode:

function GetTicks : UInt64; register;
asm
  rdtsc
{$IFDEF WIN64} 
  shl rdx, 32
  or rax, rdx
{$ENDIF}
end;

Das sollte für rudimentäre Zwecke reichen. Willst Du ganz exaktes Messen veranstalten, da nimm doch die Routine von Agner Fog (Optimierungs Papst) :

Delphi-Quellcode:

function GetTicks : UInt64;
asm
{$IFDEF CPUX64}
  .NOFRAME
  // by Agner Fog
  push    rbx                    // ebx is modified by cpuid
  sub     rax, rax               // 0
  cpuid                          // serialize
  rdtsc                          // read time stamp counter into edx:eax
  shl     rdx, 32
  or      rax, rdx               // combine into 64 bit register        
  push    rax
  sub     eax, eax
  cpuid                          // serialize
  pop     rax                    // return value
  pop     rbx
  ret
{$ELSE}
  push    ebx                    // ebx is modified by cpuid
  sub     eax, eax               // 0
  cpuid                          // serialize
  rdtsc                          // read time stamp counter
  push    eax
  push    edx
  sub     eax, eax
  cpuid                          // serialize
  pop     edx
  pop     eax
  pop     ebx
  ret
{$ENDIF}
end;

Um auf das "Tick" genau zu sein, müsstest Du dann zusätzlich die Funktion hintereinander aufrufen und die Differenz bilden. Bei späteren Messungen ist diese Differenz (verursacht von dem Funktionsaufruf) abzuziehen.

Gruß Thomas