Как накапливать векторы в OpenCL?

Question

У меня есть набор операций, выполняющихся в цикле.

for(int i = 0; i < row; i++) 
{ 
    sum += arr1[0] - arr2[0] 
    sum += arr1[0] - arr2[0] 
    sum += arr1[0] - arr2[0] 
    sum += arr1[0] - arr2[0] 

    arr1 += offset1; 
    arr2 += offset2; 
} 

Теперь я пытаюсь векторизовать операции, как этот

for(int i = 0; i < row; i++) 
{ 
    convert_int4(vload4(0, arr1) - vload4(0, arr2)); 

    arr1 += offset1; 
    arr2 += offset2; 
} 

Но как я аккумулировать результирующий вектор в скаляр sum без использования цикла?

Я использую OpenCL 2.0.

Answer 1

Я нашел решение, которое, кажется, является самым близким путем, я мог бы ожидать решения моей проблемы.

uint sum = 0; 
uint4 S; 

for(int i = 0; i < row; i++) 
{ 
    S += convert_uint4(vload4(0, arr1) - vload4(0, arr2)); 

    arr1 += offset1; 
    arr2 += offset2; 
} 

S.s01 = S.s01 + S.s23; 
sum = S.s0 + S.s1; 

OpenCL 2.0 обеспечивает такую ​​функциональность с векторами, где элементы векторов последовательно могут быть заменены на операции сложения, как показано выше. Это может поддерживать до вектора размера 16. Большие операции можно разделить на факторы меньших операций. Например, для добавления абсолютных значений разностей между двумя векторами размером 32, мы можем сделать следующее:

uint sum = 0; 
uint16 S0, S1; 

for(int i = 0; i < row; i++) 
{ 
    S0 += convert_uint16(abs(vload16(0, arr1) - vload16(0, arr2))); 
    S1 += convert_uint16(abs(vload16(1, arr1) - vload16(1, arr2))); 

    arr1 += offset1; 
    arr2 += offset2; 
} 

S0 = S0 + S1; 
S0.s= S0.sS0.s89abcdef; 
S0.s= S0.sS0.s4567; 
S0.s01 = S0.s01 + S0.s23; 
sum = S0.s0 + S0.s1; 

Answer 2

Операция называется «сокращение», и, похоже, есть информация об этом here.

В функции OpenCL, как представляется, реализованы, один из которых work_group_reduce(), который может вам помочь: link.

И презентация, включая код: link.

Answer 3

Для float2, float4 и аналогичной, самой простой версией может быть точечный продукт. (Преобразование из междунар плавать может быть дорогим)

float4 v1=(float4)(1,2,3,4); 
float4 v2=(float4)(5,6,7,8); 

float sum=dot(v1-v2,(float4)(1,1,1,1)); 

это равно

(v1.x-v2.x)*1 + (v1.y-v2.y)*1+(v1.z-v2.z)*1+(v1.w-v2.w)*1 

и если есть аппаратная поддержка для нее, оставив ее на милость компилятора должно быть в порядке. Для больших векторов и особенно массивов ответ Дж. Б.Бонариуса - это путь. Как я знаю, только у процессора есть такие операции с вертикальной суммой, поскольку у GPU это не так, но ради мобильности, dot product и work_group_reduce - это самые простые способы достижения удобочитаемости и даже производительности.

У продукта Dot есть дополнительные умножения, поэтому это может быть не всегда хорошо.