Optimize MPI code for any big integer number - c

Question

I'm trying to compute an estimation of pi using Monte Carlo methods.
The method that I used is that of the circumference inscribed into a square.
This is my simple code for the solution of the problem:
#define _XOPEN_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <mpi.h>
#define SEED time(NULL)
void pi_mpi_version(void) {
unsigned int seed;
long long int all_point;
double x, y, start, end;
int rank, size;
long long int i, points = 0, all_intern;
MPI_Init(NULL, NULL);
start = MPI_Wtime();
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &size);
seed = SEED + rank;
for ( i = 0; i < 1000000000; i++ ) {
x = (double) rand_r(&seed) / RAND_MAX;
y = (double) rand_r(&seed) / RAND_MAX;
if ( x * x + y * y <= 1.0 ) points++;
}
MPI_Reduce(&points, &all_intern, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD);
all_point = 1000000000 * size;
MPI_Barrier(MPI_COMM_WORLD);
end = MPI_Wtime();
if ( rank == 0 ) {
printf("All intern: %lld\n", all_intern);
printf("All points: %lld\n", all_point);
printf("\u03C0 \u2248 %Lf\n", (long double) all_intern / all_point * 4.0);
printf("Time elapsed: %.4f\n", end - start);
}
MPI_Finalize();
}
I try to set all varible to long long int but with the input 1000000000 like in the code, that return a negative number. With input up to 100000000 it seems to work.

Answer 1

That's actually a much more interesting question than you might imagine. Your results are the combination of two issues: Overflow and a type confusion.
First the overflow part:
Numbers larger than 2147483647 can't be represented using signed 32 bit integers, which is the default size of an int in many C++ compilers as well as what MPI uses for the internal representation of an MPI_INT. So as soon as you have more than a 2-3 MPI ranks, the partial counts in the magnitude of 1000000000 * pi / 4 can still be represented as an int, but their sum can't - the result overflows and becomes a negative number. The same holds for the line
1000000000 * size
Without any suffix, both size and 1000000000 are of type int, so is their product. This computation will thus overflow, and only then will the result be stored in the larger long long int all_points variable.
Simple fix: Replace the computation by
1000000000LL * size
This forces the first integer to be of type long long int, so the whole computation won't overflow.
But your code has a second, more serious issue: Type confusion.
MPI_Reduce expects a void* value for both its send and receive buffer, which means that you can use any pointer as a parameter. The type confusion now is that MPI_Reduce expects you to pass a pointer to an int, because you passed MPI_INT as the type argument. But the pointer you passed points to a long long int. What you would need to use instead is MPI_LONG_LONG_INT, which corresponds to the long long int type.
If you want to know why your code still worked for smaller iteration counts, you can read up on the binary representation of integers, especially Little/Big Endian.