详解CodeTimer及XCode性能测试

移动开发 iOS
本文介绍的是详解CodeTimer及XCode性能测试,详细的对CodeTimer及XCode性能测试,并讲述的很详细,我们先来看详细内容。

详解CodeTimerXCode性能测试是本文要介绍的内容,在测试XCode性能的时候,发现每次执行测试程序得到的执行时间差距实在太大,于是采用了老赵的CodeTimer来计算线程时间,后来因为测试程序稍微有点复杂,在使用匿名委托时会有参数的“打包”过程,于是改进了CodeTimer测试功能代码通过实现一个继承自CodeTimer的类来实现,避免每次迭代时参数“打包”的过程。

  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Text;  
  4. using System.Runtime.InteropServices;  
  5. using System.Diagnostics;  
  6. using System.Threading;  
  7. using NewLife.Reflection;  
  8. using NewLife.Exceptions;  
  9.  
  10. namespace NewLife.Log  
  11. {  
  12.     /// <summary> 
  13.     /// 代码性能计时器  
  14.     /// </summary> 
  15.     /// <remarks>参考了老赵(http://www.cnblogs.com/jeffreyzhao/archive/2009/03/10/codetimer.html)  
  16. 和eaglet(http://www.cnblogs.com/eaglet/archive/2009/03/10/1407791.html)两位的作品</remarks> 
  17.     /// <remarks>为了保证性能比较的公平性,采用了多种指标,并使用计时器重写等手段来避免各种不必要的损耗</remarks> 
  18.     public class CodeTimer  
  19.     {  
  20.         #region 静态快速计时  
  21.         /// <summary> 
  22.         /// 计时  
  23.         /// </summary> 
  24.         /// <param name="times"></param> 
  25.         /// <param name="action"></param> 
  26.         /// <returns></returns> 
  27.         public static CodeTimer Time(Int32 times, Action<Int32> action)  
  28.         {  
  29.             CodeTimer timer = new CodeTimer();  
  30.             timer.Times = times;  
  31.             timer.Action = action;  
  32.  
  33.             timer.TimeOne();  
  34.             timer.Time();  
  35.  
  36.             return timer;  
  37.         }  
  38.  
  39.         /// <summary> 
  40.         /// 计时,并用控制台输出行  
  41.         /// </summary> 
  42.         /// <param name="title"></param> 
  43.         /// <param name="times"></param> 
  44.         /// <param name="action"></param> 
  45.         public static void TimeLine(String title, Int32 times, Action<Int32> action)  
  46.         {  
  47.             Console.Write("{0,16}:", title);  
  48.  
  49.             CodeTimer timer = new CodeTimer();  
  50.             timer.Times = times;  
  51.             timer.Action = action;  
  52.             timer.ShowProgress = true;  
  53.  
  54.             ConsoleColor currentForeColor = Console.ForegroundColor;  
  55.             Console.ForegroundColor = ConsoleColor.Yellow;  
  56.  
  57.             timer.TimeOne();  
  58.             timer.Time();  
  59.  
  60.             Console.WriteLine(timer.ToString());  
  61.  
  62.             Console.ForegroundColor = currentForeColor;  
  63.         }  
  64.         #endregion  
  65.  
  66.         #region PInvoke  
  67.         [DllImport("kernel32.dll")]  
  68.         [return: MarshalAs(UnmanagedType.Bool)]  
  69.         static extern bool QueryThreadCycleTime(IntPtr threadHandle, ref ulong cycleTime);  
  70.  
  71.         [DllImport("kernel32.dll")]  
  72.         static extern IntPtr GetCurrentThread();  
  73.  
  74.         [DllImport("kernel32.dll", SetLastError = true)]  
  75.         static extern bool GetThreadTimes(IntPtr hThread, out long lpCreationTime, out long lpExitTime,
  76.  out long lpKernelTime, out long lpUserTime);  
  77.  
  78.         static Boolean supportCycle = true;  
  79.         private static ulong GetCycleCount()  
  80.         {  
  81.             //if (Environment.Version.Major < 6) return 0;  
  82.  
  83.             if (!supportCycle) return 0;  
  84.  
  85.             try  
  86.             {  
  87.                 ulong cycleCount = 0;  
  88.                 QueryThreadCycleTime(GetCurrentThread(), ref cycleCount);  
  89.                 return cycleCount;  
  90.             }  
  91.             catch  
  92.             {  
  93.                 supportCycle = false;  
  94.                 return 0;  
  95.             }  
  96.         }  
  97.  
  98.         private static long GetCurrentThreadTimes()  
  99.         {  
  100.             long l;  
  101.             long kernelTime, userTimer;  
  102.             GetThreadTimes(GetCurrentThread(), out l, out l, out kernelTime, out userTimer);  
  103.             return kernelTime + userTimer;  
  104.         }  
  105.         #endregion  
  106.  
  107.         #region 私有字段  
  108.         ulong cpuCycles = 0;  
  109.         long threadTime = 0;  
  110.         int[] gen;  
  111.         #endregion  
  112.  
  113.         #region 属性  
  114.         private Int32 _Times;  
  115.         /// <summary>次数</summary> 
  116.         public Int32 Times  
  117.         {  
  118.             get { return _Times; }  
  119.             set { _Times = value; }  
  120.         }  
  121.  
  122.         private Action<Int32> _Action;  
  123.         /// <summary>迭代方法,如不指定,则使用Time(int index)</summary> 
  124.         public Action<Int32> Action  
  125.         {  
  126.             get { return _Action; }  
  127.             set { _Action = value; }  
  128.         }  
  129.  
  130.         private Boolean _ShowProgress;  
  131.         /// <summary>是否显示控制台进度</summary> 
  132.         public Boolean ShowProgress  
  133.         {  
  134.             get { return _ShowProgress; }  
  135.             set { _ShowProgress = value; }  
  136.         }  
  137.  
  138.         private Int32 _Index;  
  139.         /// <summary>进度</summary> 
  140.         public Int32 Index  
  141.         {  
  142.             get { return _Index; }  
  143.             set { _Index = value; }  
  144.         }  
  145.  
  146.         private ulong _CpuCycles;  
  147.         /// <summary>CPU周期</summary> 
  148.         public ulong CpuCycles  
  149.         {  
  150.             get { return _CpuCycles; }  
  151.             set { _CpuCycles = value; }  
  152.         }  
  153.  
  154.         private long _ThreadTime;  
  155.         /// <summary>线程时间,单位是100ns,除以10000转为ms</summary> 
  156.         public long ThreadTime  
  157.         {  
  158.             get { return _ThreadTime; }  
  159.             set { _ThreadTime = value; }  
  160.         }  
  161.  
  162.         private Int32[] _Gen = new Int32[] { 0, 0, 0 };  
  163.         /// <summary>GC代数</summary> 
  164.         public Int32[] Gen  
  165.         {  
  166.             get { return _Gen; }  
  167.             set { _Gen = value; }  
  168.         }  
  169.  
  170.         private TimeSpan _Elapsed;  
  171.         /// <summary>执行时间</summary> 
  172.         public TimeSpan Elapsed  
  173.         {  
  174.             get { return _Elapsed; }  
  175.             set { _Elapsed = value; }  
  176.         }  
  177.         #endregion  
  178.  
  179.         #region 方法  
  180.         /// <summary> 
  181.         /// 计时核心方法,处理进程和线程优先级  
  182.         /// </summary> 
  183.         public virtual void Time()  
  184.         {  
  185.             if (Times <= 0) throw new XException("非法迭代次数!");  
  186.  
  187.             // 设定进程、线程优先级,并在完成时还原  
  188.             ProcessPriorityClass pp = Process.GetCurrentProcess().PriorityClass;  
  189.             ThreadPriority tp = Thread.CurrentThread.Priority;  
  190.             try  
  191.             {  
  192.                 Process.GetCurrentProcess().PriorityClass = ProcessPriorityClass.High;  
  193.                 Thread.CurrentThread.Priority = ThreadPriority.Highest;  
  194.  
  195.                 StartProgress();  
  196.  
  197.                 TimeTrue();  
  198.             }  
  199.             finally  
  200.             {  
  201.                 StopProgress();  
  202.  
  203.                 Thread.CurrentThread.Priority = tp;  
  204.                 Process.GetCurrentProcess().PriorityClass = pp;  
  205.             }  
  206.         }  
  207.  
  208.         /// <summary> 
  209.         /// 真正的计时  
  210.         /// </summary> 
  211.         protected virtual void TimeTrue()  
  212.         {  
  213.             if (Times <= 0) throw new XException("非法迭代次数!");  
  214.  
  215.             // 统计GC代数  
  216.             GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced);  
  217.             gen = new Int32[GC.MaxGeneration + 1];  
  218.             for (Int32 i = 0; i <= GC.MaxGeneration; i++)  
  219.             {  
  220.                 gen[i] = GC.CollectionCount(i);  
  221.             }  
  222.  
  223.             Stopwatch watch = new Stopwatch();  
  224.             watch.Start();  
  225.             cpuCycles = GetCycleCount();  
  226.             threadTime = GetCurrentThreadTimes();  
  227.  
  228.             // 如果未指定迭代方法,则使用内部的Time  
  229.             Action<Int32> action = Action;  
  230.             if (action == null)  
  231.             {  
  232.                 action = Time;  
  233.  
  234.                 // 初始化  
  235.                 Init();  
  236.             }  
  237.  
  238.             for (Int32 i = 0; i < Times; i++)  
  239.             {  
  240.                 Index = i;  
  241.  
  242.                 action(i);  
  243.             }  
  244.             if (Action == null)  
  245.             {  
  246.                 // 结束  
  247.                 Finish();  
  248.             }  
  249.  
  250.             CpuCycles = GetCycleCount() - cpuCycles;  
  251.             ThreadTime = GetCurrentThreadTimes() - threadTime;  
  252.  
  253.             watch.Stop();  
  254.             Elapsed = watch.Elapsed;  
  255.  
  256.             // 统计GC代数  
  257.             List<Int32> list = new List<Int32>();  
  258.             for (Int32 i = 0; i <= GC.MaxGeneration; i++)  
  259.             {  
  260.                 int count = GC.CollectionCount(i) - gen[i];  
  261.                 list.Add(count);  
  262.             }  
  263.             Gen = list.ToArray();  
  264.         }  
  265.  
  266.         /// <summary> 
  267.         /// 执行一次迭代,预热所有方法  
  268.         /// </summary> 
  269.         public void TimeOne()  
  270.         {  
  271.             Int32 n = Times;  
  272.  
  273.             try  
  274.             {  
  275.                 Times = 1;  
  276.                 Time();  
  277.             }  
  278.             finally { Times = n; }  
  279.         }  
  280.  
  281.         /// <summary> 
  282.         /// 迭代前执行,计算时间  
  283.         /// </summary> 
  284.         public virtual void Init() { }  
  285.  
  286.         /// <summary> 
  287.         /// 每一次迭代,计算时间  
  288.         /// </summary> 
  289.         /// <param name="index"></param> 
  290.         public virtual void Time(Int32 index) { }  
  291.  
  292.         /// <summary> 
  293.         /// 迭代后执行,计算时间  
  294.         /// </summary> 
  295.         public virtual void Finish() { }  
  296.         #endregion  
  297.  
  298.         #region 进度  
  299.         Thread thread;  
  300.  
  301.         void StartProgress()  
  302.         {  
  303.             if (!ShowProgress) return;  
  304.  
  305.             // 使用低优先级线程显示进度  
  306.             thread = new Thread(new ParameterizedThreadStart(Progress));  
  307.             thread.IsBackground = true;  
  308.             thread.Priority = ThreadPriority.BelowNormal;  
  309.             thread.Start();  
  310.         }  
  311.  
  312.         void StopProgress()  
  313.         {  
  314.             if (thread != null && thread.IsAlive)  
  315.             {  
  316.                 thread.Abort();  
  317.                 thread.Join(3000);  
  318.             }  
  319.         }  
  320.  
  321.         void Progress(Object state)  
  322.         {  
  323.             Int32 left = Console.CursorLeft;  
  324.  
  325.             // 设置光标不可见  
  326.             Boolean cursorVisible = Console.CursorVisible;  
  327.             Console.CursorVisible = false;  
  328.  
  329.             Stopwatch sw = new Stopwatch();  
  330.             sw.Start();  
  331.             while (true)  
  332.             {  
  333.                 try  
  334.                 {  
  335.                     Int32 i = Index;  
  336.                     if (i >= Times) break;  
  337.  
  338.                     if (i > 0 && sw.Elapsed.TotalMilliseconds > 10)  
  339.                     {  
  340.                         Double d = (Double)i / Times;  
  341.                         Console.Write("{0,7:n0}ms {1:p}", sw.Elapsed.TotalMilliseconds, d);  
  342.                         Console.CursorLeft = left;  
  343.                     }  
  344.                 }  
  345.                 catch (ThreadAbortException) { break; }  
  346.                 catch { break; }  
  347.  
  348.                 Thread.Sleep(500);  
  349.             }  
  350.             sw.Stop();  
  351.  
  352.             Console.CursorLeft = left;  
  353.             Console.CursorVisible = cursorVisible;  
  354.         }  
  355.         #endregion  
  356.  
  357.         #region 重载  
  358.         /// <summary> 
  359.         /// 已重载。输出依次分别是:执行时间、CPU线程时间、时钟周期、GC代数  
  360.         /// </summary> 
  361.         /// <returns></returns> 
  362.         public override string ToString()  
  363.         {  
  364.             return String.Format("{0,7:n0}ms {1,7:n0}ms {2,15:n0} {3}/{4}/{5}", Elapsed.TotalMilliseconds,
  365.  ThreadTime / 10000, CpuCycles, Gen[0], Gen[1], Gen[2]);  
  366.         }  
  367.         #endregion  
  368.     }  

对于控制台测试项目,另外起了一个线程负责输出进度,不知道这样对测试会有多大影响。

#p#

XCode性能测试

XCode每次升级都会进行性能测试,不过那是为了检查升级是否造成了性能瓶颈,实际上性能测试就是作为XCode升级的最后一道工作。

上一次与ADO.Net进行性能对比测试XCode的版本是v3.5,XCode各种操作的耗时大概是ADO.Net的1.2倍,vs统计代码只有2000行。

目前XCode最新版本是v7.3,vs统计代码有5100行,并且引用一个4100行的核心库,一些常用的扩展功能形成4800行的通用实体类库。

由此可见,现在的XCode至少在代码上是v3.5的7倍。(当然,这个代码量是远不如NH的,记得它有好些文件超过了1000行代码)

废话少说,下面开始测试

本地环境:win7+MSSQL2007

说明:

1、以下截图,黄色数字分别代表执行时间、线程时间、CPU周期、GC,白色数字表示与第一个测试项相比较的比列,两个白色分别表示执行时间比例和线程时间比例

2、ADO.SQL表示用sql方式执行,ADO.Param表示用参数化执行

3、DAL表示用XCode的数据访问层执行SQL,DALIdentity表示插入后查询自增,如果开启一级缓存,这两项会有影响

4、Entity是普通实体类操作,WeakEntity表示弱类型操作实体,DynEntity表示动态创建实体类(CodeDom)执行操作

5、所有比例的计算以ADO.SQL为基准,因为XCode也是采用这种方式

本地普通测试

详解CodeTimer及XCode性能测试

总体来看,XCode的性能大概是ADO的1.5倍。

后面的查询中,WeakEntity和DynEntity的比例小于1,Entity也很小,主要是因为XCode的二级缓存(实体缓存)。每一次查询测试,实际上包含了查一个管理员和一个角色,而角色表数据较少,XCode使用了实体缓存,所以XCode对角色的查询几乎接近于0。XCode的实体缓存能够保证数据数据的新鲜性,这里不能说不公平。

开启一级缓存

详解CodeTimer及XCode性能测试

可以注意到,开启一级缓存后,XCode的表现非常出色,并且越是后面的测试项越出色。因为,后面三项都必须通过DAL来执行,而一级缓存正是位于DAL中。所以XCode的第一个测试项DAL会比较慢,因为它的缓存命中率太低了,并且还要负责缓存数据等操作。查询哪个管理员是随机的,越是到了后面,随着缓存命中率的提高,速度就越快。

XCode的一级缓存也是能保证实时更新的,也许这个测试作为与ADO的标准测试比较好。

下面我们试试别的数据库,SQLite吧,开启一级缓存。SQLite插入后获取自增的方法跟MSSQL不一样,为了让测试代码简单,我们放过它,允许ADO的两个测试项不插入角色。而XCode是能够很好支持各种数据库获取自增的

详解CodeTimer及XCode性能测试

首先看到的是,没有开启事务的SQLite,实在是太不给力了,执行时间很长,但是线程时间很短。这个测试告诉我们,用SQLite要尽可能的开事务。

为了更切近生产环境,下面我们试试远程的MSSQL,位于局域网内的window 2008 r2上的MSSQL2008

详解CodeTimer及XCode性能测试

可以看到,越是切近生产环境,数据量越大,XCode表现越是出色!

把MySql也拉出来溜溜

详解CodeTimer及XCode性能测试

该MySql部署在一个XP虚拟机上(512M内存安装了MySql、Oracle、Firebird、PostgreSQL),并且各种配置都是开发用配置,测试数据不是很稳定。

后面会附上测试程序,以及测试程序的源代码,感兴趣的同学可以在自己机器上执行测试程序看看结果如何。

建议对XCode感兴趣的同学都看看Performance.cs源码,每一个测试项,同时也展示着如何使用XCode,如何支持多数据库,如何做到更好的性能!

BTW:

这段时间一直在准备一篇文章《XCode这样处理无限增长的海量数据》,灵感源自于一位使用XCode做项目的同学,他用了三百多张相同结构的表,并且表的数量可能会无限增多,每张表有数百万的数据。没错,这是一个数据采集系统,包括采集、分析整理、查询展现三大块。

他使用了XCode十八般武艺中的动态修改表,实现一个实体类控制几百张表的需求,当然,也包括自动创建表。尽管这项功能位列于十八般武艺当中,与三级缓存并重,但实际上项目使用得不多,风险还是挺大的。至少,到现在为止,没有发现太大的问题。

我想以他的这个项目为例子,详细的讲解一下XCode的各个缓存,以及如何去处理海量数据。当然,还要包括最新版本的分布式,是的,下一版本的XCode直接支持异构数据库的分布式,提高性能,或者实现数据的热备,业务层不需要做任何修改。

小结:详解CodeTimerXCode性能测试的内容介绍完了,希望本文对你有所帮助!

测试代码请看http://xcode.codeplex.com

责任编辑:zhaolei 来源: 博客园
相关推荐

2009-11-16 09:05:46

CodeTimer

2010-06-04 09:42:47

Linux 测试cpu

2011-07-28 14:31:55

Xcode 调试 异常

2010-06-04 11:00:27

hadoop性能优化

2023-07-31 09:13:13

ValidatorGolang

2011-07-19 15:44:18

Xcode 卸载

2024-03-06 18:09:06

Linux性能工具

2010-06-04 16:07:09

Linux 性能测试工

2011-07-20 10:59:46

2011-07-26 14:44:53

调试 Xcode

2016-09-14 11:09:06

Web工具运维

2011-08-04 18:09:32

Xcode 技巧 文档

2011-07-22 18:41:11

Xcode 文档 脚本

2011-08-11 13:10:34

XcodeSVN

2013-04-15 10:48:16

Xcode ARC详解iOS ARC使用

2013-04-08 10:27:59

iOSXcode制作静态库

2011-07-26 11:21:28

Xcode Xcode4 Archive

2012-05-21 09:41:54

XcodeiOS单元测试

2010-02-03 17:47:49

千兆交换机

2013-02-25 13:00:14

iOS开发xcode
点赞
收藏

51CTO技术栈公众号