【问题标题】:Calculate the Fibonacci number (recursive approach) in compile time (constexpr) in C++11在 C++11 中计算编译时 (constexpr) 中的斐波那契数(递归方法)
【发布时间】:2014-05-03 22:38:38
【问题描述】:

我在编译时编写了斐波那契数计算程序(constexpr) 使用 C++11 中支持的模板元编程技术的问题。目的 其中一个是计算模板元编程方法与旧的传统方法之间的运行时间差异。

// Template Metaprograming Approach
template<int  N>
constexpr int fibonacci() {return fibonacci<N-1>() + fibonacci<N-2>(); }
template<>
constexpr int fibonacci<1>() { return 1; }
template<>
constexpr int fibonacci<0>() { return 0; }



// Conventional Approach
 int fibonacci(int N) {
   if ( N == 0 ) return 0;
   else if ( N == 1 ) return 1;
   else
      return (fibonacci(N-1) + fibonacci(N-2));
} 

我在我的 GNU/Linux 系统上运行了 N = 40 的两个程序并测量了时间和 发现传统解决方案(1.15 秒)比基于模板的解决方案(0.55 秒)慢两倍左右。这是一个显着的改进,因为这两种方法都基于递归。

为了更了解它,我在 g++ 中编译了程序(-fdump-tree-all 标志),发现编译器实际上生成了 40 个不同的函数(如 fibonacci、fibonacci ...斐波那契)。

constexpr int fibonacci() [with int N = 40] () {
  int D.29948, D.29949, D.29950;
  D.29949 = fibonacci<39> ();
  D.29950 = fibonacci<38> ();
  D.29948 = D.29949 + D.29950;
  return D.29948;
}

constexpr int fibonacci() [with int N = 39] () {
  int D.29952, D.29953, D.29954;
  D.29953 = fibonacci<38> ();
  D.29954 = fibonacci<37> ();
  D.29952 = D.29953 + D.29954;
  return D.29952;
}
...
...
...
constexpr int fibonacci() [with int N = 0] () {
  int D.29962;
  D.29962 = 0;
  return D.29962;
}

我也在GDB中调试了程序,发现上面所有的功能都是 执行与传统递归方法相同的次数。 如果程序的两个版本都执行相同次数的函数(递归),那么模板元编程技术是如何实现的呢?我还想知道您对基于模板元编程的方法与其他版本相比如何以及为何花费一半时间的看法?这个程序可以比现在的程序更快吗?

基本上我的目的是尽可能了解内部发生的事情。

我的机器是带有 GCC 4.8.1 的 GNU/Linux,我对这两个程序都使用了优化 -o3。

【问题讨论】:

  • 不要使用简单的f(n) = f(n - 1) + f(n - 2) 公式来计算斐波那契数。
  • 您报告的时间是执行调试代码还是非调试代码?
  • @Constructor 你更喜欢哪种方法?我个人喜欢将 {1,1 \n 1, 0} 矩阵提高到 n-1 的幂,并取左上角的变量作为答案。我发现如果操作得当,它需要执行得非常快。您还可以添加 matrix-to-2^k hack 以获得更快的速度。无论如何,对于这个问题,模板模板通常是一个坏主意,太多的空间。
  • @Shingetsu 是的,它是最快的解决方案(具有对数时间复杂度)。但我的意思是,由于大量且无意义的递归调用,简单的公式是不合适的。

标签: c++ templates c++11 recursion fibonacci


【解决方案1】:

原因是您的运行时解决方案不是最优的。对于每个 fib 编号,函数会被调用多次。斐波那契数列有重叠的子问题,例如fib(6) 调用fib(4),fib(5) 也调用fib(4)。

基于模板的方法使用(无意中)动态编程方法,这意味着它存储先前计算的数字的值,避免重复。所以,当fib(5) 调用fib(4) 时,这个数字已经在fib(6) 调用时计算出来了。

我建议查找“动态编程斐波那契”并尝试一下,它应该会大大加快速度。

【讨论】:

  • 感谢您的解释和建议。但我在问题中提到,在这两种情况下,函数调用的数量相同,所以您仍然认为基于模板使用动态编程方法。是的,我知道动态编程方法会加快速度,但我想通过使用递归(较慢)方法来检查两者的区别。
  • @tmp 你确定它有相同数量的调用吗?具有给定参数集的模板被实例化多次是没有意义的。它甚至不是一个函数调用。
【解决方案2】:

试试这个:

template<size_t N>
struct fibonacci : integral_constant<size_t, fibonacci<N-1>{} + fibonacci<N-2>{}> {};

template<> struct fibonacci<1> : integral_constant<size_t,1> {};
template<> struct fibonacci<0> : integral_constant<size_t,0> {};

使用 clang 和 -Os,编译大约需要 0.5 秒,N=40 的运行时间零。您的“常规”方法在大约 0.4 秒内编译并在 0.8 秒内运行。只是为了检查,结果是102334155对吗?

当我尝试您自己的constexpr 解决方案时,编译器运行了几分钟,然后我停止了它,因为显然内存已满(计算机开始冻结)。编译器试图计算最终结果,而您的实现在编译时使用效率极低。

