浅谈尾递归的优化方式

在上文《尾递归与Continuation》里，我们谈到了尾递归的概念和示例，不过有些朋友对于尾递归的功效依然有所怀疑。因此现在，我再简单讲解一下尾递归的优化原理，希望能给大家以一定理性认识。
尾递归的循环优化

尾递归，即是递归调用放在方法末尾的递归方式，如经典的阶乘：

1. int FactorialTailRecursion(int n, int acc)
2. {
3.     if (n == 0) return acc;
4.     return FactorialTailRecursion(n - 1, acc * n);
5. }

复制代码

由于递归在方法的末尾，因此方法中的局部变量已经毫无用处，编译器完全可以将其“复用”，并把尾递归优化为“循环”方式：

1. int FactorialLoopOptimized(int n, int acc)
2. {
3.     while (true)
4.     {
5.         if (n == 0) return acc;
7.         acc *= n;
8.         n--;
9.     }
10. }

复制代码

不过，上文还提到了尾递归中的常用技巧Continuation。那么对于如下形式的Continuation，编译器又该如何优化呢？

1. int FactorialContinuation(int n, Func<int, int> continuation)
2. {
3.     if (n == 0) return continuation(1);
4.     return FactorialContinuation(n - 1, r => continuation(n * r));
5. }

复制代码

我们先用“人脑”来思考一下，这段代码的执行方式是怎么样的。我们每次使用n和contn调用FactorialContinuation时，都会构造一个新的contn - 1，并同n - 1传入下一次FactorialContinuation调用中去。以此类推，直到n等于0时，就直接调用cont0并返回。至于每个Continuation的定义，我们可以归纳出如下结果：

1. Func<int, int> cont_n = r => r * n

复制代码

因此：

