为什么编译的 RegEx 性能比 Intrepreted RegEx 慢？

Question

我遇到了这篇文章：

Performance: Compiled vs. Interpreted Regular Expressions，我修改了示例代码以编译 1000 个正则表达式，然后每个运行 500 次以利用预编译，但即使在这种情况下，解释的正则表达式运行速度也快 4 倍！

这意味着RegexOptions.Compiled选项完全没用，实际上更糟糕的是，它更慢！ 很大的不同是由于JIT，在解决JIT后编译的正则表达式在下面的代码中仍然执行有点慢对我来说没有意义，但@Jim in the answers provided a much cleaner version which works as expected。

谁能解释为什么会这样？

代码，取自并修改自博文：

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

namespace RegExTester
{
    class Program
    {
        static void Main(string[] args)
        {
            DateTime startTime = DateTime.Now;

            for (int i = 0; i < 1000; i++)
            {
                CheckForMatches("some random text with email address, address@domain200.com" + i.ToString());    
            }


            double msTaken = DateTime.Now.Subtract(startTime).TotalMilliseconds;
            Console.WriteLine("Full Run: " + msTaken);


            startTime = DateTime.Now;

            for (int i = 0; i < 1000; i++)
            {
                CheckForMatches("some random text with email address, address@domain200.com" + i.ToString());
            }


            msTaken = DateTime.Now.Subtract(startTime).TotalMilliseconds;
            Console.WriteLine("Full Run: " + msTaken);

            Console.ReadLine();

        }


        private static List<Regex> _expressions;
        private static object _SyncRoot = new object();

        private static List<Regex> GetExpressions()
        {
            if (_expressions != null)
                return _expressions;

            lock (_SyncRoot)
            {
                if (_expressions == null)
                {
                    DateTime startTime = DateTime.Now;

                    List<Regex> tempExpressions = new List<Regex>();
                    string regExPattern =
                        @"^[a-zA-Z0-9]+[a-zA-Z0-9._%-]*@{0}$";

                    for (int i = 0; i < 2000; i++)
                    {
                        tempExpressions.Add(new Regex(
                            string.Format(regExPattern,
                            Regex.Escape("domain" + i.ToString() + "." +
                            (i % 3 == 0 ? ".com" : ".net"))),
                            RegexOptions.IgnoreCase));//  | RegexOptions.Compiled
                    }

                    _expressions = new List<Regex>(tempExpressions);
                    DateTime endTime = DateTime.Now;
                    double msTaken = endTime.Subtract(startTime).TotalMilliseconds;
                    Console.WriteLine("Init:" + msTaken);
                }
            }

            return _expressions;
        }

        static  List<Regex> expressions = GetExpressions();

        private static void CheckForMatches(string text)
        {

            DateTime startTime = DateTime.Now;


                foreach (Regex e in expressions)
                {
                    bool isMatch = e.IsMatch(text);
                }


            DateTime endTime = DateTime.Now;
            //double msTaken = endTime.Subtract(startTime).TotalMilliseconds;
            //Console.WriteLine("Run: " + msTaken);

        }
    }
}

Answer 1

按预期使用时，编译的正则表达式匹配得更快。正如其他人指出的那样，我们的想法是编译一次并多次使用它们。构造和初始化时间是amortized 超过了这么多次运行。

我创建了一个更简单的测试，它将向您展示编译的正则表达式无疑比未编译的要快。

    const int NumIterations = 1000;
    const string TestString = "some random text with email address, address@domain200.com";
    const string Pattern = "^[a-zA-Z0-9]+[a-zA-Z0-9._%-]*@domain0\\.\\.com$";
    private static Regex NormalRegex = new Regex(Pattern, RegexOptions.IgnoreCase);
    private static Regex CompiledRegex = new Regex(Pattern, RegexOptions.IgnoreCase | RegexOptions.Compiled);
    private static Regex DummyRegex = new Regex("^.$");

    static void Main(string[] args)
    {
        var DoTest = new Action<string, Regex, int>((s, r, count) =>
            {
                Console.Write("Testing {0} ... ", s);
                Stopwatch sw = Stopwatch.StartNew();
                for (int i = 0; i < count; ++i)
                {
                    bool isMatch = r.IsMatch(TestString + i.ToString());
                }
                sw.Stop();
                Console.WriteLine("{0:N0} ms", sw.ElapsedMilliseconds);
            });

        // Make sure that DoTest is JITed
        DoTest("Dummy", DummyRegex, 1);
        DoTest("Normal first time", NormalRegex, 1);
        DoTest("Normal Regex", NormalRegex, NumIterations);
        DoTest("Compiled first time", CompiledRegex, 1);
        DoTest("Compiled", CompiledRegex, NumIterations);

        Console.WriteLine();
        Console.Write("Done. Press Enter:");
        Console.ReadLine();
    }

将NumIterations 设置为 500 会给我这个：

Testing Dummy ... 0 ms
Testing Normal first time ... 0 ms
Testing Normal Regex ... 1 ms
Testing Compiled first time ... 13 ms
Testing Compiled ... 1 ms

经过 500 万次迭代，我得到：

Testing Dummy ... 0 ms
Testing Normal first time ... 0 ms
Testing Normal Regex ... 17,232 ms
Testing Compiled first time ... 17 ms
Testing Compiled ... 15,299 ms

在这里您可以看到编译后的正则表达式比未编译的版本至少快 10%。

有趣的是，如果您从正则表达式中删除 RegexOptions.IgnoreCase，500 万次迭代的结果会更加惊人：

Testing Dummy ... 0 ms
Testing Normal first time ... 0 ms
Testing Normal Regex ... 12,869 ms
Testing Compiled first time ... 14 ms
Testing Compiled ... 8,332 ms

这里，编译的正则表达式比未编译的正则表达式快 35%。

在我看来，您引用的博文只是一个有缺陷的测试。

Answer 2

http://www.codinghorror.com/blog/2005/03/to-compile-or-not-to-compile.html

仅当您将其实例化一次并多次重复使用它时，Compiled 才会有所帮助。如果您在 for 循环中创建已编译的正则表达式，那么它的性能显然会更差。您能向我们展示您的示例代码吗？

Answer 3

这个基准的问题是编译的正则表达式有创建一个全新的程序集并将其加载到 AppDomain 的开销。

编译正则表达式的设计场景（我相信——我没有设计它们）是让数十个正则表达式执行数百万次，而不是数千个正则表达式执行数千次。如果您不打算在领域内执行一百万次正则表达式，那么您甚至可能都无法弥补 JIT 编译它的时间。

Answer 4

这几乎肯定表明您的基准代码编写不正确，而编译的正则表达式比解释的慢。使编译的正则表达式的性能有很多工作要做。

现在我们有了代码，可以查看一些需要更新的具体内容

1. 此代码不考虑该方法的 JIT 成本。它应该运行一次代码以消除 JIT 成本，然后再次运行并测量
2. 为什么要使用lock？完全没有必要
3. 基准测试应使用StopWatch 而不是DateTime
4. 要在已编译和未编译之间进行良好比较，您应该测试匹配 N 次的单个已编译 Regex 和单个未编译 Regex 的性能。不是每个正则表达式最多一次匹配的 N 个。