函数数组与开关的性能答案

【问题标题】：Performance of array of function vs switch函数数组与开关的性能
【发布时间】：2014-07-17 18:16:03
【问题描述】：

阅读本主题：Performance of array of functions over if and switch statements 和http://en.wikipedia.org/wiki/Branch_table 后，我编写了一个小测试来测量开关/案例风格编码与函数数组之间的性能差异。函数调用（F 类成员）故意只使用 cpu 容量（算术的东西）：没有系统调用，没有控制台输出等 I/O 等。

最后，这两种方法之间的差异是 switch 方法快 30% 左右！好的，函数指针比 switch/case 慢一点。

所以我的问题是：我的测试对您来说是否有效？或者我是否引入了任何导致这些令人难以置信的结果的偏见？ 30%！

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;
using System.IO;

namespace ConsoleApplication1
{
    class Program
    {

// 使用的函子：

        delegate void functor(int i, int j);

// switch 中使用的枚举：

        enum indexes
        {
            a = 0, b = 1, c = 2, d = 3, e = 4, f = 5,
            g = 6, h = 7, i = 8, j = 9, k = 10,
            l = 11, m = 12, n = 13, o = 14, p = 15,
            q = 16
        };

// 具有不同可能调用的类：

        class F
        {
            long m_j = 1;
            public void A(int i, int j) { m_j = (i + j - 2) % (j / 3 + 1); }
            public void B(int i, int j) { m_j = (i + j - 3) % (j / 3 + 1); }
            public void C(int i, int j) { m_j = (i + j - 4) % (j / 3 + 1); }
            public void D(int i, int j) { m_j = (i + j - 5) % (j / 3 + 1); }
            public void E(int i, int j) { m_j = (i + j - 6) % (j / 3 + 1); }
            public void FF(int i, int j) { m_j = (i + j - 7) % (j / 3 + 1); }
            public void G(int i, int j) { m_j = (i + j - 8) % (j / 3 + 1); }
            public void H(int i, int j) { m_j = (i + j - 9) % (j / 3 + 1); }
            public void I(int i, int j) { m_j = (i + j - 10) % (j / 3 + 1); }
            public void J(int i, int j) { m_j = (i + j - 11) % (j / 3 + 1); }
            public void K(int i, int j) { m_j = (i + j - 12) % (j / 3 + 1); }
            public void L(int i, int j) { m_j = (i + j - 13) % (j / 3 + 1); }
            public void M(int i, int j) { m_j = (i + j - 14) % (j / 3 + 1); }
            public void N(int i, int j) { m_j = (i + j - 15) % (j / 3 + 1); }
            public void O(int i, int j) { m_j = (i + j - 16) % (j / 3 + 1); }
            public void P(int i, int j) { m_j = (i + j - 17) % (j / 3 + 1); }
            public void Q(int i, int j) { m_j = (i + j - 18) % (j / 3 + 1); }
            public static int nbfunc = 17;
        }


