Is there a faster hi resolution timer for diy profiling

[colin]

Hi,

Im trying to time some parts of my code using the Stopwatch class,
but it is so slow, I tried the QueryPerformanc eFrequency()
but this seems to be just as slow,
if I just simply call this function in a loop it takes 21 ticks
with a reported frequency of 3.5mhz
its is about 6us wich is over 12k instructions on my 2ghz cpu.
this negates the idea of having a high res timer ...

Is there any way to access the timer more directly ?
I know the cpu actually has a very high resolution timer,
it would be nice to be able to just read this value directly,
maybe il have to write a c++ library and do it in asm
thats assuming I can get the OS to grant me acces to that hardware address.

basicaly im making a diy profiler, I have a profile class
wich needs Enter(enum p) funtion at the start and a Leave()
function at the end of some functions of interest.

primarily it keeps tarck of the number of calls made,
and a lists the calling functions counts too.
it also measures the total time spent in the function and the subtracts the
time spent in
subroutins to provide an actual time too.

It works pretty quick for counts but when I use the timer it is like 20
times slower,
wich although I can live with waiting 20 minutes to collect the data it does
mean
that there is a considerable error for short functions,

I have added a fudge wich subtracts a fiddle value from the timer,
wich is increased by 21 ticks every times its called,
this might be close but its far from ideal.

Im trying to find out why/where its spending 75% of the cpu time in
mscorlib and mscorwks libraries, the amd codeanalyst identifies its spending
most of its time in a function called mscorwks::gc_he ap::adjust_limi t_clr

thanks
Colin =^.^=

[Willy Denoyette [MVP]]

"colin" <co*********@nt world.NOSPAM.co mwrote in message
news:kr******** ******@newsfe4-win.ntli.net...

Hi,

Im trying to time some parts of my code using the Stopwatch class,
but it is so slow, I tried the QueryPerformanc eFrequency()
but this seems to be just as slow,
if I just simply call this function in a loop it takes 21 ticks
with a reported frequency of 3.5mhz
its is about 6us wich is over 12k instructions on my 2ghz cpu.
this negates the idea of having a high res timer ...

Is there any way to access the timer more directly ?
I know the cpu actually has a very high resolution timer,
it would be nice to be able to just read this value directly,
maybe il have to write a c++ library and do it in asm
thats assuming I can get the OS to grant me acces to that hardware
address.

basicaly im making a diy profiler, I have a profile class
wich needs Enter(enum p) funtion at the start and a Leave()
function at the end of some functions of interest.

primarily it keeps tarck of the number of calls made,
and a lists the calling functions counts too.
it also measures the total time spent in the function and the subtracts
the time spent in
subroutins to provide an actual time too.

It works pretty quick for counts but when I use the timer it is like 20
times slower,
wich although I can live with waiting 20 minutes to collect the data it
does mean
that there is a considerable error for short functions,

I have added a fudge wich subtracts a fiddle value from the timer,
wich is increased by 21 ticks every times its called,
this might be close but its far from ideal.

Im trying to find out why/where its spending 75% of the cpu time in
mscorlib and mscorwks libraries, the amd codeanalyst identifies its
spending
most of its time in a function called mscorwks::gc_he ap::adjust_limi t_clr

thanks
Colin =^.^=

Please post your code, there must be something wrong with it,
QueryPerformanc eFrequency()
can't take 6µsec to complete.
Note that there is no need to call QueryPerformanc eFrequency(), this value
exposed by the Stopwatch class.
Willy.

[colin]

I just copied the code from here
http://msdn2.microsoft.com/en-us/lib...92(VS.80).aspx

and oops I meant the QueryPerformanc eCounter() call is taking so long ...

I just have a loop wich calls it repeatedly 100000 times to measure how long
it takes.

the Stopwatch also took just as long.

Colin =^.^=

>
Please post your code, there must be something wrong with it,
QueryPerformanc eFrequency()
can't take 6µsec to complete.
Note that there is no need to call QueryPerformanc eFrequency(), this value
exposed by the Stopwatch class.
Willy.

