MPI : 프로세스 수에 따라 프로그램이 작동합니다.

Question

MPI 라이브러리 (MPICH-2)를 사용하는 프로그램을 작성했습니다. 프로그램은 2와 N 사이의 모든 소수를 찾습니다. 두 프로세스 만 사용하면 잘 작동하지만 프로세스> 2의 수를 지정하면 작동하지 않습니다. 내 목표는 MPI를 사용하는 프로그램과 그렇지 않은 프로그램 사이의 퍼포먼스를 비교하는 것이므로 매우 비효율적입니다. 듀얼 코어 머신이 있고 우분투 13.10에서 NetBeans 7.4를 사용하고 있습니다. 문제는 내 컴퓨터의 코어 수에 따라 좌우됩니까? 나는 스케줄링이 OS에 달려 있다는 것을 알았지 만, 어떻게 생각해야할지 모르겠다! 어쩌면 MPI_Barrier를 넣을 수 있을까요? 나는 2 개 이상의 procs로 프로그램을 호출 할 때 이상한 0을 볼 수 있으므로 코드와 출력을 아래에 삽입한다.

#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); 
    } 

출력은 다음과 같습니다

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

빠른 스캔이 잘못 여기에 나에게 몇 가지를 보여줍니다

1. 당신은 숫자의 배열이 균일하게 분산시키고 있는지 확인해야합니다. 예를 들어 3 개의 프로세스에서 100 개의 숫자를 나누는 경우 MPI_SCATTER에 의해 올바르게 분배되지 않는 숫자가 있습니다. 그러나 이것은 당신의 문제가 아닙니다.

2. MPI_GATHER에는 수신 측에서 문제가 있습니다. 여기서 문제는 각 프로세스에서 n_prime_loc 개의 숫자를 보내고 있지만 그 값은 각 프로세스마다 다릅니다. 예를 들어 순위 0은 10 개의 소수를 찾을 수 있으므로 n_prime_loc의 값은 10이지만 순위 1에 25 개의 소수가있을 수 있습니다 (이 예는 정확하지 않지만 나와 관련이 있습니다). 문제는 랭크 0이 MPI_GATHER 연산의 루트이기 때문에 n_prime_loc 값이 사용됩니다. 즉, 다른 프로세스가 0 랭크가 예상되는 숫자를 더 보내면 문제가 발생한다는 것입니다. 가능한 모든 결과를 보유하고 결과를 적절히 수집 할만큼 충분히 큰 버퍼를 생성해야합니다. 또는 버퍼의 크기가 선험적으로 알려지지 않았으므로 MPI_GATHER을 사용하지 않도록 선택할 수 있습니다. 대신 MPI_SEND과 MPI_RECV을 사용하고 MPI_PROBE을 사용하면 버퍼를 얼마나 크게 만들 수 있는지 알 수 있습니다. 둘 중 하나를 만들 수 있습니다.

3. MPI_BARRIER은 쓸모가 없습니다. 어떤 이유로 MPI에서 사람들이 무엇을 해야할지 모를 때 그들은 MPI_BARRIER을 던집니다. 이 모든 기능은 모든 다른 프로세스가 같은 지점에 도달 할 때까지 모든 프로세스가이 시점에서 대기하도록합니다. 다른 모든 프로세스가 해당 호출에 관련되어 있기 때문에 이미 MPI_GATHER을 호출하여이 작업을 완료했습니다.

4. 하나의 프로세스에서만이 응용 프로그램을 실행하는 것 같습니다. 당신이 확실히 그것을 할 수있는 동안, 당신은 정말로 많은 스피드 업을 얻지 못할 것이고 당신은 코어를 가진 것보다 스피드 업을 더 이상 얻지 못할 것입니다. 듀얼 코어 프로세서가 있고 4 개의 프로세스를 실행하려는 경우 CPU 및 컨텍스트 전환을 위해 싸우는 데 많은 시간을 할애해야합니다. 코어가있는 것보다 더 많은 MPI 등급을 사용하지 않도록 노력해야합니다.