我想用openMP优化递归。所以，我从这个问题开始：best-way-to-parallelize-this-recursion-using-openmp
在优化递归函数时，我首先对openMP感兴趣。从下面的代码开始，我发现那里（https://en.cppreference.com/w/cpp/chrono）：

#include <iostream>
#include <chrono>
 
long fibonacci(unsigned n)
{
    if (n < 2) return n;
    return fibonacci(n-1) + fibonacci(n-2);
}
 
int main()
{
    auto start = std::chrono::steady_clock::now();
    std::cout << "f(42) = " << fibonacci(42) << '\n';
    auto end = std::chrono::steady_clock::now();
    std::chrono::duration<double> elapsed_seconds = end-start;
    std::cout << "elapsed time: " << elapsed_seconds.count() << "s\n";
}

用g++编译，没有任何优化，它给出的结果是：

f(42) = 267914296
elapsed time: 1.88232s

然后我用类似的openMP的答案向上...但我不得不停止这个过程，因为它花了很长很长的时间。我不知道很多关于openMP递归并行，因为我只是用它来优化我的代码中的循环。另外，我在GCC文档中发现了一些东西：

__attributes__((const))

然后我把它添加到我的openMP“优化”版本，但我得到的只是一个核心转储！！！
所以我删除了我的omp杂注，以检查核心转储是由于我的代码或其他东西...
然后代码变成了：

#include <iostream>
#include <chrono>

__attribute__ ((const))
long fibonacci(unsigned n)
{
   
   int long r[2];

   if (n < 2) return n;
   r[0]=fibonacci(n-1);
   r[1]=fibonacci(n-2);
   return (r[0]+r[1]);
}
 
int main()
{
    auto start = std::chrono::steady_clock::now();
    std::cout << "f(42) = " << fibonacci(42) << '\n';
    auto end = std::chrono::steady_clock::now();
    std::chrono::duration<double> elapsed_seconds = end-start;
    std::cout << "elapsed time: " << elapsed_seconds.count() << "s\n";
}

我使用以下命令编译了它：

g++ fibonacci.cpp -o fibonacci -Wall -O2 -march=native

现在，执行42的Fibonacci计算所需的时间要少得多：

f(42) = 267914296
elapsed time: 0.00106504s

在保存模式和性能模式中，它给出

f(42) = 267914296
elapsed time: 0.000187806s

这里是我的计算机的lscpu（如果有人想比较结果）：

Architecture:            x86_64
  CPU op-mode(s):        32-bit, 64-bit
  Address sizes:         39 bits physical, 48 bits virtual
  Byte Order:            Little Endian
CPU(s):                  8
  On-line CPU(s) list:   0-7
Vendor ID:               GenuineIntel
  Model name:            Intel(R) Core(TM) i7-7700K CPU @ 4.20GHz
    CPU family:          6
    Model:               158
    Thread(s) per core:  2
    Core(s) per socket:  4
    Socket(s):           1
    Stepping:            9
    CPU(s) scaling MHz:  95%
    CPU max MHz:         4500,0000
    CPU min MHz:         800,0000
    BogoMIPS:            8403,00

现在，我不知道用openMP要花多少时间，因为我没能得到满意的结果...我希望有人能找到一种方法，将omp杂注添加到这种递归情况中。
根据需要，这里是这个案例的omp版本1：

#include <iostream>
#include <chrono>
#include <omp.h>

__attribute__ ((const))
long fibonacci(unsigned n)
{
   
    int long a, b;

    if (n < 2) return n;
    #pragma omp parallel
    #pragma omp single nowait
    {         
       #pragma omp task shared(a)
       a=fibonacci(n-1);
       #pragma omp task shared(b)
       b=fibonacci(n-2);
       #pragma omp taskwait
    }
    return (a+b);
}
 
int main()
{
    auto start = std::chrono::steady_clock::now();
    std::cout << "f(42) = " << fibonacci(42) << '\n';
    auto end = std::chrono::steady_clock::now();
    std::chrono::duration<double> elapsed_seconds = end-start;
    std::cout << "elapsed time: " << elapsed_seconds.count() << "s\n";
}

和版本，驱动我到一个“愚蠢的代码”：

#include <iostream>
#include <chrono>
#include <omp.h>

__attribute__ ((const))
long fibonacci(unsigned n)
{
   
   int long r[2];
   int i;
   if (n < 2) return n;
   #pragma omp parallel
   #pragma omp single
   for(i=0;i<2;++i) 
   {
       #pragma omp task shared(r)   
       r[i]=fibonacci(n-i-1);
   }      
    
    return (r[0]+r[1]);
}
 
int main()
{
    auto start = std::chrono::steady_clock::now();
    std::cout << "f(42) = " << fibonacci(42) << '\n';
    auto end = std::chrono::steady_clock::now();
    std::chrono::duration<double> elapsed_seconds = end-start;
    std::cout << "elapsed time: " << elapsed_seconds.count() << "s\n";
}

这些omp版本的构建命令为：

g++ omp_fibonacci_for.cpp -o omp_fibonacci_for -Wall -fopenmp

它们似乎都是“永远”循环的（幸运的是Ctrl-C工作得很好）。但是，在写这个问题的结尾时，第二个版本用“for”，处理成功：

f(42) = 267914296
elapsed time: 480.953s

需要说明的是，我不是在寻找“最佳性能”，我的目标是试图获得一个在合理时间内处理的omp版本，目的是找到在递归代码上使用openMP的方法。老实说，我期待一个更好的执行时间比480 s！我也很惊讶它在“差调试”版本中所花的时间，它花了更少的0. 001秒来处理...
现在的问题是，我想知道我使用openMP的方式是否可以接受，如果我将这个模型应用于“更复杂”的任务，或者如果我做错了什么。