        static void Main(string[] args)
        {

// 在每一轮，我们增加调用次数：

            long maxi = 1000;
            for (; maxi < 10000000000; maxi *= 10)
            {
                long switch_time, array_time;
                TextWriter tw = Console.Out;
                {
                    Stopwatch sw = new Stopwatch();
                    F f = new F();

// *************** 使用 switch/case 进行测试 ***************

                    sw.Start();
                    for (int i = 0; i < maxi; i++)
                    {
                        indexes e = (indexes)(i % F.nbfunc);
                        switch (e)
                        {
                            case indexes.a:
                                f.A(i,i/2);
                                break;
                            case indexes.b:
                                f.B(i, i / 2);
                                break;
                            case indexes.c:
                                f.C(i, i / 2);
                                break;
                            case indexes.d:
                                f.D(i, i / 2);
                                break;
                            case indexes.e:
                                f.E(i, i / 2);
                                break;
                            case indexes.f:
                                f.FF(i, i / 2);
                                break;
                            case indexes.g:
                                f.G(i, i / 2);
                                break;
                            case indexes.h:
                                f.H(i, i / 2);
                                break;
                            case indexes.i:
                                f.I(i, i / 2);
                                break;
                            case indexes.j:
                                f.J(i, i / 2);
                                break;
                            case indexes.k:
                                f.K(i, i / 2);
                                break;
                            case indexes.l:
                                f.L(i, i / 2);
                                break;
                            case indexes.m:
                                f.M(i, i / 2);
                                break;
                            case indexes.n:
                                f.N(i, i / 2);
                                break;
                            case indexes.o:
                                f.O(i, i / 2);
                                break;
                            case indexes.p:
                                f.P(i, i / 2);
                                break;
                        }
                    }
                    sw.Stop();
                    switch_time = sw.ElapsedMilliseconds;
                }
                //

// *************** 使用函数数组进行测试 ***************

                {

                    Stopwatch sw = new Stopwatch();
                    F f = new F();

                    List<functor> functors = new List<functor>()
                    {
                        f.A, f.B, f.C, f.D, f.E, f.FF, f.G, f.H, f.I, f.J, f.K, f.L, f.M, f.N, f.O, f.P, f.Q 
                    };

                    sw.Start();
                    for (int i = 0; i < maxi; i++)
                    {
                        functors[i % F.nbfunc](i, i / 2);
                    }
                    sw.Stop();
                    array_time = sw.ElapsedMilliseconds;
                }

// *************** 显示结果 ***************

                Console.WriteLine("nb iterations : " + maxi.ToString());
                Console.WriteLine("  switch method total time in ms : " + (switch_time).ToString());
                Console.WriteLine("  array  method total time in ms : " + (array_time).ToString());


            }

        }

    }
}

在 win7 64 位、VS2010、Xeon E5-2609 @ 2.4 Ghz 上编译编译器标志：可视标准模式发布，开启“优化代码”标志。

结果：

nb iterations : 1000000
  switch method total time in ms : 19
  array  method total time in ms : 23
nb iterations : 10000000
  switch method total time in ms : 177
  array  method total time in ms : 237
nb iterations : 100000000
  switch method total time in ms : 1808
  array  method total time in ms : 2416
nb iterations : 1000000000
  switch method total time in ms : 18630
  array  method total time in ms : 24312

【问题讨论】：

您为什么不简单地使用 OOP 并创建一个包含所有需要的因素和一些 Calculate() 函数的类？您正在为非常示意性的行为创建 10000 行案例，并在高度面向对象的范例语言中使用它...

标签： c# switch-statement function-pointers

【解决方案1】：

唯一跳出来的是你newing 每次maxi 迭代的仿函数列表。如果你把它移到你的循环之外，你的时间会是什么样子？

【讨论】：

new 在 start/stop 方法之外，因此应该没有影响。
无论如何我都会试一试。您会惊讶地发现，诸如此类的微小变化会对您的工作产生整体影响。

【解决方案2】：

您的实验存在偏差，即您定期执行 switch 的所有条目。

本实验中的切换效率主要由“分支预测”决定，即我是快速命中匹配的“案例”还是需要探索几乎所有案例？

对于这个小尺寸 (16)，我们平均进行 8 次布尔测试以找到正确的“案例”，并且我们受益于更多的内联优化可能性，因为代码结构是静态的；我认为编译器无法检测到“仿函数”是静态的。

因此，我会尝试将函子设为在任何函数之外定义和初始化的静态常量数组（普通函子 []），以帮助编译器至少拥有优化/内联的选项。

然后你可以尝试增加 case 的数量，在某些时候我怀疑数组中的随机访问 O(1) 应该比 switch case 中的测试更快（总体 O(Nbcases)）。

最后，尝试绘制一些随机访问模式（为两次运行重播相同的种子以避免随机偏差），因为交换机版本可能会受到影响，但数组版本不会受到影响。

【讨论】：