[Willy Denoyette [MVP]]

"Willy Denoyette [MVP]" <wi************ *@telenet.bewro te in message
news:ea******** ******@TK2MSFTN GP03.phx.gbl...

"colin" <co*********@nt world.NOSPAM.co mwrote in message
news:kr******** ******@newsfe4-win.ntli.net...

>Hi,

Im trying to time some parts of my code using the Stopwatch class,
but it is so slow, I tried the QueryPerformanc eFrequency()
but this seems to be just as slow,
if I just simply call this function in a loop it takes 21 ticks
with a reported frequency of 3.5mhz
its is about 6us wich is over 12k instructions on my 2ghz cpu.
this negates the idea of having a high res timer ...

Is there any way to access the timer more directly ?
I know the cpu actually has a very high resolution timer,
it would be nice to be able to just read this value directly,
maybe il have to write a c++ library and do it in asm
thats assuming I can get the OS to grant me acces to that hardware
address.

basicaly im making a diy profiler, I have a profile class
wich needs Enter(enum p) funtion at the start and a Leave()
function at the end of some functions of interest.

primarily it keeps tarck of the number of calls made,
and a lists the calling functions counts too.
it also measures the total time spent in the function and the subtracts
the time spent in
subroutins to provide an actual time too.

It works pretty quick for counts but when I use the timer it is like 20
times slower,
wich although I can live with waiting 20 minutes to collect the data it
does mean
that there is a considerable error for short functions,

I have added a fudge wich subtracts a fiddle value from the timer,
wich is increased by 21 ticks every times its called,
this might be close but its far from ideal.

Im trying to find out why/where its spending 75% of the cpu time in
mscorlib and mscorwks libraries, the amd codeanalyst identifies its
spending
most of its time in a function called mscorwks::gc_he ap::adjust_limi t_clr

thanks
Colin =^.^=

Please post your code, there must be something wrong with it,
QueryPerformanc eFrequency()
can't take 6µsec to complete.
Note that there is no need to call QueryPerformanc eFrequency(), this value
exposed by the Stopwatch class.
Willy.

Well, QueryPerformanc eFrequency must transition into the kernel, which is
quite expensive, (6000 instructions), so this function may well take +4
µsec on a 2Ghz machine. The same is true for QueryPerformanc eCounter, so you
need to account for this overhead when profiling.

Windows Vista and WS2008 have a new API QueryThreadCycl eTime which returns
the CPU cycles count.
This API calls the __rdtsc(); VC++ compilers intrinsic function, you can
implement a small C function that calls this intrinsic and call this one
from C# using PInvoke.
Willy.

[Willy Denoyette [MVP]]

"colin" <co*********@nt world.NOSPAM.co mwrote in message
news:SY******** ********@newsfe 1-win.ntli.net...

>I just copied the code from here
http://msdn2.microsoft.com/en-us/lib...92(VS.80).aspx

and oops I meant the QueryPerformanc eCounter() call is taking so long ...

I just have a loop wich calls it repeatedly 100000 times to measure how
long it takes.

the Stopwatch also took just as long.

Hmmm.. this code is meant for the compact framework (WinCE).
The exact PInvoke declaration for Windows is:

[DllImport("kern el32"),Suppress UnmanagedCodeSe curity]
static extern int QueryPerformanc eFrequency(out long freq);

but as I said in another reply QueryPerformanc eFrequency is an expensive
call.

Willy.

[colin]

"Willy Denoyette [MVP]" <wi************ *@telenet.bewro te in message
news:eA******** ******@TK2MSFTN GP03.phx.gbl...

"colin" <co*********@nt world.NOSPAM.co mwrote in message
news:SY******** ********@newsfe 1-win.ntli.net...

>>I just copied the code from here
http://msdn2.microsoft.com/en-us/lib...92(VS.80).aspx

and oops I meant the QueryPerformanc eCounter() call is taking so long ...

