Merkwürdigkeit mit Sleep()

[p80286]

War Da nicht vor einiger Zeit ein thread in dem Tickcount für solche Messungen als untauglich bewertet wurde?

Da ich's nicht brauche habe ich die Alternative vergessen.
Aber wie schon oben erwähnt MUSS es so genau sein?

Gruß
K-H

[himitsu]

GetTickCount arbeitet aktuell mit einem ~16 ms-Intervall.
> z.B. QueryPerformanceCounter

[hathor]

AVERAGE RESOLUTION - bei WIN XP ca. 15.620 msec, bei meinem WIN 7 64Bit: 1 msec!
Kann jemand was dazu schreiben?
Was kann man damit anfangen? Der Wert ist sehr CPU-Last-abhängig.

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, ExtCtrls, StdCtrls;

CONST
  Floating = 255;

type msecs = real;

type
  TForm1 = class(TForm)
    Label1: TLabel;
    Timer1: TTimer;
    procedure Timer1Timer(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

function Strip(L,C:char;Str:string):string;
{L is left,center,right,all,ends}
var I :  byte;
begin
   Case Upcase(L) of
   'L' : begin       {Left}
            while (Str[1] = C) and (length(Str) > 0) do
               Delete(Str,1,1);
         end;
   'R' : begin       {Right}
            while (Str[length(Str)] = C) and (length(Str) > 0) do
               Delete(Str,length(Str),1);
         end;
   'B' : begin       {Both left and right}
            while (Str[1] = C) and (length(Str) > 0) do
               Delete(Str,1,1);
            while (Str[length(Str)] = C) and (length(Str) > 0)  do
               Delete(Str,length(Str),1);
         end;
   'A' : begin       {All}
            I := 1;
            repeat
               if (Str[I] = C) and (length(Str) > 0) then
                  Delete(Str,I,1)
               else
                  I := succ(I);
            until (I > length(Str)) or (Str = '');
         end;
   end;
   Strip := Str;
end;  {Strip}

function RealToStr(Number:extended;Decimals:byte):string;
var Temp : string;
begin
   Str(Number:20:Decimals,Temp);
   repeat
        if copy(Temp,1,1) = ' ' then delete(Temp,1,1);
   until copy(temp,1,1) <> ' ';
   if Decimals = Floating then
   begin
      Temp := Strip('R','0',Temp);
      if Temp[Length(temp)] = '.' then
         Delete(temp,Length(temp),1);
   end;
   RealToStr := Temp;
end; {RealToStr}

function resolution: msecs;
var t0 : tdatetime;
begin
    t0 := now;
    while now = t0 do ;
    result := msecsperday * (now -t0);
end;


function avgres : real;
var j : integer;
begin
    result := 0;
    for j := 1 to 100 do
       result := result + resolution;
    result := result /100;
end;

procedure TForm1.Timer1Timer(Sender: TObject);
begin
 Label1.Caption:=' Average resolution = '+ RealToStr(avgres,3)+' msec'; //15.620 msec
end;

end.

[xZise]

Zitat von p80286:

War Da nicht vor einiger Zeit ein thread in dem Tickcount für solche Messungen als untauglich bewertet wurde?[...]

Es ist nicht super genau, aber es gibt ein relativ gutes Ergebnis für den Aufwand. Wenn man mal eben was testen will, ist der PerformanceCounter schon wesentlich komplexer. Abgesehen davon wurde der ja auch schon genannt.

Und zu den ungenauen Zahlen: Ist es nicht so, dass ein Extended nicht alle Zahlen darstellen kann? Es also zwingenderweise "Sprünge" geben muss? Es kann natürlich sein, dass diese Sprünge < 1 ms sind, aber trotzdem finde ich, den Umgang mit Ganzzahlen angenehmer

MfG
Fabian

PS: Gibts nicht sowas wie "SecondsBetween". Das durch Tausend und man dürfte das richtige Ergebnis bekommen, oder (egal ob Industrieminute oder nicht )?

[Medium]

Die Genauigkeit der Zeitdarstellungen ist bei weitem gut genug. Das "Problem" ist einfach, dass der Windows Scheduler CPU Zeit an die Prozesse verteilt, und jedem Prozess ein Minimum an Zeit gewährt, die sog. kleinst mögliche Zeitscheibe. Die ist unter verscheidenen OSs unterschiedlich, aber die Essenz ist die selbe: Es ist NIEMALS gesichert, dass dein Prozess nach exakt N Millisekunden wieder an die Reihe kommt. Derartige Zusagen treffen, wie gesagt, nur Echtzeit-Betriebssysteme.

Man kann sich drehen und wenden wie man will, man wird in der "Consumer"-Windowswelt immer damit rechnen müssen, keine millisekundengenauen Scheibchen zu bekommen. Das kann per Zufall mal sein, aber damit rechnen darf ich einfach nicht. Egal mit welcher Methode. End of story.

[jfheins]

Leute ich will ja nicht rechthaberisch sein, aber ihr diskutiert jetzt schon seit ein paar Posts über ein Thema das zwar entfernt etwas mit der Ursprungsfrage zu tun hat, aber total überflüssig ist.

Der Threadersteller wollte eine Sekunde stoppen. Hat das versucht und 1160ms herausbekommen weil er aus Versehen bei der Anzeige 16% auf den eigentlichen Wert draufgeschlagen hat.

Dass GetTickCount() immer noch eine Ungenauigkeit von 10-20ms hat, ist zwar richtig - hat aber mit dem Ursprungsproblem nichts zu tun.

[Medium]

Du hast zwar prinzipiell Recht, jedoch ist das Ursprungsproblem durchaus durch die Kombination beider Ursachen zu erklären, bzw. reicht die Korrektur der Rechnung allein nicht aus, um zum vom TE erklärten Ziel zu gelangen. Da finde ich es schon sinnvoll das so weit zu tragen, damit sich der TE nachher nicht wundert, warum diese eine Maßnahme dennoch nicht alles prima macht. Jede Wette wir würden das sonst in spätestens 1-2 Tagen in einem neuen Tread genau so tun

[Shark99]

Fand die zusätzlichen Erklärungen sehr interessant, danke!

[HHennig]

Vielleicht helfen dir folgende, wohl undokumentiere API-Funktionen weiter (bisher in keiner Delphi-Unit deklariert):

Code:

function NTQueryTimerResolution(CoarsestResolution : PULONG;
                                FinestResolution   : PULONG;
                                ActualResolution   : PULONG) : longint; stdcall; external 'ntdll.dll';

function NTSetTimerResolution(RequestedResolution : ULong;
                              Set_: Boolean;
                              ActualResolution : PULONG) : longint; stdcall; external 'ntdll.dll';



procedure SetTimerResolutionFinest;
var
  CoarsestResolution:  ULONG;
  FinestResolution:    ULONG;
  ActualResolution:    ULONG;
  RequestedResolution: ULONG;
begin
  NtQueryTimerResolution(@CoarsestResolution, @FinestResolution, @ActualResolution);
  RequestedResolution := FinestResolution;
  NtSetTimerResolution(RequestedResolution, True, @ActualResolution);
end;

procedure SetTimerResolutionDefault;
var
  CoarsestResolution:  ULONG;
  FinestResolution:    ULONG;
  ActualResolution:    ULONG;
  RequestedResolution: ULONG;
begin
  NtQueryTimerResolution(@CoarsestResolution, @FinestResolution, @ActualResolution);
  RequestedResolution := CoarsestResolution;
  NtSetTimerResolution(RequestedResolution, True, @ActualResolution);
end;

begin
  // maximale Resolution setzen
  SetTimerResolutionFinest;

  // make your job...

  // Timer wieder zurücksetzen !
  SetTimerResolutionDefault;
end;

Es sollte damit tatsächlich (evtl. annähernd) Sleep(1) = 1ms sein!