빼기를위한 적절한 추력 호출

Question

here 다음과 같습니다.

dev_X가 벡터라고 가정합니다.

int * X = (int*) malloc(ThreadsPerBlockX * BlocksPerGridX * sizeof(*X)); 


for (int i = 0; i < ThreadsPerBlockX * BlocksPerGridX; i++) 
    X[ i ] = i; 

// create device vectors 
thrust::device_vector<int> dev_X (ThreadsPerBlockX * BlocksPerGridX); 

//copy to device 
thrust::copy(X , X + theThreadsPerBlockX * theBlocksPerGridX , dev_X.begin()); 

다음

는 뺄셈을하고있다 :

thrust::transform(dev_Kx.begin(), dev_Kx.end(), dev_X.begin() , distX.begin() , thrust::minus<float>()); 

dev_Kx - dev_X. 

나는 그것이 사용되는이 .END하는 .begin에서 이동하기 때문에 (전체 dev_Kx 벡터를 사용하려면()) 및 전체 dev_X 벡터.

위의 코드는 dev_X.begin()을 사용합니다.

dev_X 벡터 전체를 사용한다는 의미입니까? 처음부터 시작 하시겠습니까? 또는 다른 추가 인수를 사용하여 dev_X.end()을 가리켜 야합니까? 예를 들어,

또한 (위의 함수 호출에 난 그냥이 추가 인수를 사용할 수 없기 때문에) :

내가

thrust::transform(dev_Kx, dev_Kx + i , dev_X.begin() ,distX.begin() , thrust::minus<int>()); 

그런 다음 dev_Kx 내가 0에서 갈 것 사용하려면 및 dev_X.begin()? 그것은 같은 길이를 사용할 것인가? (0 ~ i?) 또는 dev_X 길이를 사용합니까?

Answer 1

많은 수의 thrust (및 표준 라이브러리) 함수는 범위를 첫 번째 매개 변수로 사용하고 다른 모든 반복기는 같은 크기의 컨테이너로 백업한다고 가정합니다. 범위는 시작을 나타내는 및 끝 시퀀스를 나타내는 한 쌍의 반복자입니다. 예를 들어

는 : dev_X로

thrust::copy(
    X.begin(), // begin input iterator 
    X.end(),  // end input iterator 
    dev_X.begin() // begin output iterator 
); 

이 복사 X의 전체 내용. dev_X.end()이 필요하지 않은 이유는 무엇입니까? thrust은 프로그래머가 dev_X의 크기를 적절하게 조정하여 이상이 입력 범위에있는 것보다 많은 요소 수인 이상을 포함 할 수 있도록 처리해야하기 때문입니다. 그 보장을 충족시키지 못하면 동작은 정의되지 않습니다.

당신이 할 때 : thrust가 보는 무엇

thrust::transform(
    dev_Kx.begin(), // begin input (1) iterator 
    dev_Kx.end(), // end input (1) iterator 
    dev_X.begin(), // begin input (2) iterator 
    distX.begin(), // output iterator 
    thrust::minus<float>() 
); 

이 dev_Kx.begin()에서 dev_Kx.end()의 입력 범위입니다. 명시 적 크기는 dev_Kx.end() - dev_Kx.begin()입니다. dev_X.end() 및 distX.end()이 필요하지 않은 이유는 무엇입니까? 그들은 의 암시 적 크기가 dev_Kx.end() - dev_Kx.begin()이기 때문에.예를 들어, dev_Kx 10 개 요소가있는 경우, 다음 transform는 :

수행

• 은 (적어도 10 요소를 보유하고 있어야합니다) dev_X의 dev_Kx
• 사용 10 요소의 10 개 요소를 사용 빼기를 수행하고 distX에 10 개의 결과를 저장하면 이상을 적어도 개의 요소 10 개까지 포함 할 수 있어야합니다.

어쩌면 구현을 보면 의심의 여지가 없습니다. 다음은 몇 가지 의사 코드입니다.

void transform(InputIterator input1_begin, InputIterator input1_end, 
       InputIterator input2_begin, OutputIterator output, 
       BinaryFunction op) { 
    while (input1_begin != input1_end) { 
     *output++ = op(*input1_begin++, *input2_begin++); 
    } 
} 

하나의 엔드 반복자 만 필요합니다. 관련이없는 노트에

---

, 다음

int * X = (int*) malloc(ThreadsPerBlockX * BlocksPerGridX * sizeof(*X)); 
for (int i = 0; i < ThreadsPerBlockX * BlocksPerGridX; i++) 
    X[ i ] = i; 

더 관용적으로 다시 작성할 수 있습니다, 덜 오류가 발생하기 쉬운 C++ :

std::vector<int> X(ThreadsPerBlockX * BlocksPerGridX); 
std::iota(X.begin(), X.end(), 0);