Svi*_*ish 307 .net c# testing performance
查看某些内容(例如方法调用)接受代码的最精确方式是什么？
我猜的最容易和最快的是:
DateTime start = DateTime.Now;
{
// Do some work
}
TimeSpan timeItTook = DateTime.Now - start;
但这有多精确？还有更好的方法吗？
Phi*_*ert 568
更好的方法是使用秒表类:
using System.Diagnostics;
// ...
Stopwatch sw = new Stopwatch();
sw.Start();
// ...
sw.Stop();
Console.WriteLine("Elapsed={0}",sw.Elapsed);
Jon*_*eet 166
正如其他人所说,Stopwatch在这里使用是一个很好的课程.你可以用一个有用的方法包装它:
public static TimeSpan Time(Action action)
{
Stopwatch stopwatch = Stopwatch.StartNew();
action();
stopwatch.Stop();
return stopwatch.Elapsed;
}
(注意使用Stopwatch.StartNew().我更喜欢这个来创建一个秒表然后调用Start()简单.)显然这会引起调用委托,但在绝大多数情况下都不相关.然后你写:
TimeSpan time = StopwatchUtil.Time(() =>
{
// Do some work
});
您甚至可以ITimer为此创建一个接口,StopwatchTimer, CpuTimer其中包含可用的实现.
naw*_*fal 76
正如其他人所说,Stopwatch应该是正确的工具.但是,对它的改进很少,具体看到这个主题:在C#中对小代码样本进行基准测试,是否可以改进这种实现？.
我在这里看到了Thomas Maierhofer的一些有用的提示
基本上他的代码看起来像:
//prevent the JIT Compiler from optimizing Fkt calls away
long seed = Environment.TickCount;
//use the second Core/Processor for the test
Process.GetCurrentProcess().ProcessorAffinity = new IntPtr(2);
//prevent "Normal" Processes from interrupting Threads
Process.GetCurrentProcess().PriorityClass = ProcessPriorityClass.High;
//prevent "Normal" Threads from interrupting this thread
Thread.CurrentThread.Priority = ThreadPriority.Highest;
//warm up
method();
var stopwatch = new Stopwatch()
for (int i = 0; i < repetitions; i++)
{
stopwatch.Reset();
stopwatch.Start();
for (int j = 0; j < iterations; j++)
method();
stopwatch.Stop();
print stopwatch.Elapsed.TotalMilliseconds;
}
另一种方法是依靠Process.TotalProcessTime测量CPU保持忙于运行代码/进程的时间,如此处所示.这可以反映更真实的情况,因为没有其他进程影响测量.它做的事情如下:
var start = Process.GetCurrentProcess().TotalProcessorTime;
method();
var stop = Process.GetCurrentProcess().TotalProcessorTime;
print (end - begin).TotalMilliseconds;
在这里可以找到相同的裸体,详细的实现.
我编写了一个帮助程序类,以易于使用的方式执行:
public class Clock
{
interface IStopwatch
{
bool IsRunning { get; }
TimeSpan Elapsed { get; }
void Start();
void Stop();
void Reset();
}
class TimeWatch : IStopwatch
{
Stopwatch stopwatch = new Stopwatch();
public TimeSpan Elapsed
{
get { return stopwatch.Elapsed; }
}
public bool IsRunning
{
get { return stopwatch.IsRunning; }
}
public TimeWatch()
{
if (!Stopwatch.IsHighResolution)
throw new NotSupportedException("Your hardware doesn't support high resolution counter");
//prevent the JIT Compiler from optimizing Fkt calls away
long seed = Environment.TickCount;
//use the second Core/Processor for the test
Process.GetCurrentProcess().ProcessorAffinity = new IntPtr(2);
//prevent "Normal" Processes from interrupting Threads
Process.GetCurrentProcess().PriorityClass = ProcessPriorityClass.High;
//prevent "Normal" Threads from interrupting this thread
Thread.CurrentThread.Priority = ThreadPriority.Highest;
}
public void Start()
{
stopwatch.Start();
}
public void Stop()
{
stopwatch.Stop();
}
public void Reset()
{
stopwatch.Reset();
}
}
class CpuWatch : IStopwatch
{
TimeSpan startTime;
TimeSpan endTime;
bool isRunning;
public TimeSpan Elapsed
{
get
{
if (IsRunning)
throw new NotImplementedException("Getting elapsed span while watch is running is not implemented");
return endTime - startTime;
}
}
public bool IsRunning
{
get { return isRunning; }
}
public void Start()
{
startTime = Process.GetCurrentProcess().TotalProcessorTime;
isRunning = true;
}
public void Stop()
{
endTime = Process.GetCurrentProcess().TotalProcessorTime;
isRunning = false;
}
public void Reset()
{
startTime = TimeSpan.Zero;
endTime = TimeSpan.Zero;
}
}
public static void BenchmarkTime(Action action, int iterations = 10000)
{
Benchmark<TimeWatch>(action, iterations);
}
static void Benchmark<T>(Action action, int iterations) where T : IStopwatch, new()
{
//clean Garbage
GC.Collect();
//wait for the finalizer queue to empty
GC.WaitForPendingFinalizers();
//clean Garbage
GC.Collect();
//warm up
action();
var stopwatch = new T();
var timings = new double[5];
for (int i = 0; i < timings.Length; i++)
{
stopwatch.Reset();
stopwatch.Start();
for (int j = 0; j < iterations; j++)
action();
stopwatch.Stop();
timings[i] = stopwatch.Elapsed.TotalMilliseconds;
print timings[i];
}
print "normalized mean: " + timings.NormalizedMean().ToString();
}
public static void BenchmarkCpu(Action action, int iterations = 10000)
{
Benchmark<CpuWatch>(action, iterations);
}
}
打电话吧
Clock.BenchmarkTime(() =>
{
//code
}, 10000000);
要么
Clock.BenchmarkCpu(() =>
{
//code
}, 10000000);
最后一部分Clock是棘手的部分.如果您想显示最终时间,可由您自行选择所需的时间.我写了一个扩展方法NormalizedMean,它给出了丢弃噪声的读取时间的平均值.我的意思是我计算每个时间与实际平均值的偏差,然后我从偏差的平均值(称为绝对偏差;请注意它不是经常听到的标准偏差)中丢弃更快的值(只有较慢的值) ,最后返回剩余值的平均值.这意味着,例如,如果定时值{ 1, 2, 3, 2, 100 }(以毫秒为单位或其他),它丢弃100,并返回平均值{ 1, 2, 3, 2 }是2.或者,如果定时是{ 240, 220, 200, 220, 220, 270 },它丢弃270,并返回平均值{ 240, 220, 200, 220, 220 }是220.
public static double NormalizedMean(this ICollection<double> values)
{
if (values.Count == 0)
return double.NaN;
var deviations = values.Deviations().ToArray();
var meanDeviation = deviations.Sum(t => Math.Abs(t.Item2)) / values.Count;
return deviations.Where(t => t.Item2 > 0 || Math.Abs(t.Item2) <= meanDeviation).Average(t => t.Item1);
}
public static IEnumerable<Tuple<double, double>> Deviations(this ICollection<double> values)
{
if (values.Count == 0)
yield break;
var avg = values.Average();
foreach (var d in values)
yield return Tuple.Create(d, avg - d);
}
秒表很好,但循环工作10 ^ 6次,然后除以10 ^ 6.你会得到更多的精确度.