使用此解决方案,N-2、N-1 处的模板实例化在实例化 N 时被重新使用。所以fibonacci&lt;40&gt;实际上在编译时被称为一个值,在运行时没有什么可做的。这是一种动态编程方法,当然,如果在计算 N 之前将所有值存储在 0 到 N-1,您可以在运行时执行相同的操作。

使用您的解决方案,编译器可以在编译时评估fibonacci&lt;N&gt;(),但不需要。在您的情况下,全部或部分计算留给运行时。就我而言,所有计算都是在编译时尝试的,因此永远不会结束。

【讨论】:

  • 我认为使用问题中的代码可以缩短它:`template struct Fibonacci : std::integral_constant()> {};跨度>
  • @Constructor 好吧,这意味着作为一种替代实现。正如我所说,问题的constexpr 解决方案从未设法为N=40 编译。似乎模板实例被记忆了,而constexpr 函数调用的结果没有。
  • 我认为clang中存在问题(可能是错误)。比较:gcc N = 40、clang N = 26 和 clang N = 27(clang 的结果对于所有 N &gt; 26 都是相同的)。
  • 不是真的,至少对我来说。 121393, 196418, 102334155 for N=26,27,40 for gcc 和 clang。
  • 这很奇怪。我认为clang提到的constexpr评估的最大步长(在我的例子中是N = 27)应该在其设置中指定。
【解决方案3】:

也许只是使用更有效的算法?

constexpr pair<double, double> helper(size_t n, const pair<double, double>& g)
{
    return n % 2
        ? make_pair(g.second * g.second + g.first * g.first, g.second * g.second + 2 * g.first * g.second)
        : make_pair(2 * g.first * g.second - g.first * g.first, g.second * g.second + g.first * g.first);
}

constexpr pair<double, double> fibonacciRecursive(size_t n)
{
    return n < 2
        ? make_pair<double, double>(n, 1)
        : helper(n, fibonacciRecursive(n / 2));
}

constexpr double fibonacci(size_t n)
{
    return fibonacciRecursive(n).first;
}

我的代码基于 D. Knuth 在他的“计算机编程艺术”的第一部分中描述的一个想法。我不记得这本书的确切位置,但我确信那里描述了算法。

【讨论】:

  • 你为什么用double?
  • 斐波那契数列中的数字增长非常快,所以我们需要防止溢出。
  • 不会那么快导致int 溢出N = 40。
  • 你如何衡量速度? Seems to me it doesn't work slowly
  • 你的意思是什么速度?我的意思是f(40) &lt; std::numeric_limits&lt;int&gt;::max()。
【解决方案4】:

在 GCC4.8.1 中添加 -O1(或更高版本)将使 fibonacci() 成为编译时间常数,并且所有模板生成的代码将从您的程序集中消失。以下代码

int foo()
{
  return fibonacci<40>();
}

将产生汇编输出

foo():
    movl    $102334155, %eax
    ret

这提供了最佳的运行时性能。

但是,看起来您正在构建没有优化 (-O0) 的东西,所以您得到的东西有些不同。 40 个斐波那契函数中的每一个的汇编输出看起来基本相同(除了 0 和 1 情况)

int fibonacci<40>():
    pushq   %rbp
    movq    %rsp, %rbp
    pushq   %rbx
    subq    $8, %rsp
    call    int fibonacci<39>()
    movl    %eax, %ebx
    call    int fibonacci<38>()
    addl    %ebx, %eax
    addq    $8, %rsp
    popq    %rbx
    popq    %rbp
    ret

这很简单,它设置堆栈,调用另外两个斐波那契函数,添加值,拆掉堆栈,然后返回。没有分支,也没有比较。

现在将其与传统方法的组装进行比较

fibonacci(int):
    pushq   %rbp
    pushq   %rbx
    subq    $8, %rsp
    movl    %edi, %ebx
    movl    $0, %eax
    testl   %edi, %edi
    je  .L2
    movb    $1, %al
    cmpl    $1, %edi
    je  .L2
    leal    -1(%rdi), %edi
    call    fibonacci(int)
    movl    %eax, %ebp
    leal    -2(%rbx), %edi
    call    fibonacci(int)
    addl    %ebp, %eax
    .L2:
    addq    $8, %rsp
    popq    %rbx
    popq    %rbp
    ret

每次调用该函数时,它都需要检查 N 是 0 还是 1 并采取适当的行动。在模板版本中不需要这种比较,因为它是通过模板的魔力内置到函数中的。我的猜测是模板代码的未优化版本更快,因为您避免了这些比较并且也不会错过任何分支预测。

【讨论】:

  • 我确实尝试了所有优化标志(o1 o2 o3),但在我的终端上没有找到任何这样的东西。您是否在您的案例中看到了您已经解释过的情况,或者这只是您的假设。
  • 我使用gcc.godbolt.org 对其进行了验证,我展示的所有程序集输出都是从那里剪切和粘贴的。我没有做任何假设。
  • 我不相信这是在使用 c++ constexpr,只是编译器优化器做了一些很好但不能保证的事情。
猜你喜欢
  • 1970-01-01
  • 2016-02-24
  • 1970-01-01
  • 1970-01-01
  • 2012-12-03
  • 2011-08-02
  • 1970-01-01
  • 2020-01-18
  • 2010-12-03
相关资源
最近更新 更多