홈>2020-02-01 00:34

parallel processing - 어레이와의 CUDA 병렬화 작업

CUDA가 처음인데 CUDA에 대한 NVIDIA 교사를 읽었으며 도움이 필요합니다. 다음 코드가 있습니다 :

//some includes
#define NUM_OF_ACCOMS 3360
#define SIZE_RING 16
#define NUM_OF_BIGRAMMS 256
//...some code...
    for (i = 1; i <= SIZE_RING; i++) {
        for (j = 1; j <= SIZE_RING; j++) {
            if (j == i) continue;
            for (k = 1; k <= SIZE_RING; k++) {
                if (k == j || k == i) continue;
                accoms_theta[indOfAccoms][0] = i - 1; accoms_theta[indOfAccoms][1] = j - 1; accoms_theta[indOfAccoms][2] = k - 1;
                accoms_thetaFix[indOfAccoms][0] = i - 1; accoms_thetaFix[indOfAccoms][1] = j - 1; accoms_thetaFix[indOfAccoms][2] = k - 1;
                results[indOfAccoms][0] = results[indOfAccoms][1] = results[indOfAccoms][2] = 0;
                indOfAccoms++;
            }
        }
    }   
    for (i = 0; i < SIZE_RING; i++)
        for (j = 0; j < SIZE_RING; j++) {
            bigramms[indOfBigramms][0] = i; bigramms[indOfBigramms][1] = j;
            indOfBigramms++;
        }
        for (i = 0; i < NUM_OF_ACCOMS; i++) {
            thetaArr[0] = accoms_theta[i][0]; thetaArr[1] = accoms_theta[i][1]; thetaArr[2] = accoms_theta[i][2];
            d0 = thetaArr[2] - thetaArr[1]; d1 = thetaArr[2] - thetaArr[0];
            if (d0 < 0)
                d0 += SIZE_RING;
            if (d1 < 0)
                d1 += SIZE_RING;
            for (j = 0; j < NUM_OF_ACCOMS; j++) {
                theta_fixArr[0] = accoms_thetaFix[j][0]; theta_fixArr[1] = accoms_thetaFix[j][1]; theta_fixArr[2] = accoms_thetaFix[j][2];
                d0_fix = theta_fixArr[2] - theta_fixArr[1]; d1_fix = theta_fixArr[2] - theta_fixArr[0];
                count = 0;
                if (d0_fix < 0)
                    d0_fix += SIZE_RING;
                if (d1_fix < 0)
                    d1_fix += SIZE_RING;
                for (k = 0; k < NUM_OF_BIGRAMMS; k++) {
                    diff0 = subst[(d0 + bigramms[k][0]) % SIZE_RING] - subst[bigramms[k][0]];
                    diff1 = subst[(d1 + bigramms[k][1]) % SIZE_RING] - subst[bigramms[k][1]];
                    if (diff0 < 0)
                        diff0 += SIZE_RING;
                    if (diff1 < 0)
                        diff1 += SIZE_RING;
                    if (diff0 == d0_fix && diff1 == d1_fix)
                        count++;
                }
                if (max < count) {
                    max = count;
                    results[indResults][0] = max; results[indResults][1] = i; results[indResults][2] = j;
                    count = 0;
                    indResults++;
                }
            }
        }

보시다시피, i 에는 두 가지 주요주기가 있습니다 그리고 j 변수. accoms_theta 의 foreach 배열이 필요합니다. accoms_thetaFix 에서 각 배열의 상태를 확인하십시오. . (와이즈 와이즈) subst 입니다 SIZE_RING 요소가 포함 된 배열). 글쎄 당신은 int 에 대한 필요 모든 배열을 확인하는 작업. CUDA를 처음 사용하므로 알고리즘을 병렬화하는 데 도움이 필요합니다.

내 장치에 대한 정보가 있습니다

2^30

GeForce GT730M
Compute Capability 3.5
Global Memory 2 GB
Shared Memory Per Block 48 KB
Max Threads Per Block 1024
Number of multiprocessors 2
Max Threads Dim 1024 : 1024 : 64
Max Grid Dim 2*(10 ^ 9) : 65535 : 65535

arraysparallel-processingcuda

답변 # 1
내가 계산하려고하는 것에 대한 구체적인 내용은 다루지 않겠지 만, 내가 할 수있는 일에 대해서는 제안 할 것이다.
CUDA (또는 OpenCL 또는 OpenMP에서도)의 직렬 알고리즘을 병렬화하는 간단한 방법은 "루프 병렬화"입니다. CUDA의 맥락에서 단일 스레드 대신 일부 인덱스 값을 반복하는 것을 의미합니다. i 의 다른 값에 대해 다른 GPU 스레드가 작동합니다. (또는- i 의 여러 값마다 하나의 스레드 ).

이것은 중첩 루프로 수행 할 수 있습니다 (예 : 두 지수 i 그리고 i 커널 발사 그리드의 2 차원에 해당합니다.
그러나 '순진하게'이 작업은 당혹 스러울 정도로 평행 한 문제에 대해서만 가능합니다. 예를 들어 각 스레드에서 계산/기록 할 데이터간에 종속성이없는 경우 (예 : j 의 각 조합에 대해) 그리고 i ). 또한 다른 j 에 대해읽은데이터가 그리고 i 동일한 데이터를 반복해서 읽지 못하게하여 성능이 저하되지 않도록 추가로주의해야합니다.

이 접근법을 시도하십시오. 실패하거나 적용 할 수 없다는 결론에 도달하면 다른 질문을하십시오.이 질문에는이 질문에 대해 제공하지 않은 최소의 완전하고 검증 가능한 예가 필요합니다.
j

Python2.net

parallel processing - 어레이와의 CUDA 병렬화 작업

관련 자료