Question

背景

今天早上运行基准测试时，我和我的同事发现了一些与C＃代码与VB.NET代码性能有关的奇怪事情。

我们开始比较C＃与Delphi Prism计算质数，发现Prism的速度提高了约30％。我在生成IL时更多地考虑CodeGear优化代码（exe大约是C＃的两倍，并且有各种不同的IL。）

我决定在VB.NET中编写一个测试，假设微软的编译器最终会为每种语言编写基本相同的IL。然而，结果更令人震惊： C＃上的代码比使用相同操作的VB慢了三倍以上！

生成的IL有所不同，但并非极端如此，而且我不太善于阅读它以理解差异。

基准

我已经在下面列出了每个代码。在我的机器上，VB在大约 6.36 秒内找到348513个素数。 C＃在 21.76 秒内找到相同数量的素数。

计算机规格和注释

Intel Core 2 Quad 6600 @ 2.4Ghz

我测试的每台机器在C＃和VB.NET之间的基准测试结果都有明显的差异。

两个控制台应用程序都是在发布模式下编译的，但是没有更改项目设置从Visual Studio 2008生成的默认值。

VB.NET代码

Imports System.Diagnostics

Module Module1

    Private temp As List(Of Int32)
    Private sw As Stopwatch
    Private totalSeconds As Double

    Sub Main()
        serialCalc()
    End Sub

    Private Sub serialCalc()
        temp = New List(Of Int32)()
        sw = Stopwatch.StartNew()
        For i As Int32 = 2 To 5000000
            testIfPrimeSerial(i)
        Next
        sw.Stop()
        totalSeconds = sw.Elapsed.TotalSeconds
        Console.WriteLine(String.Format("{0} seconds elapsed.", totalSeconds))
        Console.WriteLine(String.Format("{0} primes found.", temp.Count))
        Console.ReadKey()
    End Sub

    Private Sub testIfPrimeSerial(ByVal suspectPrime As Int32)
        For i As Int32 = 2 To Math.Sqrt(suspectPrime)
            If (suspectPrime Mod i = 0) Then
                Exit Sub
            End If
        Next
        temp.Add(suspectPrime)
    End Sub

End Module

C＃代码

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

namespace FindPrimesCSharp {
    class Program {
        List<Int32> temp = new List<Int32>();
        Stopwatch sw;
        double totalSeconds;


        static void Main(string[] args) {

            new Program().serialCalc();

        }


        private void serialCalc() {
            temp = new List<Int32>();
            sw = Stopwatch.StartNew();
            for (Int32 i = 2; i <= 5000000; i++) {
                testIfPrimeSerial(i);
            }
            sw.Stop();
            totalSeconds = sw.Elapsed.TotalSeconds;
            Console.WriteLine(string.Format("{0} seconds elapsed.", totalSeconds));
            Console.WriteLine(string.Format("{0} primes found.", temp.Count));
            Console.ReadKey();
        }

        private void testIfPrimeSerial(Int32 suspectPrime) {
            for (Int32 i = 2; i <= Math.Sqrt(suspectPrime); i++) {
                if (suspectPrime % i == 0)
                    return;
            }
            temp.Add(suspectPrime);
        }

    }
}

为什么C＃执行Math.Sqrt()比VB.NET慢？

Answer 1

C＃实现每次循环都会重新计算Math.Sqrt(suspectPrime)，而VB只在循环开始时计算它。这仅仅是由于控制结构的性质。在C＃中，for只是一个花哨的while循环，而在VB中它是一个单独的结构。

使用此循环甚至可以提升分数：

        Int32 sqrt = (int)Math.Sqrt(suspectPrime)
        for (Int32 i = 2; i <= sqrt; i++) { 
            if (suspectPrime % i == 0) 
                return; 
        }

Answer 2

我同意C＃代码在每次迭代时计算sqrt的说法，这里是Reflector的证据：

VB版：

private static void testIfPrimeSerial(int suspectPrime)
{
    int VB$t_i4$L0 = (int) Math.Round(Math.Sqrt((double) suspectPrime));
    for (int i = 2; i <= VB$t_i4$L0; i++)
    {
        if ((suspectPrime % i) == 0)
        {
            return;
        }
    }
    temp.Add(suspectPrime);
}

