问题
I'm doing some real quick and dirty benchmarking on a single line of C# code using DateTime:
long lStart = DateTime.Now.Ticks;
// do something
long lFinish = DateTime.Now.Ticks;
The problem is in the results:
Start Time [633679466564559902] Finish Time [633679466564559902] Start Time [633679466564569917] Finish Time [633679466564569917] Start Time [633679466564579932] Finish Time [633679466564579932]
...and so on.
Given that the start and finish times are identical, Ticks is obviously not granular enough.
So, how can I better measure performance?
回答1:
The Stopwatch class, available since .NET 2.0, is the best way to go for this. It is a very high performance counter accurate to fractions of a millisecond.
Take a look at the MSDN documentation, which is pretty clear.
EDIT: As previously suggested, it is also advisable to run your code a number of times in order to get a reasonable average time.
回答2:
Execute your code repeatedly. The problem seems to be that your code executes a lot faster than the granularity of your measuring instrument. The simplest solution to this is to execute your code many, many times (thousands, maybe millions) and then calculate the average execution time.
Edit: Also, due to the nature of current optimizing compilers (and Virtual Machines such as the CLR and the JVM) it can be very misleading to measure the execution speed of single lines of code, since the measurement can influence the speed quite a lot. A much better approach would be to profile the entire system (or at least larger blocks) and check where the bottlenecks are.
回答3:
I find these useful
http://accelero.codeplex.com/SourceControl/changeset/view/22633#290971 http://accelero.codeplex.com/SourceControl/changeset/view/22633#290973 http://accelero.codeplex.com/SourceControl/changeset/view/22633#290972
TickTimer is a cut down copy of Stopwatch that starts when constructed and does not support restarting. It will also notify you if the current hardware does not support high resolution timing (Stopwatch swallows this problem)
So this
var tickTimer = new TickTimer();
//call a method that takes some time
DoStuff();
tickTimer.Stop();
Debug.WriteLine("Elapsed HighResElapsedTicks " + tickTimer.HighResElapsedTicks);
Debug.WriteLine("Elapsed DateTimeElapsedTicks " + tickTimer.DateTimeElapsedTicks);
Debug.WriteLine("Elapsed ElapsedMilliseconds " + tickTimer.ElapsedMilliseconds);
Debug.WriteLine("Start Time " + new DateTime(tickTimer.DateTimeUtcStartTicks).ToLocalTime().ToLongTimeString());
will output this
Elapsed HighResElapsedTicks 10022886
Elapsed DateTimeElapsedTicks 41896
Elapsed ElapsedMilliseconds 4.18966178849554
Start Time 11:44:58
DebugTimer is a wrapper for TickTimer that will write the result to Debug. (note: it supports the Disposable pattern)
So this
using (new DebugTimer("DoStuff"))
{
//call a method that takes some time
DoStuff();
}
will output this to the debug window
DoStuff: Total 3.6299 ms
IterationDebugTimer is for timing how long it takes to run an operation multiple times and write the result to Debug. It will also perform an initial run that is not included so as to ignore startup time. (note: it supports the Disposable pattern)
So this
int x;
using (var iterationDebugTimer = new IterationDebugTimer("Add", 100000))
{
iterationDebugTimer.Run(() =>
{
x = 1+4;
});
}
Will output this
Add: Iterations 100000
Total 1.198540 ms
Single 0.000012 ms
回答4:
Just to add to what others have already said about using Stopwatch and measuring averages.
Make sure you call your method before measuring. Otherwise you will measure the time needed to JIT compile the code as well. That may skew your numbers significantly.
Also, make sure you measure release mode code as optimizations are turned off by default for debug builds. Tuning debug code is pointless imho.
And make sure you're measuring what you actually want to measure. When optimizations kick in, the compiler/JIT compiler may rearrange code or remove it entirely, so you may end up measuring something a little different than intended. At least take a look at the generated code to make sure code has not been stripped.
Depending on what you're trying to measure keep in mind, that a real system will stress the runtime differently than a typical test application. Some performance problems are related to e.g. how objects are garbage collected. These problems will typically not show up in a simple test application.
Actually, the best advise is to measure real systems with real data as sandbox tests may turn out to be highly inaccurate.
回答5:
Use a real profiler such as dotTrace.
回答6:
Sample for Stopwatch class
using System.Diagnostics;
......
...
..
Stopwatch sw = new Stopwatch();
sw.Start();
//Your Code Here
sw.Stop();
Console.WriteLine("Elapsed={0}",sw.Elapsed);
回答7:
https://andreyakinshin.gitbooks.io/performancebookdotnet/content/science/microbenchmarking.html
https://github.com/PerfDotNet/BenchmarkDotNet
"Indeed, microbencmarking is very hard. If an operation takes 10–100ns, the operation measurement is a big challenge. I suggest you to use BenchmarkDotNet for your benchmarks. It’s a library that can help you to make an honest benchmark and get measurements with good precision. Of course, you can write own benchmark without any additional libraries. In this section, we talk about why it is probably a bad idea and what you should know before start."
回答8:
You can use the Stopwatch, assuming you are using .NET 2.0 or newer.
System.Diagnostics.Stopwatch.StartNew();
The Stopwatch class also has public read-only field IsHighResolution that will let you know if the stopwatch is based on a high-resolution performance counter. If its not, it is based on the system timer.
I'm not sure what it takes for stopwatch to be based on high-resolution performance counter. There are some API calls but I figure if the stopwatch doesn't use a high resolution, then the API is probably not there.
回答9:
See the answer to Is DateTime.Now the best way to measure a function’s performance? for an explanation or read my blog post about high performance measurement
The problem is that DateTime has a resolution of about 15ms, it can't be more precise than that. Stopwatch, however, can.
回答10:
Here's a nice write up at the MSDN on how to Implement a Continuously Updating, High-Resolution Time Provider for Windows
Here's the sample source code for the article (C++).
回答11:
This code project article shows how to use the high performance timer to measure execution speed of your code:
http://www.codeproject.com/KB/cs/highperformancetimercshar.aspx
Here you can find a number of open source C# profilers:
http://csharp-source.net/open-source/profilers
回答12:
Another option is to have the timer-code inserted automatically with Fody. This makes your code far more easy to read as it seperates your cross-cutting concerns. I think this is close to what is called Aspect Oriented Programming, but done at post-compile time.
See https://github.com/Fody/MethodTimer for the fody addon that does method timing.
Quoting from the Readme:
With an interceptor, somewhere in your assembly:
public static class MethodTimeLogger {
public static void Log(MethodBase methodBase, long milliseconds)
{
//Do some logging here
}
}
Your code,
public class MyClass
{
[Time]
public void MyMethod()
{
//Some code u are curious how long it takes
Console.WriteLine("Hello");
}
}
Is compiled to this:
public class MyClass
{
public void MyMethod()
{
var stopwatch = Stopwatch.StartNew();
try
{
//Some code u are curious how long it takes
Console.WriteLine("Hello");
}
finally
{
stopwatch.Stop();
MethodTimeLogger.Log(methodof(MyClass.MyMethod), stopwatch.ElapsedMilliseconds);
}
}
}
回答13:
Disposable style Stopwatch works best to me.
class VWatch : IDisposable {
Stopwatch watch = new Stopwatch();
public VWatch() {
this.watch.Start();
}
public void Dispose() {
this.watch.Stop();
Console.WriteLine("Finished. Elapsed={0}", this.watch.Elapsed);
}
}
And then:
using (new VWatch()) {
/// do something for time measurement
}
回答14:
My preferences go for BenchmarkDotNet mentioned by @Evgeniy. Probably his reply is bypassed because there is no code snippet, but as this is a complex item it worth at least taking a look into the library before to go head first into something bespoke.
And because some code always catches eyes, here is the example from the quoted site:
using System;
using System.Security.Cryptography;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;
namespace MyBenchmarks
{
[ClrJob(baseline: true), CoreJob, MonoJob, CoreRtJob]
[RPlotExporter, RankColumn]
public class Md5VsSha256
{
private SHA256 sha256 = SHA256.Create();
private MD5 md5 = MD5.Create();
private byte[] data;
[Params(1000, 10000)]
public int N;
[GlobalSetup]
public void Setup()
{
data = new byte[N];
new Random(42).NextBytes(data);
}
[Benchmark]
public byte[] Sha256() => sha256.ComputeHash(data);
[Benchmark]
public byte[] Md5() => md5.ComputeHash(data);
}
public class Program
{
public static void Main(string[] args)
{
var summary = BenchmarkRunner.Run<Md5VsSha256>();
}
}
}
回答15:
Sometimes it may be best to look at why you need to time the operation? Is it running slow? Or are you just curious? First rule of optimization is "Don't do it". So, depending on what you're actually measuring, could change the opinion on what tool is best suited for the task.
回答16:
Easiest to use a profiler like ANTS Performance Profiler, or one of the others which are available.
回答17:
I made an extension that returns milliseconds from ticks.
public static int GetTotalRunningTimeInMilliseconds(this DateTime start)
{
var endTicks = DateTime.Now.Ticks - start.Ticks;
return TimeSpan.FromTicks(endTicks).Milliseconds;
}
Usage:
var start = DateTime.Now;
//...your long running code here
var endTime = start.GetTotalRunningTimeInMilliseconds();
回答18:
I've done a very simple method that measures the execution speed of an Action, which has for me the benefit that I can reuse it whenever I need it, and whichever code I have to measure.
For me a DateTime was enough, but it's easily adaptable from DateTime to Stopwatch.
public static TimeSpan MeasureTime(Action action)
{
DateTime start = DateTime.Now;
if (action == null)
{
throw new ArgumentNullException("action");
}
try
{
action();
}
catch (Exception ex)
{
Debugger.Log(1, "Measuring",ex.ToString());
}
return DateTime.Now - start;
}
How to use it?:
private static void StressTest()
{
List<TimeSpan> tss = new List<TimeSpan>();
for (int i = 0; i < 100; i++)
{
// here is the measuring:
var ts = MeasureTime(() => instance.Method("param1"));
tss.Add(ts);
}
Console.WriteLine("Max: {0}", tss.Max());
Console.WriteLine("Min: {0}", tss.Min());
Console.WriteLine("Avg: {0}", TimeSpan.FromMilliseconds(tss.Average(i => i.TotalMilliseconds)));
}
or:
var ts = MeasureTime(() =>
{
// Some intensive stuff here
int a = 1;
// more here
int b = 2;
// and so on
});
回答19:
To measure performance with difference between measurements I use this class. The StopWatch class doesn't have the Split method.
/// <summary>
/// Stopwatch like class that keeps track of timelapses.
/// Probably low-res because of the usage of DateTime.
/// </summary>
public class ChronoMeter
{
/// <summary>
/// The name given when the Chronometer was constructed.
/// </summary>
public string Name { get; private set; }
/// <summary>
/// The moment in time Start was called.
/// </summary>
public DateTime Started { get; private set; }
/// <summary>
/// All time recordings are added to this list by calling Split and Stop.
/// </summary>
public List<ChronoRecord> Records { get; private set; }
private readonly Stopwatch _stopWatch = new Stopwatch();
private bool _hasBeenStopped = false;
/// <summary>
/// Constrcutor
/// </summary>
/// <param name="pName">The name is used in logging</param>
/// <param name="pLoggingType">The type of logging appriate for the information yielded by this time recording.</param>
public ChronoMeter(string pName)
{
Name = pName;
Records = new List<ChronoRecord>();
}
/// <summary>
/// Not calling Stop is bad practise. Therefore a little safety net zo the end is still recorderd.
/// Keep in mind that the garbase collector invokes the destructor, so the moment of time probably doesn't make much sense.
/// It is more to notify that you should have used Stop for the latest split.
/// </summary>
~ChronoMeter()
{
if (!_hasBeenStopped)
{
Stop("Destructor safety net");
}
}
/// <summary>
/// TimeElapsedSinceStart of a ChronoRecord is relative to the moment ChronoMeter was started by calling this function.
/// </summary>
public void Start()
{
_stopWatch.Start();
Started = DateTime.Now;
}
/// <summary>
/// Splits the timerecording and add a record of this moment to the list of split records.
/// </summary>
/// <param name="pSplitName"></param>
public void Split(string pSplitName)
{
_stopWatch.Stop();
var created = Started + _stopWatch.Elapsed;
var previousRecord = Records.LastOrDefault();
Records.Add(new ChronoRecord(pSplitName, Started, created, previousRecord));
_stopWatch.Start();
}
/// <summary>
/// Indicates you are done and the records will be written to the log.
/// </summary>
public void Stop(string pSplitName)
{
Split(pSplitName);
_stopWatch.Stop();
_hasBeenStopped = true;
}
public class ChronoRecord
{
public string Name { get; private set; }
public TimeSpan TimeElapsedSinceStart { get; private set; }
public TimeSpan TimeElapsedSincePrevious { get; private set; }
public DateTime Start { get; private set; }
public DateTime Created { get; private set; }
public ChronoRecord(string pName, DateTime pStartDateTime, DateTime pCreated, ChronoRecord pPreviousRecord=null)
{
if (pCreated == default(DateTime)) //Ignore DefaultDateTimeComparison
{
pCreated = DateTime.Now;
}
Created = pCreated;
Name = pName;
Start = pStartDateTime;
TimeElapsedSinceStart = Created - Start;
if (pPreviousRecord != null)
{
TimeElapsedSincePrevious = Created - pPreviousRecord.Created;
}
else
{
TimeElapsedSincePrevious = TimeElapsedSinceStart;
}
}
}
}
来源：https://stackoverflow.com/questions/457605/how-to-measure-code-performance-in-net