Programban a másodperc ezred részénél kisebb szünetet mivel lehet elérni? (akár másodperc milliomod részét vagy annál nagyobbat venni).

Ha gondolod itt van egy alap ami Delphi alatt működik. Küzdjél vele, hogy olyan időzítőd legyen amilyet te akarsz :)

uses windows;

procedure getCPUticks(var count: Int64);

var CPUclock : double; //CPU clock speed in MHz

implementation

procedure getCPUticks(var count: Int64);

//store 64 bits CPU clock in variable count

begin

asm

mov ECX,count;

RDTSC; //lower 32 bits --> EAX, upper 32 bits ---> EDX

//RDTSC = DB $0F,$31

mov [ECX],EAX;

add ECX,4;

mov [ECX],EDX;

end;

end;

procedure setCPUclock;

//set variable CPUclock

var t1,t2 : cardinal; //system clock ticks

cput1,cput2 : Int64; //CPU clock ticks

begin

t1 := getTickCount; //get milliseconds clock

while getTickCount = t1 do; //sync with start of 1 millisec interval

getCPUticks(cput1); //get CPU clock count

t1 := gettickcount;

repeat

getCPUticks(cput2); //get CPU clock count

t2 := gettickcount;

until t2-t1 >= 500;

CPUclock := (cput2-cput1)/((t2-t1)*1e3); //set CPU clock in microsecs

end;

initialization

setCPUclock;

end.

C++ alatt, 376 nanoszekundum volt a legrövidebb idő amit kitudtam sajtolni belőle, így maradtam a mikroszekundumnál. Természetesen a processzor egy magját teljesen lefoglalja. 1 mikroszekundum 1,e-6 másodperc.

void MySleep(const long long us)

{

auto startTime = std::chrono::high_resolution_clock::now();

for (; std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::high_resolution_clock::now() - startTime).count() < us;) {}

}

A fejlesztőnek nincs nagyon beleszólása az ütemező és a megszakítások működésébe egy Windows estében (feltételezem hogy Windows, mert nem írtál mást), ezért nem tudok elképzelni olyan feladatot aminél lehetne erre hagyatkozni a helyes működés biztosításához és lenne is értelme.

A Sleep, Delay és társai nagyon pontatlanok amik az ütemezőre és a megszakításokra hagyatkoznak, megspórolva értékes CPU ciklusokat. Már az is pontosabb ha egy while ciklusban addig kérd el az időt QueryPerformanceCounter hívással, amíg le nem telt a várakozni kívánt idő. Nem tartom kizártnak hogy az ezredmásodpercnél töredékénél is pontosabb így.

A probléma az, hogy az ütemező felbontása 1/64s, azaz 15.625ms. Ha a sleep vagy bármi más feladja a futást, az ütemező csak akkor tudja visszaadni legközelebb a CPU-t, amikor letelik a 15.625ms periódus.

Ha a feladat megköveteli az ilyen pontosságot akkor fontolóra kell venni a valósidejű operációs-rendszerek használatát. (VxWorks, QNX, eCos, RTLinux és társaik)

Nem valószínű, de lehet hogy ha el tudnád érni a HPET-et, akkor meg tudnád oldani ezt a problémát. Egy próbát azért megér:

[link]