C＃版本：

 private void testIfPrimeSerial(int suspectPrime)
{
    for (int i = 2; i <= Math.Sqrt((double) suspectPrime); i++)
    {
        if ((suspectPrime % i) == 0)
        {
            return;
        }
    }
    this.temp.Add(suspectPrime);
}

哪种方式指向VB生成的代码即使开发人员天真到足以在循环定义中调用sqrt也能表现更好。

Answer 3

这是来自for循环的反编译IL。如果你比较两者，你会看到VB.Net只执行Math.Sqrt(...) onces而C＃在每次传递时检查它。要解决此问题，您需要像其他人建议的那样执行var sqrt = (int)Math.Sqrt(suspectPrime);之类的操作。

...... VB ......

.method private static void CheckPrime(int32 suspectPrime) cil managed
{
    // Code size       34 (0x22)
    .maxstack  2
    .locals init ([0] int32 i,
         [1] int32 VB$t_i4$L0)
    IL_0000:  ldc.i4.2
    IL_0001:  ldarg.0
    IL_0002:  conv.r8
    IL_0003:  call       float64 [mscorlib]System.Math::Sqrt(float64)
    IL_0008:  call       float64 [mscorlib]System.Math::Round(float64)
    IL_000d:  conv.ovf.i4
    IL_000e:  stloc.1
    IL_000f:  stloc.0
    IL_0010:  br.s       IL_001d

    IL_0012:  ldarg.0
    IL_0013:  ldloc.0
    IL_0014:  rem
    IL_0015:  ldc.i4.0
    IL_0016:  bne.un.s   IL_0019

    IL_0018:  ret

    IL_0019:  ldloc.0
    IL_001a:  ldc.i4.1
    IL_001b:  add.ovf
    IL_001c:  stloc.0
    IL_001d:  ldloc.0
    IL_001e:  ldloc.1
    IL_001f:  ble.s      IL_0012

    IL_0021:  ret
} // end of method Module1::testIfPrimeSerial

... C＃...

.method private hidebysig static void CheckPrime(int32 suspectPrime) cil managed
{
    // Code size       26 (0x1a)
    .maxstack  2
    .locals init ([0] int32 i)
    IL_0000:  ldc.i4.2
    IL_0001:  stloc.0
    IL_0002:  br.s       IL_000e

    IL_0004:  ldarg.0
    IL_0005:  ldloc.0
    IL_0006:  rem
    IL_0007:  brtrue.s   IL_000a

    IL_0009:  ret

    IL_000a:  ldloc.0
    IL_000b:  ldc.i4.1
    IL_000c:  add
    IL_000d:  stloc.0
    IL_000e:  ldloc.0
    IL_000f:  conv.r8
    IL_0010:  ldarg.0
    IL_0011:  conv.r8
    IL_0012:  call       float64 [mscorlib]System.Math::Sqrt(float64)
    IL_0017:  ble.s      IL_0004

    IL_0019:  ret
} // end of method Program::testIfPrimeSerial

Answer 4

关闭切线，如果你已经启动并运行VS2010，你可以利用PLINQ并更快地制作C＃（可能也是VB.Net）。

将for循环更改为...

var range = Enumerable.Range(2, 5000000);

range.AsParallel()
    .ForAll(i => testIfPrimeSerial(i));

我从7.4开始 - ＆gt;在我的机器上4.6秒。将其移至发布模式可以节省更多时间。

Answer 5

区别在于循环;你的C＃代码计算每次迭代的平方根。改变这一行：

for (Int32 i = 2; i <= Math.Sqrt(suspectPrime); i++) {

为：

var lim = Math.Sqrt(suspectPrime);
for (Int32 i = 2; i <= lim; i++) {

将我的机器上的时间从26秒减少到7.something。

Answer 6

一般没有。它们都编译为CLR（公共语言运行时）字节码。这类似于JVM（Java虚拟机）。

为什么C＃比VB.NET更慢地执行Math.Sqrt（）？

背景

基准

计算机规格和注释

VB.NET代码

C＃代码

6 个答案: