Question

我正在使用以下函数来获取OpenCL应用程序的最佳本地和工作组大小。

//maxWGSize == CL_KERNEL_WORK_GROUP_SIZE
//wgMultiple == CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE
//compUnits == CL_DEVICE_MAX_COMPUTE_UNITS
//rems == max required work items

void MyOpenCL::getBestWGSize(cl_uint maxWGSize, cl_uint wgMultiple, cl_uint compUnits, cl_uint rems, size_t *gsize, size_t *lsize) const
{
    cl_uint cu = 1;
    if(wgMultiple <= rems)
    {
        bool flag = true;
        while(flag)
        {
            if(cu < compUnits)
            {
                cu++;
                if((wgMultiple * cu) > rems)
                {
                    cu--;
                    flag = false;
                    break;
                }
            }
            else if(wgMultiple < maxWGSize)
            {
                wgMultiple *= 2;
                if((wgMultiple * cu) > rems)
                {
                    wgMultiple /= 2;
                    flag = false;
                    break;
                }
            }
            else
            {
                cu++;
                if(((wgMultiple * cu) > rems) || (cu > 2 * compUnits))
                {
                    cu--;
                    flag = false;
                    break;
                }
            }
        }
    }
    else
    {
        bool flag = true;
        wgMultiple = 2;
        while(flag)
        {
            if(cu < compUnits)
            {
                cu++;
                if((wgMultiple * cu) > rems)
                {
                    cu--;
                    flag = false;
                    break;
                }
            }
            else
            {
                wgMultiple *= 2;
                if((wgMultiple * cu) > rems)
                {
                    wgMultiple /= 2;
                    flag = false;
                    break;
                }
                else
                {
                    cl_int temp = rems - (wgMultiple * cu);
                    if((temp == 0) || (temp == 1))
                    {
                       flag = false;
                       break;
                    }
                }
            }
        }
    }

    *gsize = wgMultiple * cu;
    *lsize = wgMultiple;
    if(rems < *gsize)
    {
        *gsize = rems;
        *lsize = rems;
    }
    if(cu != compUnits)
    {
        while((cu * 2) <= compUnits)
        {
            cu *= 2;
            if(*lsize % 2 == 0)
                *lsize /= 2;
        }
    }
}

算法是：

如果本地尺寸==，则确定需要多少工作组 CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE
如果还需要更多工作单位，则将本地大小乘以2直到它到达CL_KERNEL_WORK_GROUP_SIZE

有关改进算法的建议吗？

我得到的一些结果：

for GPU if max required work items == 99
maxWGSize    256 
wgMultiple   64 
compUnits    6 
rems     99 
*gsize   64 
*lsize   16 


for GPU if max required work items == 35
maxWGSize    256 
wgMultiple   4 
compUnits    6 
rems     35 
*gsize   24 
*lsize   4 

for GPU if max required work items == 57
maxWGSize    256 
wgMultiple   8 
compUnits    6 
rems     57 
*gsize   48 
*lsize   8 

for CPU if max required work items == 99
maxWGSize    1024 
wgMultiple   16 
compUnits    4 
rems     99 
*gsize   64 
*lsize   16 

for CPU if max required work items == 35
maxWGSize    1024 
wgMultiple   8 
compUnits    4 
rems     35 
*gsize   32 
*lsize   8

for CPU if max required work items == 57
maxWGSize    1024 
wgMultiple   8 
compUnits    4 
rems     57 
*gsize   32 
*lsize   8

Answer 1

不可否认，我并不理解（并且很难尝试理解）你想要在那里计算什么，因为它看起来过于复杂：确定最佳工作组大小应该几乎与计算单元的数量，并不需要以如此复杂的方式计算它。

正如我在original question的答案中所述（并由DarkZeros in his comment确认：只要你不使用本地记忆等，你通常可以通过null作为本地工作规模，OpenCL将适当选择它。

但是，可能会有一些警告。根据全局工作大小，底层OpenCL实现可能无法使用“良好”的本地工作组大小。例如：当全局工作大小为素数（大于最大本地工作大小）时，可能会强制OpenCL实现使用本地工作大小1 ... < / p>

这通常可以通过填充来规避数据，使其成为更合适的本地工作大小的倍数。首先，这意味着您必须修改内核，以便它遵守工作规模的限制。在另一个问题的内核中，您必须为该大小添加另一个参数，并相应地检查：

__kernel void reduceURatios(
    __global myreal *coef, 
    __global myreal *row, 
    myreal ratio,
    int sizeOfArrays)  // Add this parameter
{
    size_t gid = get_global_id(0);
    if (gid >= sizeOfArrays)
    {
        return; // Don't access invalid elements
    }

    myreal pCoef = coef[gid];
    myreal pRow = row[gid];

    pCoef = pCoef - (pRow * ratio);
    coef[gid] = pCoef;
}

然后您可以更自由地选择全球工作规模。当前问题的代码涉及CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE，但这对于标准GPU上的这种简单内核几乎不相关。与此相反，CL_DEVICE_MAX_WORK_GROUP_SIZE对于本地工作大小来说是一个不错的选择（只要内核本身没有其他限制，例如注册压力 - 但这也绝对不是这里的情况））。

因此，您可以使用CL_DEVICE_MAX_WORK_GROUP_SIZE作为计算全球工作规模的基础：

// As queried with CL_DEVICE_MAX_WORK_GROUP_SIZE
int maxWorkGroupSize = ...
int numWorkGroups = (n-1) / maxWorkGroupSize + 1;
int globalSizePadded = numWorkGroups * maxWorkGroupSize;

然后用这个（填充的）全局工作大小调用你的内核。您在内核中添加的if语句将确保线程不会访问无效的内存区域。当您使用此填充的全局大小启动内核并将本地大小设置为null时，它应自动选择CL_DEVICE_MAX_WORK_GROUP_SIZE作为本地大小（当然，您也可以手动指定）。

这个可能会更快地从原始问题中进行计算，但它仍然不会比CPU版本更快......

在OpenCL中获得最佳的本地/全球工作组大小？

1 个答案: