7

请帮我确定以下哪些是更优化的代码?

for(int i=0;i<count;i++)
{
    switch(way)
    {
        case 1:
            doWork1(i);
            break;
        case 2:
            doWork2(i);
            break;
        case 3:
            doWork3(i);
            break;
    }
}

或者

switch(way)
{
    case 1:
        for(int i=0;i<count;i++)
        {
            doWork1(i);
        }
        break;
    case 2:
        for(int i=0;i<count;i++)
        {
            doWork2(i);
        }
        break;
    case 3:
        for(int i=0;i<count;i++)
        {
            doWork3(i);
        }
        break;
}

在第一种情况下,碰巧在每次迭代中总是检查 switch case 条件的开销。在第二种情况下,开销不存在。我觉得第二种情况好多了。如果有人有任何其他解决方法,请帮助我提出建议。

4

7 回答 7

6

低的switch连续值非常快 - 这种类型的跳转具有高度优化的处理。坦率地说,在绝大多数情况下,你所问的都不会产生任何影响——任何事情都会淹没doWork2(i);这个;哎呀,虚拟呼叫本身可能会淹没它。

如果它真的,真的,真的很重要(我很难在这里想到一个真实的场景),那么:测量它。在任何明显的情况下,衡量它的唯一方法是使用您实际的、准确的代码 - 您无法概括 pico 优化。

所以:

  1. 没关系
  2. 措施
  3. 没关系
于 2012-06-26T07:41:55.720 回答
2

实际上,尽管这里有一些评论,它可能会更快一些。

让我们实际测试一下:

using System;
using System.Diagnostics;

namespace Demo
{
    class Program
    {
        static void Main(string[] args)
        {
            int count = 1000000000;

            Stopwatch sw = Stopwatch.StartNew();

            for (int way = 1; way <= 3; ++way)
                test1(count, way);

            var elapsed1 = sw.Elapsed;
            Console.WriteLine("test1() took " + elapsed1);

            sw.Restart();

            for (int way = 1; way <= 3; ++way)
                test2(count, way);

            var elapsed2 = sw.Elapsed;
            Console.WriteLine("test2() took " + elapsed2);

            Console.WriteLine("test2() was {0:f1} times as fast.", + ((double)elapsed1.Ticks)/elapsed2.Ticks);
        }

        static void test1(int count, int way)
        {
            for (int i = 0; i < count; ++i)
            {
                switch (way)
                {
                    case 1: doWork1(); break;
                    case 2: doWork2(); break;
                    case 3: doWork3(); break;
                }
            }
        }

        static void test2(int count, int way)
        {
            switch (way)
            {
                case 1:
                    for (int i = 0; i < count; ++i)
                        doWork1();
                    break;

                case 2:
                    for (int i = 0; i < count; ++i)
                        doWork2();
                    break;

                case 3:
                    for (int i = 0; i < count; ++i)
                        doWork3();
                    break;
            }
        }

        static void doWork1()
        {
        }

        static void doWork2()
        {
        }

        static void doWork3()
        {
        }
    }
}

现在这是非常不现实的,因为 doWork() 方法不做任何事情。但是,它将给我们一个基准时间。

在我的 Windows 7 x64 系统上构建 RELEASE 得到的结果是:

test1() took 00:00:03.8041522
test2() took 00:00:01.7916698
test2() was 2.1 times as fast.

因此,将循环移动到 switch 语句中可以使其速度快两倍。

现在让我们通过在 doWork() 中添加一些代码来让它更真实一点:

using System;
using System.Diagnostics;

namespace Demo
{
    class Program
    {
        static void Main(string[] args)
        {
            int count = 1000000000;

            Stopwatch sw = Stopwatch.StartNew();

            for (int way = 1; way <= 3; ++way)
                test1(count, way);

            var elapsed1 = sw.Elapsed;
            Console.WriteLine("test1() took " + elapsed1);

            sw.Restart();

            for (int way = 1; way <= 3; ++way)
                test2(count, way);

            var elapsed2 = sw.Elapsed;
            Console.WriteLine("test2() took " + elapsed2);

            Console.WriteLine("test2() was {0:f1} times as fast.", + ((double)elapsed1.Ticks)/elapsed2.Ticks);
        }

        static int test1(int count, int way)
        {
            int total1 = 0, total2 = 0, total3 = 0;

            for (int i = 0; i < count; ++i)
            {
                switch (way)
                {
                    case 1: doWork1(i, ref total1); break;
                    case 2: doWork2(i, ref total2); break;
                    case 3: doWork3(i, ref total3); break;
                }
            }

            return total1 + total2 + total3;
        }