1. Factorial(n)
2.     = cont_n(cont_{n - 1}(...(cont₂(cont₁(cont₀(1)))...))
3.     = n * ((n – 1) * (...(2 * (1 * 1))...)) =
4.     = n * (n - 1) * ... * 2 * 1
5.     = n!

复制代码

于是，我们可以根据这个“意图”，将FactorialContinuation方法“优化”为如下形式：

1. int FactorialLoopOptimized2(int n, Func<int, int> continuation)
2. {
3.     LinkedList<Func<int, int>> contList = new LinkedList<Func<int, int>>();
5.     while (true)
6.     {
7.         if (n == 0) break;
9.         int tempN = n;
10.         Func<int, int> newCont = r => tempN * r;
11.         contList.AddFirst(newCont);
13.         n--;
14.         continuation = newCont;
15.     }
17.     return contList.Aggregate(1, (acc, cont) => cont(acc));
18. }

复制代码

我们构造了一个Continuation函数链表，随着n递减，每次都会把新的Continuation函数插入到链表头，最后Aggregate方法会将第一个参数（累加器）依次运用到每个函数中去，得到最后结果并返回。只可惜，这个优化完全是我们“一厢情愿”而已，这么做的前提是“理解”了函数的意义，把方法的迭代调用“拆开”，而编译器是无法（还是很难）帮我们优化到如斯地步的。那么编译器对于此类问题又该如何解决呢？
之前，我们使用C#中的匿名方法特性来构造每个Continuation方法。如果我们使用自定义的封装类，再将递归“优化”成循环，FactorialContinuation又会成为什么样呢？如下：

1. private class Continuation
2. {
3.     public Continuation(Func<int, int> cont, int n)
4.     {
5.         this.cont = cont;
6.         this.n = n;
7.     }
9.     private Func<int, int> cont;
10.     private int n;
12.     public int Invoke(int r)
13.     {
14.         return this.cont(this.n * r);
15.     }
16. }
18. public static int FactorialLoopOptimized3(int n, Func<int, int> continuation)
19. {
20.     while (true)
21.     {
22.         if (n == 0) break;
23.         continuation = new Continuation(continuation, n).Invoke;
24.         n--;
25.     }
27.     return continuation(1);
28. }

复制代码

其实这才是FactorialContinuation的“直译”，也是编译器能够进行优化。不过朋友们应该也能够看出，这只是一个Continuation对象套着另一个Continuation对象。如果形成了数万个Continuation对象的嵌套，在最终调用最外层的Continuation时，每个内部的Continuation也会在调用时往同一个堆栈中不断累加，最终还是会造成堆栈溢出。因此，如果使用了Continuation，还是无法简单把递归优化成循环来避免堆栈溢出的。编译器还必须进行其他方面的优化。
方法尾调用的优化

上一篇文章曾经谈到：“与普通递归相比，由于尾递归的调用处于方法的最后，因此方法之前所积累下的各种状态对于递归调用结果已经没有任何意义，因此完全可以把本次方法中留在堆栈中的数据完全清除，把空间让给最后的递归调用。这样的优化便使得递归不会在调用堆栈上产生堆积，意味着即时是“无限”递归也不会让堆栈溢出”。这其实才是尾递归的“正统”优化方式，那么我们先暂时忘记之前的“循环优化”，从最简单的示例中查看这样的优化是如何进行的。还是最简单的“尾递归”阶乘：

1. static int FactorialTailRecursion(int n, int acc)
2. {
3.     if (n == 0) return acc;
4.     return FactorialTailRecursion(n - 1, acc * n);
5. }

复制代码

它的IL代码是：

1. .method private hidebysig static int32 FactorialTailRecursion(int32 n, int32 acc) cil managed
2. {
3.     .maxstack 8
4.     L_0000: ldarg.0            // 加载第1个参数，即n
5.     L_0001: brtrue.s L_0005    // 如果第一个参数不为0，则跳转到L_0005
6.     L_0003: ldarg.1            // 运行到此，说明第1个参数为0，则加载第2个参数，即acc
7.     L_0004: ret                // 返回（刚加载的第2个参数）
8.     L_0005: ldarg.0            // 加载第1个参数，即n
9.     L_0006: ldc.i4.1           // 加载数值1
10.     L_0007: sub                // 将两者相减，即n - 1
11.     L_0008: ldarg.1            // 加载第2个参数，即acc
12.     L_0009: ldarg.0            // 加载第1个参数，即n
13.     L_000a: mul                // 将两者相乘，即acc * n
14. 　　// 把n - 1和acc * n作为参数递归调用
15.     L_000b: call int32 TailRecursion.Recursion::FactorialTailRecursion(int32, int32)
16.     L_0010: ret                // 返回递归调用结果
17. }

复制代码

在这个问题上，我们还需要观察它的汇编代码（为了不干扰文章内容，我会把获取汇编代码的做法单独写一篇文章，稍后发布），如下：

1. <font color="#ff0000">00ad00d0</font>    push    ebp
2. 00ad00d1    mov     ebp,esp
3. 00ad00d3    push    esi
4. 00ad00d4    mov     eax,edx
5. 00ad00d6    test    ecx,ecx
6. 00ad00d8    jne     00ad00dd
7. 00ad00da    pop     esi
8. 00ad00db    pop     ebp
9. 00ad00dc    ret
10. 00ad00dd    lea     edx,[ecx-1]
11. 00ad00e0    imul    ecx,eax
12. 00ad00e3    mov     esi,ecx
13. 00ad00e5    test    edx,edx
14. 00ad00e7    jne     00ad00ed
15. 00ad00e9    mov     eax,esi
16. 00ad00eb    jmp     00ad00f9
17. 00ad00ed    lea     ecx,[edx-1]
18. 00ad00f0    imul    edx,esi
19. 00ad00f3    call    dword ptr ds:[703068h] (地址703068h的值即为<font color="#ff0000">00ad00d0</font>)
20. 00ad00f9    pop     esi
21. 00ad00fa    pop     ebp
22. 00ad00fb    ret

复制代码

上面的汇编代码非常简单，从中可以看出，每次递归调用都使用了最简单的call指令，没有经过任何有效的优化或调整。因此在不断地递归调用之后，终究会出现堆栈溢出。这就是普通递归的缺陷。而对于尾递归来说，MSIL提供了额外的tail指令表示“尾调用”1，它只需简单补充在IL指令call, callvirt, calli之前便可。因此我们使用ildasm.exe将IL代码dump出来，并在call之前加上tail指令：

1. .method private hidebysig static int32 FactorialTailRecursion(int32 n, int32 acc) cil managed
2. {
3.     .maxstack 8
4.     L_0000: ldarg.0
5.     L_0001: brtrue.s L_0005
6.     L_0003: ldarg.1
7.     L_0004: ret
8.     L_0005: ldarg.0
9.     L_0006: ldc.i4.1
10.     L_0007: sub
11.     L_0008: ldarg.1
12.     L_0009: ldarg.0
13.     L_000a: mul
14.     <font color="#ff0000">L_000b: tail.</font>
15.     L_000c: call int32 TailRecursion.Recursion::FactorialTailRecursion(int32, int32)
16.     L_0010: ret
17. }

复制代码

使用ilasm.exe重新编译之后运行，再重新察看FactorialTailRecursion的汇编代码：

1. 00a600d0    push    ebp
2. 00a600d1    mov     ebp,esp
3. 00a600d3    push    edi
4. 00a600d4    push    esi
5. 00a600d5    push    ebx
6. 00a600d6    mov     eax,ecx
7. 00a600d8    mov     esi,edx
8. 00a600da    test    eax,eax
9. 00a600dc    jne     00a600e5
10. 00a600de    mov     eax,esi
11. 00a600e0    pop     ebx
12. 00a600e1    pop     esi
13. 00a600e2    pop     edi
14. 00a600e3    pop     ebp
15. 00a600e4    ret
16. 00a600e5    lea     ecx,[eax-1]
17. 00a600e8    imul    eax,esi
18. 00a600eb    mov     edx,eax
19. 00a600ed    mov     eax,dword ptr ds:[813068h]
20. 00a600f3    push    0
21. 00a600f5    push    0
22. 00a600f7    push    1
23. 00a600f9    push    eax
24. 00a600fa    cmp     dword ptr [mscorwks!g_TrapReturningThreads (7204339c)],0
25. 00a60101    je      00a6010c
26. 00a60103    push    ecx
27. 00a60104    push    edx
28. 00a60105    call    mscorwks!JIT_PollGC (71d5c9d3)
29. 00a6010a    pop     edx
30. 00a6010b    pop     ecx
31. 00a6010c    call    mscorwks!JIT_TailCall (71b02890)
32. 00a60111    int     3

复制代码

在这里我实在无法完整讲述上述汇编代码的含义，不过从中可以看出它的确对于尾递归进行了特别的处理，而并非使用简单的call指令进行调用。对此互联网上的资源也不多，我只找到了Shri Borde的一篇文章，其中简单描述了Whidbey V2（真早）中CLR对于这方面的处理，以及一些相关的考虑，从中似乎能够看出一些苗头来。
让我们再回想之前的问题：Continuation无法通过简单优化为循环来解决递归问题。但是通过观察可以看出，Continuation.Invoke方法中的cont委托调用是最后一条命令，这说明它是一个“尾调用”——虽然不是“尾递归”，不过这已经满足tail指令的要求了：只需和所在方法返回值相同（或兼容）即可。因此，对于Continuation来说，我们也需要进行尾递归的优化。您可以进行尝试，现在无论递归多“深”，都不会使堆栈溢出了。
 
注1：与tail类似，IL指令jmp也能够用于方法调用。这两条指令都不会在调用栈上堆积数据。tail与jmp的不同之处在于，前者只需要返回值与所在方法相同或兼容即可，而后者需要签名完全相同。您可以想象得到，对于“直接递归”来说，可以使用jmp进行调用，而普通的“尾调用”，则只能使用tail了。

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！