I just have a loop wich calls it repeatedly 100000 times to measure how
long it takes.

the Stopwatch also took just as long.

Hmmm.. this code is meant for the compact framework (WinCE).
The exact PInvoke declaration for Windows is:

[DllImport("kern el32"),Suppress UnmanagedCodeSe curity]
static extern int QueryPerformanc eFrequency(out long freq);

but as I said in another reply QueryPerformanc eFrequency is an expensive
call.

Ah yes i found that out after I copied it and had to go search for
coredll.dll
it seems its in kernel32 for non ce
I aded the supress security too
in the hope it might speed it up ...

seems these two calls are easy to mix up when writing them lol...
i just call frequency func once, and the counter func about 100million times

thanks
Colin =^.^=

[Willy Denoyette [MVP]]

"Willy Denoyette [MVP]" <wi************ *@telenet.bewro te in message
news:eM******** ******@TK2MSFTN GP05.phx.gbl...

"Willy Denoyette [MVP]" <wi************ *@telenet.bewro te in message
news:ea******** ******@TK2MSFTN GP03.phx.gbl...

>"colin" <co*********@nt world.NOSPAM.co mwrote in message
news:kr******* *******@newsfe4-win.ntli.net...

>>Hi,

Im trying to time some parts of my code using the Stopwatch class,
but it is so slow, I tried the QueryPerformanc eFrequency()
but this seems to be just as slow,
if I just simply call this function in a loop it takes 21 ticks
with a reported frequency of 3.5mhz
its is about 6us wich is over 12k instructions on my 2ghz cpu.
this negates the idea of having a high res timer ...

Is there any way to access the timer more directly ?
I know the cpu actually has a very high resolution timer,
it would be nice to be able to just read this value directly,
maybe il have to write a c++ library and do it in asm
thats assuming I can get the OS to grant me acces to that hardware
address.

basicaly im making a diy profiler, I have a profile class
wich needs Enter(enum p) funtion at the start and a Leave()
function at the end of some functions of interest.

primarily it keeps tarck of the number of calls made,
and a lists the calling functions counts too.
it also measures the total time spent in the function and the subtracts
the time spent in
subroutins to provide an actual time too.

It works pretty quick for counts but when I use the timer it is like 20
times slower,
wich although I can live with waiting 20 minutes to collect the data it
does mean
that there is a considerable error for short functions,

I have added a fudge wich subtracts a fiddle value from the timer,
wich is increased by 21 ticks every times its called,
this might be close but its far from ideal.

Im trying to find out why/where its spending 75% of the cpu time in
mscorlib and mscorwks libraries, the amd codeanalyst identifies its
spending
most of its time in a function called
mscorwks::gc_ heap::adjust_li mit_clr

thanks
Colin =^.^=

Please post your code, there must be something wrong with it,
QueryPerforman ceFrequency()
can't take 6µsec to complete.
Note that there is no need to call QueryPerformanc eFrequency(), this
value exposed by the Stopwatch class.
Willy.

Well, QueryPerformanc eFrequency must transition into the kernel, which is
quite expensive, (6000 instructions), so this function may well take +4
µsec on a 2Ghz machine. The same is true for QueryPerformanc eCounter, so
you need to account for this overhead when profiling.

Windows Vista and WS2008 have a new API QueryThreadCycl eTime which returns
the CPU cycles count.
This API calls the __rdtsc(); VC++ compilers intrinsic function, you can
implement a small C function that calls this intrinsic and call this one
from C# using PInvoke.
Willy.

// C function that uses an intrinsic to retrieve the Processor's cycle
counter register
// Beware your CPU may not support this!
// Compile from the command line: cl /EHsc /O2 <thisfile.cpp >
#include <intrin.h>
#pragma intrinsic(__rdt sc)
extern "C"
__declspec(dlle xport) unsigned __int64 __stdcall rdtsc()
{
return __rdtsc();
}
// C#
[DllImport("this file.dll"),Supp ressUnmanagedCo deSecurity]
static extern ulong rdtsc();

