遞歸調用的棧溢出估計

代碼規范中不允許遞歸調用，實際開發中應該盡量避免對遞歸的使用，究其原因主要是以下兩點：

1. 嵌套深度上會存在一定風險，遞歸層數過多，不斷壓棧，可能會引起棧溢出的問題；

2. 代碼可讀性，不太容易被后面維護的人理解；

但是，凡事總有例外。

比如要有一種需求場景，需要遍歷一個目錄下的所有文件，包括其中子目錄中的文件，然后將滿足一定條件的文件篩選出來，

你會發現，用遞歸去設計反而會比較簡單。

對於解決一些包含重復類似邏輯的問題，遞歸對於開發人員來說是一個反而比較清晰的選擇。

本文主要介紹，不得不使用遞歸時，針對上述第一個風險，如何評估棧空間是否足夠。

評估思路：

1. 確認當前線程棧空間限制cur_stack_size是多少？

2. 遞歸調用n次，分析n次壓棧后棧空間的損耗cost_size大約大少？

3. 結合業務評估，預估一個最大可能的遞歸調用次數max

4. （max*cost_size/n） 如果大於或已經接近 cur_stack_size, 表示存在棧越界風險，需要放大棧空間或者做功能規格約束

 

具體以一個例子來說明，main函數中啟動一個線程，線程棧大小可配，線程中遞歸計算一個階乘：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <pthread.h>
#include <errno.h>
#include <limits.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

static char* stack_begin = NULL;
static char* stack_end = NULL;
static int totalnum = 0;
static const char* filepath = "datafile.txt";

static unsigned long factor(int n)
{
    unsigned long ulRet = 0;
    
    if (n == totalnum) 
    {
        stack_begin = (char*)(&ulRet); 
    }
    if (1 == n)
    {
        stack_end =(char*)(&ulRet);
        ulRet = 1; 
    }
    else
    {
        
        ulRet = n*factor(n-1); 
    }
#if 0 
        printf("[%5d], begin:%p,end:%p, &n:%p\n", n, stack_begin,stack_end, &n);
#endif
    return ulRet;
}


static int traverse_test(int test_num, int stack_size)
{
    int i = 0;
    int fd = -1;
    int num = 0; 
    int iret = 0; 
    int stacksize = 0;
    long theoretical_max = 0; 
    float percost = 0.0;
    float stackcost = 0.0;
    pthread_t thread_id;
    pthread_attr_t attr; 
    char info[256];
    
    num = test_num;
    stacksize = stack_size * 1024;
    printf("--------- num :%d, stacksize:%d ---------\n",test_num,stack_size);

    fd = open(filepath,O_CREAT|O_RDWR|O_APPEND,0777);
    if (0 > fd) 
    {
        printf("open file failed, err:%d,%s\n",errno, strerror(errno)); 
        return -1;
    }
    else
    {
        (void)truncate(filepath,0); 
        lseek(fd, 0, SEEK_SET); 
    }

    memset(info,0,sizeof(info)); 
    snprintf(info, sizeof(info),"%s %s %s %s %s\n","num", "stacksize(KB)","percost(KB)","stackcost(KB)","maxNum"); 
    (void)write(fd, info, strnlen(info, sizeof(info)));

    if (0 != pthread_attr_init(&attr))
    {
        printf("pthread attr init err, errno:%d!!!!\n",errno);
        iret = -1;
        goto err_exit; 
    }
    if (0 != pthread_attr_setstacksize(&attr, stacksize))
    {
        printf("pthread set stack err, min[%d],set[%d],errno:%d,err:%s!!!!\n",
            PTHREAD_STACK_MIN,stacksize,errno,strerror(errno));
        iret = -1;
        goto err_exit; 
    }

    for (i = 2; i <= num; i++)
    {
        /*start a pthread to call recursive*/
        memset(&thread_id,0,sizeof(thread_id));
        stack_begin = 0;
        stack_end = 0; 
        totalnum = i;
        if (0 != pthread_create(&thread_id,&attr, factor,i))
        {
            printf("pthread create err, errno:%d!!!!\n",errno);
            iret = -1;
            goto err_exit; 
        } 
        if (0 != pthread_join(thread_id, NULL))
        {
            printf("pthread join err, errno:%d!!!!\n",errno);
            iret = -1;
            goto err_exit; 
        }

        percost =  (float)(stack_begin - stack_end)/(float)i;
        stackcost = (float)(stack_begin - stack_end)/1024.0;
        theoretical_max = (stacksize*i)/(stack_begin - stack_end);
        memset(info,0,sizeof(info)); 
        snprintf(info, sizeof(info),"%d %d %.2f %.2f %ld\n", i, stack_size, percost,stackcost,theoretical_max); 
        (void)write(fd, info, strnlen(info, sizeof(info)));

        if (1 == i || 0 == i % 10)
        {
            printf("testnum[%d], stacksize[%d]KB, percost[%.2f]Byte, stackcost:[%.2f]KB, max maybe:[%ld],!!!!\n",
                i, stack_size,percost,stackcost,theoretical_max);
        }
    }
    iret = 0;

err_exit:
    if (0 != pthread_attr_destroy(&attr))
    {
        printf("pthread attr destroy err, errno:%d!!!!\n",errno);
    }
    close(fd);
    return iret;
}

int main(int argc, char* argv[])
{
    int num = 0;
    int stacksize = 0;

    num = atoi(argv[1]);
    stacksize = atoi(argv[2]);

    if (0 != traverse_test(num,stacksize))
    {
        printf("err happen!!!\n");
        return -1; 
    }

    return 0;
}

 

編譯運行， 測試10的階乘，線程棧配置為16KB：

gcc -g test.c -pthread -o test;./test 10 16

結果如下：

10次遞歸，棧開銷大約： 0x7feef0a2bebc – 0x7feef0a2bbec = 0x2d0,， 720字節

進一步增大迭代次數和線程棧（計算4000的階乘，棧空間定位256KB），將得到的數據繪制分析曲線如下：

（X軸是階乘計算的總數n，Y軸是平均每次階乘棧的開銷KB）：

可以看出來，每次平均每次棧的開銷值並非線性增長，所以評估時注意使用最終持平的那個單次開銷去估算。

保險期間，實際項目中用最高約束規格去做一把驗證性測試。