공유메모리를 사용한 병렬처리 가우스소거법 프로그램

게시물 수정 , 삭제는 로그인 필요

안녕하세요 공유메모리를 이용한 병렬처리로 가우스소거법을 구현하고 있습니다.

아래는 코드입니다.

[code]

#include <stdio.h>

#include <unistd.h>

#include <stdlib.h>

#include <sys/stat.h>

#include <sys/mman.h>

#include <sys/wait.h>

#include <fcntl.h>

#include <pthread.h>

#include "wrapper.h"

#define sfname "sha"

double * A, * B, * X;

pthread_barrier_t *barrier;

void argCheck(int argc, char *argv[])

{

  /*

    Fill the function with codes such that

    if the number of arguments is not 4

       exit with code 1 and the following error message

           Usage: hw1 <mat> <invec> <outvec>

   */

    if (argc != 5)

    {

        fprintf(stderr, "Usage: %s <mat> <invec> <outvec> <np>\n", argv[0]);

        exit(1);

    }

}

int sizeCheck(int argc, char *argv[])

{

  /*

     Fill the function with codes such that 

     if the number of elements in file argv[1] is the square of the argv[2]

        return the number of elements in file argv[2]

     else

        exit with value 1

  */

    struct stat finfoA, finfoB;

    int noeleA, noeleB;

    Stat(argv[1], &finfoA);

    Stat(argv[2], &finfoB);

    noeleA = finfoA.st_size / sizeof(double);

    noeleB = finfoB.st_size / sizeof(double);

    if (noeleA != noeleB * noeleB)

    {

        fprintf(stderr, "Error: no. elements(%d) of %s is not square of that(%d) of %s.\n", noeleA, argv[1], noeleB, argv[2]);

        exit(1);

    }

    return noeleB;

}

void getData(int size, int argc, char *argv[])

{

    int afd, bfd;

    A = (double*)malloc(sizeof(double) * size * size);

    B = (double*)malloc(sizeof(double) * size); //어떤 사이즈에도 대응하기 위해 동적할당

    X = (double*)malloc(sizeof(double) * size); //병렬처리를 수행하게되면 필요없을 수도 있음

    afd = Open(argv[1], O_RDONLY);

    bfd = Open(argv[2], O_RDONLY);

    Read(afd, A, sizeof(double) * size * size);

    Read(bfd, B, sizeof(double) * size);

    close(afd);

    close(bfd);

}

void GaussianElimination(int n, int start, int end)

{

    int l, i, j;

    for (l = 0; l < n - 1; l++) {

        for (i = start; i < end; i++)

        {

            double ratio = A[i * n + l] / A[l * n + l];

            for (j = l; j < n; j++)

            {

                A[i * n + j] = A[i * n + j] - ratio * A[l * n + j];

                //A[i * n + j] = A[i * n + j] - (A[i * n + l] / A[l * n + l]) * A[l * n + j]; //1차원 배열로 표현

            }//n : 한 행의 요소 수, i : 행 번호, j : 열 번호

            B[i] = B[i] - ratio * B[l];

            //B[i] = B[i] - (A[i * n + l] / A[l * n + l]) * B[l];

        }

        pthread_barrier_wait(barrier);

    }

}

void BackSubstitution(int n, int start, int end)

{

    int i, j;

    for (i = n - 1; i >= 0; i--)

    {

        if (i >= start && i < end)

        {

            X[i] = B[i] / A[i * n + i];

        }

        pthread_barrier_wait(barrier);

        for (j = start; j < end && j < i; j++)

        {

            B[j] -= X[i] * A[j * n + i];

            A[j * n + i] = 0;

        }

        pthread_barrier_wait(barrier);

    }

}

int main(int argc, char *argv[])

{

    pthread_barrierattr_t attr; //특성변수

    int xfd;

    int size;

    int np;

    pid_t pid;

    argCheck(argc, argv);

    size = sizeCheck(argc, argv);

    np = atoi(argv[4]);

    getData(size, argc, argv);

    int smsize = (size * size + size + size + sizeof(pthread_barrier_t)) * sizeof(double);

    int smfd = Shm_open(sfname, O_CREAT | O_RDWR, 0666);

    Ftruncate(smfd, smsize);

    double* shm_ptr = (double*)Mmap(0, smsize, PROT_READ | PROT_WRITE, MAP_SHARED, smfd, 0);

    A = shm_ptr;

    B = shm_ptr + size * size;

    X = shm_ptr + size * size + size;

    barrier = (pthread_barrier_t*)(X + size);

    Pthread_barrierattr_init(&attr);

    Pthread_barrierattr_setpshared(&attr, PTHREAD_PROCESS_SHARED);

    Pthread_barrier_init(barrier, &attr, np);

    for (int i = 0; i < np; i++)

    {

        pid = fork();

        if (pid == 0) //자식 프로세스

        {

            int start = i * (size / np);

            int end = ((i + 1) * size) / np - 1;

            if (i == np - 1)

            {

                end = size;

            }

            GaussianElimination(size, start, end);

            pthread_barrier_wait(barrier);

            BackSubstitution(size, start, end);

            exit(0);

        }

    }

    for (int i = 0; i < np; i++)

    {

        wait(NULL);

    }

    xfd = Creat(argv[3], 0644);

    Write(xfd, X, sizeof(double) * size);

    close(xfd);

    pthread_barrier_destroy(barrier);

    munmap(shm_ptr, smsize);

    shm_unlink(sfname);    

    //free(A);

    //free(B);

    //free(X);

    return 0;

}

[/code]

대문자로 시작하는 함수들은 wrapper함수로 구현해놓은 것들입니다.

여튼 이렇게 해서 컴파일도 성공적으로 되고 

./'프로그램이름' A2.dat B2.dat X2.dat '프로세스 수'

이런식으로 실행합니다. A는 행렬 B는 벡터입니다. 그래서 AX = B를 계산해서 X에 벡터가 구해집니다.

그리고 ./showdata X2.dat를 해서 내용을 확인할 수 있는데 -nan -nan이라고 나옵니다... 숫자가 아니라는 의미인 것은 알고 있는데 딱히 0으로 나눈다거나 하는 경우가 안생기는 것 같은데 어디가 문제인지 모르겠습니다 ㅜ start와 end에서 반복문을 나누는 곳이 잘못된걸까요? 답변부탁드립니다.