MPI: program works depending on the number of processes - c

Question

I wrote a program which uses the MPI library (MPICH-2). The program finds all the prime number between 2 and N. It works fine if I use only two processes, but it doesn't when I specify the number of processes >2.
The program is very inefficient, as my aim is to compare performances between a program which uses MPI and the same program which doesn't.
I have a dual core machine and I'm using NetBeans 7.4 on Ubuntu 13.10. Does the problem depend on the number of cores of my machine? I knew that the scheduling is up to the OS, but I don't know what to think! Maybe have I to put an MPI_Barrier? I insert the code and the output below, as you can see some strange zeros appear when I invoke the program with more than 2 procs.
#include <stdio.h>
#include <stdlib.h>
#include <mpi.h>
int count(int *a, int N){
int b[N];
int i, j, n_prime;
for(i=0; i<N; i++)
b[i] = a[i];
b[0] = b[1] = 0;
for (i=2; i<N; i++) {
b[i] = 1;
for (j=2; j<i; j++)
if (i % j == 0) {
b[i] = 0;
break;
}
}
n_prime = 0;
for (j=2; j<N; j++)
if (b[j]) n_prime++;
return n_prime;
}
int main(int argc, char** argv) {
int size, rank, div;
int N;
int *array;
int i, j, k, check, n_prime, n_prime_loc;
int *sub_array, *prime, *recv_prime, *b, *prime2;
double t1, t2;
if(argc != 2){
printf("Argument error: %s not recognized as argument\n", argv[0]);
return -1;
}
N = atoi(argv[1]);
MPI_Init(NULL, NULL);
t1 = MPI_Wtime();
MPI_Comm_size(MPI_COMM_WORLD, &size);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
div = N/size; //elements per process
b = (int*) malloc(sizeof(int)*N);
if (b == NULL){
printf("Cannot allocate array 'b'\n");
return -1;
}
n_prime = count(b, N);
/* Dynamic allocation of the arrays */
sub_array = (int*) malloc(sizeof(int)*div);
if (sub_array == NULL){
printf("Cannot allocate array 'sub_array'\n");
return -1;
}
recv_prime = (int*) malloc(sizeof(int)*n_prime);
if (recv_prime == NULL){
printf("Cannot allocate array 'recv_prime'\n");
return -1;
}
array = (int*) malloc(sizeof(int)*N);
if (array == NULL){
printf("Cannot allocate array 'array'\n");
return -1;
}
prime = (int*) malloc(sizeof(int)*n_prime);
if (prime == NULL){
printf("Cannot allocate array 'prime'\n");
return -1;
}
/* Initialization of the array */
for (i=0; i<N; i++)
array[i] = i+1;
for(i=0; i<n_prime; i++)
prime[i] = 0;
for(i=0; i<n_prime; i++)
recv_prime[i] = 0;
/* Process 0 divides the array among the processes */
MPI_Scatter(array, div, MPI_INT, sub_array, div, MPI_INT, 0, MPI_COMM_WORLD);
check = 0; //used to check if we find a divisor
k=0;
for(i=0; i<div; i++){
check = 0;
if (sub_array[i] == 1) continue;
for(j=2; j<sub_array[i]; j++){
if(sub_array[i] % j == 0){
check = 1;
}
}
if (check == 0){ //if we don't find a divisor, the number is prime
prime[k] = sub_array[i];
k++;
}
}
n_prime_loc = 0;
for(i=0; i<n_prime; i++)
if(prime[i]!=0)
n_prime_loc++;
prime2 = (int*) malloc(sizeof(int)*n_prime_loc);
j=0;
for(i=0; i<n_prime; i++){
if(prime[i]==0) continue;
prime2[j] = prime[j];
j++;
}
/* Each process sends its computation to the root process */
MPI_Gather(prime2, n_prime_loc, MPI_INT, recv_prime, n_prime_loc, MPI_INT, 0, MPI_COMM_WORLD);
MPI_Barrier(MPI_COMM_WORLD);
if(rank == 0){
printf("Prime numbers: ");
for(i=0; i<n_prime; i++)
printf("%i ", recv_prime[i]);
printf("\n");
}
/* Free the allocated arrays */
free(b);
free(array);
free(recv_prime);
free(prime);
free(prime2);
free(sub_array);
t2 = MPI_Wtime();
//printf("Computation time for Process %i: %f\n", rank, t2-t1);
MPI_Finalize();
return (EXIT_SUCCESS);
}
The outputs are:
hino#hino-X51L:~/NetBeansProjects/Prime$ mpiexec -np 10 ./Prime 1000
Prime numbers: 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97
101 103 107 109 113 127 131 137 139 149 151 157 163 167 173 179 181 191 193 197 199
0 0 0 0 211 223 227 229 233 239 241 251 257 263 269 271 277 281 283 293 307 311 313
317 331 337 347 349 353 359 367 373 379 383 389 397 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 401 409 419 421 431 433 439 443 449 457 461 463 467 479 487 491 499 503 509 521
523 541 547 557 563 569 571 577 587 593 599 450 451 452 601 607 613 617 619 631 641
643 647 653 659 661 673 677 683 691 701 709 719 727 733 739 743 751 757 761 769 773
787 797 649 650 485 486
hino#hino-X51L:~/NetBeansProjects/Prime$ mpiexec -np 2 ./Prime 1000
Prime numbers: 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97
101 103 107 109 113 127 131 137 139 149 151 157 163 167 173 179 181 191 193 197 199
211 223 227 229 233 239 241 251 257 263 269 271 277 281 283 293 307 311 313 317 331
337 347 349 353 359 367 373 379 383 389 397 401 409 419 421 431 433 439 443 449 457
461 463 467 479 487 491 499 503 509 521 523 541 547 557 563 569 571 577 587 593 599
601 607 613 617 619 631 641 643 647 653 659 661 673 677 683 691 701 709 719 727 733
739 743 751 757 761 769 773 787 797 809 811 821 823 827 829 839 853 857 859 863 877
881 883 887 907 911 919 929 937 941 947 953 967 971 977 983 991 997

