최소 반복 횟수를 반복 한 루프의 값만 저장

Question

회 반복 횟수와 L 메모리 위치가 있습니다. 각 반복은 0 ~ (L-1) 개의 메모리 위치 중 하나에 기록합니다.

전역 메모리에 반복 번호에 따라 데이터를 저장하려고합니다. 반복 K와 K-1이 모두 같은 위치에 기록한다고 가정하십시오. 전역 메모리의 최종 결과는 K가되어야합니다. 스레드 K-1은 스레드 K의 결과를 무시해서는 안됩니다.

아래 해결 방법을 시도했습니다. 각 메모리 위치에 대해 최대 반복을 사용하여 배열을 만들고 -1로 초기화하십시오. 그런 다음 반복 횟수가 현재 값보다 많은지 확인합니다. 그렇다면 값을 저장하고 최대 반복을 업데이트합니다.

이것은 현재 코드이지만 큰 반복에서는 올바른 결과를 제공하지 않습니다.

int main() 
{ 
    int A[10]={10,20,30,40,50,60,70,80,90,100}; 
    int maxIndex[10]={-1,-1,-1,-1,-1,-1,-1,-1,-1,-1}; 
    int lock[10]={0,0,0,0,0,0,0,0,0,0}; 
    int index[8192]; 
    srand(0); 
    for(int ii=0;ii<8192;ii++) 
    { 
      index[ii]=rand()%10; 
    } 
    int *index1; 
    int *A1,*maxIndex1; 
    int *lock1; 
    cudaMalloc((void**)&lock1,sizeof(int)*10); 
    cudaMalloc((void**)&A1,sizeof(int)*10); 
    cudaMalloc((void**)&index1,sizeof(int)*8192); 
    cudaMalloc((void**)&maxIndex1,sizeof(int)*10); 
    cudaMemcpy(A1,&A,sizeof(int)*10,cudaMemcpyHostToDevice); 
    cudaMemcpy(lock1,&lock,sizeof(int)*10,cudaMemcpyHostToDevice); 
    cudaMemcpy(maxIndex1,&maxIndex,sizeof(int)*10,cudaMemcpyHostToDevice); 
    cudaMemcpy(index1,&index,sizeof(int)*8192,cudaMemcpyHostToDevice); 
    fun<<<16,512>>>(A1,maxIndex1,index1,lock1); 
    cudaMemcpy(&A,A1,sizeof(int)*10,cudaMemcpyDeviceToHost); 
    cudaMemcpy(&maxIndex,maxIndex1,sizeof(int)*10,cudaMemcpyDeviceToHost); 
    printf("\nindex \n"); 
    for(int i=0;i<8192;i++) 
    { 
      printf("%d\n",index[i]); 
    } 

    for(int i=0;i<10;i++) 
    { 
      printf(" %d max is %d\n",A[i],maxIndex[i]); 
    } 
}                         

Answer 1

#include<stdio.h> 
#include"cuda.h" 
__global__ void fun(int *A,int *maxIndex,int *index1,int *lock) 
{ 
        int threadid=blockIdx.x*blockDim.x+threadIdx.x; 
        int iteration_no=threadid; 
        int index=index1[threadid]; 
        int exitFromLoop=1; 
        while(exitFromLoop==1) 
        { 
          int flag=atomicCAS(&lock[index],0,1); 
        if(flag==0) 


          { 
            if(maxIndex[index]<iteration_no) 
            {  
              A[index]=89; 
              maxIndex[index]=iteration_no; 
              __threadfence(); 
            } 
            else 
            { 
            } 
            //__threadfence(); 
            lock[index]=0; 
            exitFromLoop=0; 
          } 
          else 
          { 

          } 
        } 

은} 나는 이것이 당신이 계신 것 같아요. A 배열의 각 요소

는 A 배열의 요소를 갱신 마지막 스레드를 포함하는 iteration_no maxIndex 어레이 내의 대응하는 요소가있다. 현재 스레드의 값이 iteration_no보다 크면 maxIndex은 현재 스레드의 iteration_no으로 업데이트되고 스레드는 A의 요소를 업데이트합니다. 현재의 thread가 낮은 iteration_no이있는 경우

의 A 요소는 업데이트되지 않고 maxIndex의 iteration_no는 업데이트되지 않습니다.

#include<stdio.h> 
#include"cuda.h" 

__global__ void fun(int *A,int *maxIndex,int *index) 
{ 
    int iteration_no=blockIdx.x*blockDim.x+threadIdx.x; 
    int i=index[iteration_no]; 
    if (atomicMax(maxIndex + i, iteration_no) < iteration_no) { 
    A[i] = 89; 
    } 
} 

int main() 
{ 
    int A[10] = {10,20,30,40,50,60,70,80,90,100}; 
    int maxIndex[10]={-1}; 
    int index[8192]; 
    srand(0); 
    for(int ii=0;ii<8192;ii++) 
    { 
    index[ii]=rand()%10; 
    } 
    int *index_d; 
    int *A_d,*maxIndex_d; 
    cudaMalloc((void**)&A_d,sizeof(int)*10); 
    cudaMalloc((void**)&index_d,sizeof(int)*8192); 
    cudaMalloc((void**)&maxIndex_d,sizeof(int)*10); 
    cudaMemcpy(A_d,&A,sizeof(int)*10,cudaMemcpyHostToDevice); 
    cudaMemcpy(maxIndex_d,&maxIndex,sizeof(int)*10,cudaMemcpyHostToDevice); 
    cudaMemcpy(index_d,&index,sizeof(int)*8192,cudaMemcpyHostToDevice); 

    fun<<<16,512>>>(A_d,maxIndex_d,index_d); 

    cudaMemcpy(&A,A_d,sizeof(int)*10,cudaMemcpyDeviceToHost); 
    cudaMemcpy(&maxIndex,maxIndex_d,sizeof(int)*10,cudaMemcpyDeviceToHost); 
    printf("\nindex \n"); 

    for(int i=0;i<8192;i++) { 
    printf("%d\n",index[i]); 
    } 

    for(int i=0;i<10;i++) { 
    printf(" %d max is %d\n",A[i],maxIndex[i]); 
    } 
}