...
ulong cycles = rdtsc();

Willy.

[colin]

"Willy Denoyette [MVP]" <wi************ *@telenet.bewro te in message
news:%2******** ********@TK2MSF TNGP02.phx.gbl. ..

"Willy Denoyette [MVP]" <wi************ *@telenet.bewro te in message

// C function that uses an intrinsic to retrieve the Processor's cycle
counter register
// Beware your CPU may not support this!
// Compile from the command line: cl /EHsc /O2 <thisfile.cpp >
#include <intrin.h>
#pragma intrinsic(__rdt sc)
extern "C"
__declspec(dlle xport) unsigned __int64 __stdcall rdtsc()
{
return __rdtsc();
}
// C#
[DllImport("this file.dll"),Supp ressUnmanagedCo deSecurity]
static extern ulong rdtsc();

...
ulong cycles = rdtsc();

Willy.

thanks that worked, however it stil takes 9000 clock cycles
wich I think is roughly about the same time ...
is that PInvoke realy so time consuming ?
what does it have todo ?

thanks
Colin =^.^=

[colin]

"colin" <co*********@nt world.NOSPAM.co mwrote in message
news:4J******** *******@newsfe6-win.ntli.net...

"Willy Denoyette [MVP]" <wi************ *@telenet.bewro te in message
news:%2******** ********@TK2MSF TNGP02.phx.gbl. ..

>"Willy Denoyette [MVP]" <wi************ *@telenet.bewro te in message

>// C function that uses an intrinsic to retrieve the Processor's cycle
counter register
// Beware your CPU may not support this!
// Compile from the command line: cl /EHsc /O2 <thisfile.cpp >
#include <intrin.h>
#pragma intrinsic(__rdt sc)
extern "C"
__declspec(dll export) unsigned __int64 __stdcall rdtsc()
{
return __rdtsc();
}
// C#
[DllImport("this file.dll"),Supp ressUnmanagedCo deSecurity]
static extern ulong rdtsc();

...
ulong cycles = rdtsc();

Willy.

thanks that worked, however it stil takes 9000 clock cycles
wich I think is roughly about the same time ...
is that PInvoke realy so time consuming ?
what does it have todo ?

Ive just used Environment.Tic kCount, its only 1ms resolution
but it seems to be instant.

as ive plenty enough samples it seems to give some results still ...

thanks

Colin =^.^=

[Willy Denoyette [MVP]]

"colin" <co*********@nt world.NOSPAM.co mwrote in message
news:D%******** *******@newsfe6-win.ntli.net...

"colin" <co*********@nt world.NOSPAM.co mwrote in message
news:4J******** *******@newsfe6-win.ntli.net...

>"Willy Denoyette [MVP]" <wi************ *@telenet.bewro te in message
news:%2******* *********@TK2MS FTNGP02.phx.gbl ...

>>"Willy Denoyette [MVP]" <wi************ *@telenet.bewro te in message

>>// C function that uses an intrinsic to retrieve the Processor's cycle
counter register
// Beware your CPU may not support this!
// Compile from the command line: cl /EHsc /O2 <thisfile.cpp >
#include <intrin.h>
#pragma intrinsic(__rdt sc)
extern "C"
__declspec(dl lexport) unsigned __int64 __stdcall rdtsc()
{
return __rdtsc();
}
// C#
[DllImport("this file.dll"),Supp ressUnmanagedCo deSecurity]
static extern ulong rdtsc();

...
ulong cycles = rdtsc();

Willy.

thanks that worked, however it stil takes 9000 clock cycles
wich I think is roughly about the same time ...
is that PInvoke realy so time consuming ?
what does it have todo ?

Ive just used Environment.Tic kCount, its only 1ms resolution
but it seems to be instant.

To do what?
Using TickCount to measure something that takes less that the RTC interval
will return the same count, the reason is that TickCount is updated at the
rithm of the system clock (every 10 or 15.6 msec. or more....).

Willy.
Willy.
Willy.