By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
446,266 Members | 1,862 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 446,266 IT Pros & Developers. It's quick & easy.

High resolution Sleep

P: n/a
Sleep() function Sleep at lease 1 millisecond, there is a way to make a
thread to sleep less than a millisecond? One way I know of is using
performance counter which is not really sleep ( loop and check again and
again and uses CPU time).

Thanks

Charles Zhang
Apr 2 '08 #1
Share this Question
Share on Google+
13 Replies


P: n/a
Even Sleep() doesn't have true 1 ms resolution.

There's no better timer than the performance counter in Windows AFAIK.

Mark

--
Mark Salsbery
Microsoft MVP - Visual C++
"Charles Zhang" <Ch**********@newsgroups.nospamwrote in message
news:Ov**************@TK2MSFTNGP02.phx.gbl...
Sleep() function Sleep at lease 1 millisecond, there is a way to make a
thread to sleep less than a millisecond? One way I know of is using
performance counter which is not really sleep ( loop and check again and
again and uses CPU time).

Thanks

Charles Zhang
Apr 2 '08 #2

P: n/a
and.. what about with time struct?

hh:mm:ss,dd

where 99>=dd>=0

dd are miliseconds...

and thinking a little more, what about cpu cicles?


"Mark Salsbery [MVP]" <MarkSalsbery[MVP]@newsgroup.nospamescribió en el
mensaje news:75**********************************@microsof t.com...
Even Sleep() doesn't have true 1 ms resolution.

There's no better timer than the performance counter in Windows AFAIK.

Mark

--
Mark Salsbery
Microsoft MVP - Visual C++
"Charles Zhang" <Ch**********@newsgroups.nospamwrote in message
news:Ov**************@TK2MSFTNGP02.phx.gbl...
>Sleep() function Sleep at lease 1 millisecond, there is a way to make a
thread to sleep less than a millisecond? One way I know of is using
performance counter which is not really sleep ( loop and check again and
again and uses CPU time).

Thanks

Charles Zhang

Apr 2 '08 #3

P: n/a
You can use "clockres" from Sysinternals (today Microsoft) to see the
minimum resolution in your machine. Mine (Quad core is 15.6 ms).

I think less than 15 ms is impossible, and surely a sleep of 15 ms becomes
in a lot of more time because Windows uses that sleeping to do other tasks,
and if you put a for() loop you will get your CPU time scalated to 100% and
surely with no more precission that sleep.

"Charles Zhang" <Ch**********@newsgroups.nospamwrote in message
news:Ov**************@TK2MSFTNGP02.phx.gbl...
Sleep() function Sleep at lease 1 millisecond, there is a way to make a
thread to sleep less than a millisecond? One way I know of is using
performance counter which is not really sleep ( loop and check again and
again and uses CPU time).

Thanks

Charles Zhang
--
Microsoft Visual C++ MVP
========================
Mi blog sobre programación: http://geeks.ms/blogs/rfog
Momentos Leves: http://momentosleves.blogspot.com/
Libros, ciencia ficción y programación
========================================
Es un hecho que el hombre tiene que controlar la ciencia y chequear
ocasionalmente el avance de la tecnología.
-- Thomas Henry Huxley.

Apr 2 '08 #4

P: n/a
Hi RFOG!
I think less than 15 ms is impossible, and surely a sleep of 15 ms
becomes in a lot of more time because Windows uses that sleeping to do
other tasks, and if you put a for() loop you will get your CPU time
scalated to 100% and surely with no more precission that sleep.
If you use "timeBeginPeriod(1)" you can mostly reduce the time-slice to
2 ms.

Greetings
Jochen
Apr 2 '08 #5

P: n/a
"Jochen Kalmbach [MVP]" <no********************@holzma.dewrote in message
news:%2******************@TK2MSFTNGP05.phx.gbl...
Hi RFOG!
>I think less than 15 ms is impossible, and surely a sleep of 15 ms
becomes in a lot of more time because Windows uses that sleeping to do
other tasks, and if you put a for() loop you will get your CPU time
scalated to 100% and surely with no more precission that sleep.

If you use "timeBeginPeriod(1)" you can mostly reduce the time-slice to 2
ms.

Greetings
Jochen

True, but this won't guarantee that your thread will get scheduled right
after 2ms. The scheduler is master of the game here, once you give up your
quantum, you'll have to wait until all other higher priority threads have
run.

Willy.

Apr 2 '08 #6

