How to measure performance by milliseconds?

[Sharon]

I need to test a performance of some code of mine.
I tried using the Environment.Tic kCount but its resolution is too low (from
the MSDN remarks: The resolution of the TickCount property cannot be less
than 500 milliseconds.), I also tried the DateTime and it also gives me
minimum resolution of 500 milliseconds.
But I need to measure much less the 500 milliseconds, I need it to be
several milliseconds.
How can I do that?

--------
Thanks
Sharon

[peancor]

Hi,
QueryPerformanc eFrequency and QueryPerformanc eCounter are the methods
you are looking for. Note that both are Win32 method and you will need
to pinvoke them. you will find the signatures on www.pinvoke.net.
http://www.pinvoke.net/default.aspx/...ceCounter.html

=?Utf-8?B?U2hhcm9u?= <Sh*****@newsgr oups.nospam> wrote in
news:B9******** *************** ***********@mic rosoft.com:

I need to test a performance of some code of mine.
I tried using the Environment.Tic kCount but its resolution is too low
(from the MSDN remarks: The resolution of the TickCount property
cannot be less than 500 milliseconds.), I also tried the DateTime and
it also gives me minimum resolution of 500 milliseconds.
But I need to measure much less the 500 milliseconds, I need it to be
several milliseconds.
How can I do that?

--------
Thanks
Sharon

[Peter Bromberg [C# MVP]]

Here is some code I use that wraps the QueryPerformanc eCounter API:
using System;
using System.Runtime. InteropServices ;
using System.Componen tModel;
using System.Threadin g;
namespace PAB
{
public class HiPerfTimer
{
[DllImport("Kern el32.dll")]
private static extern bool QueryPerformanc eCounter(out long
lpPerformanceCo unt);
[DllImport("Kern el32.dll")]
private static extern bool QueryPerformanc eFrequency(out long lpFrequency);
private long startTime ;
private long stopTime;
private long freq;
/// <summary>
/// ctor
/// </summary>
public HiPerfTimer()
{
startTime = 0;
stopTime = 0;
freq =0;
if (QueryPerforman ceFrequency(out freq) == false)
{
throw new Win32Exception( ); // timer not supported
}
}
/// <summary>
/// Start the timer
/// </summary>
/// <returns>long - tick count</returns>
public long Start()
{
QueryPerformanc eCounter(out startTime);
return startTime;
}
/// <summary>
/// Stop timer
/// </summary>
/// <returns>long - tick count</returns>
public long Stop()
{
QueryPerformanc eCounter(out stopTime);
return stopTime;
}
/// <summary>
/// Return the duration of the timer (in seconds)
/// </summary>
/// <returns>doub le - duration</returns>
public double Duration
{
get
{
return (double)(stopTi me - startTime) / (double) freq;
}
}
/// <summary>
/// Frequency of timer (no counts in one second on this machine)
/// </summary>
///<returns>long - Frequency</returns>
public long Frequency
{
get
{
QueryPerformanc eFrequency(out freq);
return freq;
}
}
}
}
--
Co-founder, Eggheadcafe.com developer portal:
http://www.eggheadcafe.com
UnBlog:
http://petesbloggerama.blogspot.com


"Sharon" wrote:

I need to test a performance of some code of mine.
I tried using the Environment.Tic kCount but its resolution is too low (from
the MSDN remarks: The resolution of the TickCount property cannot be less
than 500 milliseconds.), I also tried the DateTime and it also gives me
minimum resolution of 500 milliseconds.
But I need to measure much less the 500 milliseconds, I need it to be
several milliseconds.
How can I do that?

--------
Thanks
Sharon

[William Stacey [MVP]]

Think DateTime.Now is 10ms accurate. Not sure if that is too much for your
app. Also, this link seems to suggest Environment.Tic kCount is 1ms accurate
based on interpretation of the article and empirical evidence. Not sure.
http://www.informit.com/guides/print...eqNum=241&rl=1

--
William Stacey [MVP]

"Sharon" <Sh*****@newsgr oups.nospam> wrote in message
news:B9******** *************** ***********@mic rosoft.com...
|I need to test a performance of some code of mine.
| I tried using the Environment.Tic kCount but its resolution is too low
(from
| the MSDN remarks: The resolution of the TickCount property cannot be less
| than 500 milliseconds.), I also tried the DateTime and it also gives me
| minimum resolution of 500 milliseconds.
| But I need to measure much less the 500 milliseconds, I need it to be
| several milliseconds.
| How can I do that?
|
| --------
| Thanks
| Sharon

[Chris Dunaway]

If you are using .Net 2.0, check out the Stopwatch class. You call
it's Start method, then call it's Stop method and check the Elapsed
property to get the elapsed time. I believe it will use a high
resolution timer if the hardware supports it. Check the
IsHighResolutio n field to find out.

[Lucian Wischik]

Sharon <Sh*****@newsgr oups.nospam> wrote:

I need to test a performance of some code of mine.
I tried using the Environment.Tic kCount but its resolution is too low (from
the MSDN remarks: The resolution of the TickCount property cannot be less
than 500 milliseconds.), I also tried the DateTime and it also gives me
minimum resolution of 500 milliseconds.
But I need to measure much less the 500 milliseconds, I need it to be
several milliseconds.

I use System.Diagnost ics.Stopwatch

But in any case, I think it's a bad idea to measure such a small
period. You should repeat your operation a thousand times and get the
overall time, then divide by a thousand. This will avoid edge-effects
&c.

--
Lucian

[Michel Walsh]

Hi
Doing so you also time background tasks with higher priority, which is not
necessary under your control. If you run 1000 times code1 at noon and
compare it with 1000 runs of code2 you started at 9:00 AM, you may have a
huge difference in background tasks, sustained, over the duration of one of
your 1000 times of execution, but not on the other. Maybe irrelevant, in
general, but has to be aware of the possibility.
Vanderghast, Access MVP
"Lucian Wischik" <lu***@wischik. com> wrote in message
news:5j******** *************** *********@4ax.c om...

Sharon <Sh*****@newsgr oups.nospam> wrote:

I need to test a performance of some code of mine.
I tried using the Environment.Tic kCount but its resolution is too low
(from
the MSDN remarks: The resolution of the TickCount property cannot be less
than 500 milliseconds.), I also tried the DateTime and it also gives me
minimum resolution of 500 milliseconds.
But I need to measure much less the 500 milliseconds, I need it to be
several milliseconds.

I use System.Diagnost ics.Stopwatch

But in any case, I think it's a bad idea to measure such a small
period. You should repeat your operation a thousand times and get the
overall time, then divide by a thousand. This will avoid edge-effects
&c.

--
Lucian

[code4life]

Yet another suggestion, this one involves using the TimeSpan:

DateTime start = DateTime.Now;
....
TimeSpan end = DateTime.Now.Su btract(start); // you could just do DateTime.Now -
// start also
Console.WriteLi ne(end.TotalMil liSeconds);

[Sharon]

The DateTime.Now and Environment.Tic kCount minimum resolution is 500
milliseconds. Only above this time you can get the 10ms accuracy.

-------
Thanks
Sharon

[Sharon]

I'm using the .NET 1.1 and not 2.0 so I can't use the Stopwatch class.
-------
Thanks
Sharon