mpz_add() causes segmentation Fault at large program - c

Question

My problem is the following. I have to write a program which calculates a really large element of the Fibonacci numbers (lowest it has to calculate is the pow(2,10)th member, largest is pow(2,20)th member). For this I'm using GMP's mpz_t and it's functions for calculations.
I use a tail recursive algorithm for this (later on I have to make it run parallel). The issue is that it runs for a while, then suddenly: Segmentation fault (core dumped).
I show you my code, explain it, so you don't have to waste your time figuring it out and tell you what I got to know.
int main(int argc, char** argv){
char result[1000000]; char *r; r = result;
long int n;
mpz_t num;
mpz_init(num);
double start_t, end_t, total_t;
start_t = omp_get_wtime();
for(int i = 0; i < 11; i++){
n = pow(2,i+10);
fibo(num,n);
char *d = mpz_get_str(NULL,10,num);
strcpy(r,d);
printf("The %ld. element of Fibonacci is: %s\n",n,result);
fflush(stdout);
memset(result, 0, sizeof result);
}
end_t = omp_get_wtime();
total_t = end_t - start_t;
printf("Time of running: %.6f\n",total_t);
return 0;
}
The main() function basically creates (and initializes) the variables, sets up the time measurement and in a for loop calls the fibo() function, getting the result and printing it. When everything is done, the program writes out the time of running and quits.
void fibo(mpz_t res, long int n){
if(n == 0){
mpz_set_str(res,"0",10);
return;
}else{
mpz_t temp1;
mpz_t temp2;
mpz_init_set_si(temp1,0);
mpz_init_set_si(temp2,1);
fiboTail(res,n,1,temp1,temp2);
mpz_clear(temp1);
mpz_clear(temp2);
}
}
fibo() gets 2 arguments, first one is mpz_t (for the ones who don't know, this is a pointer and it's going to belong to the one that got created in the main() so the final value is going to land back there for further usage) and the second one is the number of the element we need to calculate. If the element number is 0, we simply give back "0", otherwise we make two mpz_t variables, set one two "0", the other to "1" and hand them to the fiboTail() along with some other arguments.
void fiboTail(mpz_t res, long int n, long int m, mpz_t fibPrev, mpz_t fibCurrent){
if(n == m){
mpz_set(res,fibCurrent);
}else{
mpz_add(fibPrev,fibPrev,fibCurrent);
fiboTail(res,n, m + 1, fibCurrent, fibPrev);
}
}
So this one basically is the core. m counts how many additions we have done, on which element we are at, n is the number of element we need, fibCurrent and fibPrev is the current and previous Fibonacci number respectively.
Sorry for the dumb explanation, I figure most of you knew this without me trying to explain.
So, this program is really fast. The problem (Segmentation fault) happens when it's counting the 131072th element (sometimes on a smaller one, its...random(?)). Then the program stops about the same number of addition/m value (not always on the same one, but close to there) and the previously mentioned error message appears. I use gcc to compile (actually using Makefiles), so I added the -g switch and used gdb to get more info. Here is what I found:
I ran the program in gdb and used backtrace which produce this.
Here is the detailed stack info using info frame on frame #0-5. The error occurs at the mpz_add call, but I don't know why.
If you need any more information, I can give them, but for now I don't know what else would be useful.
Sorry for the long post, thanks for the answers in advance!
Edit:
As it seems that mpz_add dies at a point, I got out the info of the call, you can see it: i.imgur.com/XOpTve1.png (Sorry, can't post more than 2 links :/ )

Answer 1

Not sure if this will help, but here is the Lucas sequence method for finding fibonacci(n), which is fast and could be used to confirm your results (such as size of the result which may be too big). It's similar to implementing fibnoacci(n) in matrix form and using repeated squaring to raise the matrix to the nth power where fib(n) = M^n x fib(0), where M is a 2 by 2 matrix, and fib() is a 2 element vector. The Lucas sequence function takes 1 + log2(n) loops to run, so for n=2^20, it would take 21 loops.
uint64_t fibl(uint64_t n) {
uint64_t a, b, p, q, qq, aq;
a = q = 1;
b = p = 0;
while(1) {
if(n & 1) {
aq = a*q;
a = b*q + aq + a*p;
b = b*p + aq;
}
n >>= 1;
if(n == 0)
break;
qq = q*q;
q = 2*p*q + qq;
p = p*p + qq;
}
return b;
}

Answer 2

Try this: instead of repeatedly making tail calls which might not be optimized, iteratively calculate the values or use memoization. The program is probably running out of memory somewhere.

Answer 3

What you got is just the plain old stack overflow due to the recursive nature of your fiboTail function.
First, note that you don't need a debbuger to check for this, just place some printfs around fiboTail and you'll see that mpz_add executes fine and the fault happens just at the fiboTail call, before the entry to the next fiboTail with (n,m) values like (131072,115265), (131072,115224), and (131072,115218).
You can get rid of recursion rewritting fiboTail as
void fiboTail(mpz_t res, long int n, long int m, mpz_t fibPrev, mpz_t fibCurrent) {
mpz_t tmp;
mpz_init(tmp);
for (long int i = m; i < n; i++) {
mpz_add(fibPrev, fibPrev, fibCurrent);
mpz_set(tmp, fibPrev);
mpz_set(fibPrev, fibCurrent);
mpz_set(fibCurrent, tmp);
}
mpz_set(res, fibCurrent);
}
Of course, you can simplify the call by removing some parameters, or just place its code inside fibo.
In my (very old) PC, Core I5 2th gen 4Gb RAM, I get (replaced omp_get_wtime with clock from time.h, though):
Time of running: 11.068110
and it seems all elements check, up to the 1048576th which has 219140 chars, and first digits check with the answers from WolframAlpha.
If recursion is so important (note that you don't necessarily need it for parallel programming), you can either increase stack size (at compile or runtime), or you can check your compiler setting to reuse the fiboTail stack frame, since you are using tail recursion.