P: n/a
Hi Willy!
True, but this won't guarantee that your thread will get scheduled right
after 2ms. The scheduler is master of the game here,
Yes...
once you give up
your quantum, you'll have to wait until all other higher priority
threads have run.
No. If a higher prio thread becomes ready to run, your quantum does not
matter. Your thread will be immediately interrupted and the higher prio
thread will run.

Greetings
Jochen
Apr 2 '08 #7

P: n/a
Hi Willy!
No.
I wanted to say: This is only some side of the truth... sorry...

Greetings
Jochen
Apr 2 '08 #8

P: n/a
Charles Zhang wrote:
Sleep() function Sleep at lease 1 millisecond, there is a way to make
a thread to sleep less than a millisecond? One way I know of is using
performance counter which is not really sleep ( loop and check again
and again and uses CPU time).
Waitable Timers allow the wait to be specified very precisely, however the
actual resolution will depend on the system clock interrupt.
timeBeginPeriod can make the clock interrupt faster to a point, I don't know
of any user-mode way to set the interrupt rate above 1kHz.
>
Thanks

Charles Zhang

Apr 2 '08 #9

P: n/a
"Ben Voigt [C++ MVP]" <rb*@nospam.nospamwrote in message
news:Ok**************@TK2MSFTNGP05.phx.gbl...
Willy Denoyette [MVP] wrote:
>"Jochen Kalmbach [MVP]" <no********************@holzma.dewrote in
message news:OF*************@TK2MSFTNGP06.phx.gbl...
>>Hi Willy!

True, but this won't guarantee that your thread will get scheduled
right after 2ms. The scheduler is master of the game here,

Yes...

once you give up your quantum, you'll have to wait until all other
higher priority threads have run.

No. If a higher prio thread becomes ready to run, your quantum does
not matter. Your thread will be immediately interrupted and the
higher prio thread will run.

Hi Jochen,

I mean :
T1 normal priority calls sleep(2) - that is, give up your quantum now!
T2 normal priority gets scheduled runs for 1msec and enters a wait
state T3 higher priority gets scheduled and runs for 1 sec.
T1 as slept ~1 sec

This isn't a drawback to calling sleep though, any wait method could be
pre-empted by a higher priority thread.
True, and for the same reason you can't use them to "wait" for an "exact"
(especially small) amount of time when running on a Windows OS (even not on
Windows CE). Point is that once your (1) thread enters a wait state, you are
at the "mercy" of the scheduler to (2) wake you up. You are under control of
the first action, but you aren't of the second.
So whether you call Sleep(1) or WaitForSingleObject(..., 1), you will wait
for at *least* the RTC timer interval, whatever it's value.

Willy.

Apr 2 '08 #10

P: n/a

"Jordi Maycas" <jm***********@hotmail.comwrote in message
news:el**************@TK2MSFTNGP06.phx.gbl...
and.. what about with time struct?

hh:mm:ss,dd

where 99>=dd>=0

dd are miliseconds...

Yes, many APIs have 1ms units in parameters. Some use 100-nanosecond units.
But the actual accuracy is much less than 1ms.

See Charles Wang's response below...

>
and thinking a little more, what about cpu cicles?

Now you're at the performance counter level :)

Mark

--
Mark Salsbery
Microsoft MVP - Visual C++
>

"Mark Salsbery [MVP]" <MarkSalsbery[MVP]@newsgroup.nospamescribió en el
mensaje news:75**********************************@microsof t.com...
>Even Sleep() doesn't have true 1 ms resolution.

There's no better timer than the performance counter in Windows AFAIK.

Mark

--
Mark Salsbery
Microsoft MVP - Visual C++
"Charles Zhang" <Ch**********@newsgroups.nospamwrote in message
news:Ov**************@TK2MSFTNGP02.phx.gbl...
>>Sleep() function Sleep at lease 1 millisecond, there is a way to make a
thread to sleep less than a millisecond? One way I know of is using
performance counter which is not really sleep ( loop and check again and
again and uses CPU time).

Thanks

Charles Zhang

Apr 2 '08 #11

P: n/a
You can get Sleep() delay on XP close to the current timer resolution
but measuring the actual sleep time can be difficult.
I've made a simple test based on Sysinternals clockres sample.

The minimal resolution is 1 or 2 ms on most modern systems where the
default is 15.6 ms, and 1 ms on older systems where the default was 10 ms.
AFAIK there still is no good explanation why the newer PCs have default
resolution 10 ms.