        static int test2(int count, int way)
        {
            int total1 = 0, total2 = 0, total3 = 0;

            switch (way)
            {
                case 1:
                    for (int i = 0; i < count; ++i)
                        doWork1(i, ref total1);
                    break;

                case 2:
                    for (int i = 0; i < count; ++i)
                        doWork2(i, ref total2);
                    break;

                case 3:
                    for (int i = 0; i < count; ++i)
                        doWork3(i, ref total3);
                    break;
            }

            return total1 + total2 + total3;
        }

        static void doWork1(int n, ref int total)
        {
            total += n;
        }

        static void doWork2(int n, ref int total)
        {
            total += n;
        }

        static void doWork3(int n, ref int total)
        {
            total += n;
        }
    }
}

现在我得到这些结果:

test1() took 00:00:03.9153776
test2() took 00:00:05.3220507
test2() was 0.7 times as fast.

现在将循环放入开关变得更慢了!这种违反直觉的结果是这类事情的典型表现,并说明了为什么在尝试优化代码时应该始终执行时序测试。(并且像这样优化代码通常是你甚至不应该做的事情,除非你有充分的理由怀疑存在瓶颈。你最好花时间清理你的代码。;))

我做了一些其他测试,对于稍微简单的 doWork() 方法,test2() 方法更快。这在很大程度上取决于 JIT 编译器可以对优化做什么。

注意:我认为我的第二个测试代码的速度差异的原因是因为 JIT 编译器可以在内联对 doWork() 的调用时优化掉 'ref' 调用,当它们不在循环中时,如 test1() ; 而对于 test2() 它不能(出于某种原因)。

于 2012-06-26T08:35:01.357 回答
2

您可以执行以下操作:

Func(void, int> doWork;
switch(way) 
{ 
    case 1: 
        doWork = doWork1; 
        break; 
    case 2: 
        doWork = doWork2; 
        break; 
    case 3: 
        doWork = doWork3; 
        break; 
} 
for (int i=0;i<count;i++)  
{
     doWork(i);
}

(写在这里,代码可能不太编译,只是为了给你一个想法......)

于 2012-06-26T07:31:30.267 回答
2

我会问自己问题以进行优化

  1. 首先,计数有多大?是 1,2,10, 10000000000 吗?
  2. 运行代码的机器有多强大?
  3. 我应该写更少的代码吗?
  4. 我写完这段代码有人会看吗?如果是这样,他有多专业?
  5. 我缺少什么?时间?速度 ?还有什么?
  6. 是什么way?我从哪里得到它?way成为 1 或 2 或 3的概率是多少?

很明显,第一个代码片段将用于 switch 部分,直到i达到 count 但 count 有多大?如果它不是一个非常大的数字,那不会有关系吗?如果它太大并且运行时间很慢,那么它就没有用了。但是,正如我所说,如果您想要可读性并且可以保证计数很小,为什么不使用第一个呢?它比第二个更易读,而且我喜欢的代码更少。

第二个片段,看起来很丑,但如果 count 是一个巨大的数字,它应该是首选。

于 2012-06-26T07:49:24.183 回答
1

您应该对其进行测量以查看是否值得优化(我很确定它不是)。就可读性和简洁性而言,我个人更喜欢第一个(代码更少,更不容易出错,更“”)。

这是另一种更简洁的方法:

for(int i = 0; i < count; i++)
{
    doAllWays(way, i); // let the method decide what to do next
}

所有“方式”似乎都是相关的,否则它们不会出现在同一个switch. 因此,首先将它们捆绑在一种方法中是有意义的switch

于 2012-06-26T07:47:33.190 回答
0

第二种方法效率更高;无论如何,您都必须完成完整的for循环。但是在第一种方法中,您不必要地重复case语句计数次数。

于 2012-06-26T07:34:42.540 回答
0

假设您在这里遇到性能问题(因为在大多数情况下 switch 真的非常快):

如果你对你的 switch 语句感到困扰,我建议在这里应用重构。

switch 可以很容易地被策略模式替换(因为在 for 循环中切换的值没有改变,所以根本不需要切换)。

真正的优化目标是那些 for 循环,但如果没有上下文,很难说出可以做些什么。

这是有关重构开关的更多信息(例如,策略模式) CodeProject Article on refactoring switch

于 2012-06-26T07:53:01.173 回答