Answer 1

A quick scan shows me a few things wrong here:
You need to make sure that your array of numbers divides up evenly. For instance, if you're dividing 100 numbers among 3 processes, you'll have some numbers that don't end up getting distributed correctly by the MPI_SCATTER. This isn't your problem though.
Your MPI_GATHER has an issue on the receiving side. The problem here is that you are sending n_prime_loc numbers from each process, but that value is also different for each process. For instance, rank 0 might find 10 prime numbers so its value of n_prime_loc will be 10, but on rank 1, there might be 25 prime numbers (I know these examples aren't accurate, but stick with me). The problem is that since rank 0 is the root of the MPI_GATHER operation, it's value of n_prime_loc will be used which means that if another process is sending more numbers that rank 0 is expecting, there will be an issue. You need to generate a buffer that's large enough to hold all of the possible results and gather the results appropriately. Alternatively, you could choose to not use an MPI_GATHER since the size of the buffer isn't known a priori. Instead, you could use MPI_SEND and MPI_RECV and you could use MPI_PROBE to know how big to make your buffer. You can make either one work.
Your MPI_BARRIER is useless here. For some reason, when people don't know what to do in MPI, they throw in an MPI_BARRIER. All this function does is make all of the processes wait at this point until all of the other processes reach the same point. You've already accomplished that by calling MPI_GATHER since all of the other processes are involved in that call.
It sounds like you're only running this application on one process. While you can certainly do that, you won't really get much speedup and you won't get anymore speedup than you have cores. If you have a dual core processor and you're trying to run 4 processes, you'll spend a bunch of your time just fighting for the CPU and context switching in and out. You should try not to use more MPI ranks than you have cores.