Surprising is that value returned by GetSystemTimeAsFileTime or
NtQuerySystemTime
seems to update only once in system clock tick (15.6 ms in my case),
so when I call GetSystemTimeAsFileTime before and after Sleep(1), I got
_same_ value 7 times out of 8;
and on 8th time the difference jumps to 15 ms :( So the average Sleep()
delay of many samples is close to 1 ms.

Regards,
--PA
Apr 2 '08 #12

P: n/a
Pavel A. wrote:
You can get Sleep() delay on XP close to the current timer resolution
but measuring the actual sleep time can be difficult.
Not difficult, just use QueryPerformanceCounter.
I've made a simple test based on Sysinternals clockres sample.

The minimal resolution is 1 or 2 ms on most modern systems where the
default is 15.6 ms, and 1 ms on older systems where the default was
10 ms. AFAIK there still is no good explanation why the newer PCs
have default resolution 10 ms.

Surprising is that value returned by GetSystemTimeAsFileTime or
NtQuerySystemTime
seems to update only once in system clock tick (15.6 ms in my case),
so when I call GetSystemTimeAsFileTime before and after Sleep(1), I
got _same_ value 7 times out of 8;
and on 8th time the difference jumps to 15 ms :( So the average
Sleep() delay of many samples is close to 1 ms.

Regards,
--PA

Apr 2 '08 #13

P: n/a
"Pavel A." <pa*****@NOwritemeNO.comwrote in message
news:OP**************@TK2MSFTNGP03.phx.gbl...
You can get Sleep() delay on XP close to the current timer resolution
but measuring the actual sleep time can be difficult.
I've made a simple test based on Sysinternals clockres sample.

The minimal resolution is 1 or 2 ms on most modern systems where the
default is 15.6 ms, and 1 ms on older systems where the default was 10 ms.
AFAIK there still is no good explanation why the newer PCs have default
resolution 10 ms.

Surprising is that value returned by GetSystemTimeAsFileTime or
NtQuerySystemTime
seems to update only once in system clock tick (15.6 ms in my case),
so when I call GetSystemTimeAsFileTime before and after Sleep(1), I got
_same_ value 7 times out of 8;
and on 8th time the difference jumps to 15 ms :( So the average Sleep()
delay of many samples is close to 1 ms.

Regards,
--PA



Indeed, measuring is the key, but as I said before, you can't Sleep (or
Wait) for a reliable amount of time,
when sleeping (waiting) for < RTC interval, you give up your remaining
quantum, and you may possibly get re-scheduled after this period of time,
that is, after X msec. where X >= the remaining quantum.
For instance when you call Sleep(1) after your thread has run for Y msec,
you will probably sleep for 15.6 - X msec. on current multi-core/SMP
systems.
When you call Sleep(1) after your thread consumed 10 µsec of it's quantum,
this thread will sleep for at least 15.6 msec.
When you call Sleep(1) after your thread has consumed 14 msec you will sleep
for at least 1.6 msec.
That means you cannot reliably sleep with Windows ;-)

Compile and run the following sample , you'll see what I mean.
#ifndef _WIN32_WINNT
#define _WIN32_WINNT 0x0500
#endif
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <process.h>
#include <cstdio>
#include <math.h>
unsigned __stdcall Run(void* dummy)
{
double r = 0.0;
for(int i = 0; i < 50000000; i++)
{
r += (double)sqrt((double)i);
}
printf_s("%Lf\n", r);
_endthreadex(0);
return 0;
}
int main() {
__int64 startcount, stopCount, frequ;
QueryPerformanceFrequency((LARGE_INTEGER*)&frequ);
HANDLE tHandle;
unsigned thread_Id;
Sleep(1); // Give up the current quantum so we can start with a fresh one
after return
tHandle = reinterpret_cast<HANDLE>(_beginthreadex(0, 0, &Run, 0, 0,
&thread_Id ));
QueryPerformanceCounter((LARGE_INTEGER*)&startcoun t);
Sleep(1);
//Or, use next
// WaitForSingleObject(tHandle, 1); // wait for thread to finish or timeout
QueryPerformanceCounter((LARGE_INTEGER*)&stopCount );
CloseHandle(tHandle);
printf_s("%Lf seconds\n", (double)(stopCount - startcount)/frequ);
return 0;
}

Willy.

Apr 2 '08 #14

This discussion thread is closed

Replies have been disabled for this discussion.