Function morph3d

src/backend/opencl/kernel/morph.hpp:88–145

template<typename T>
void morph3d(Param out, const Param in, const Param mask, bool isDilation) {
    using cl::Buffer;
    using cl::EnqueueArgs;
    using cl::NDRange;
    using std::make_unique;
    using std::string;
    using std::vector;

    constexpr int CUBE_X = 8;
    constexpr int CUBE_Y = 8;
    constexpr int CUBE_Z = 4;

    ToNumStr<T> toNumStr;
    const T DefaultVal = isDilation ? common::Binary<T, af_max_t>::init()
                                    : common::Binary<T, af_min_t>::init();
    const int SeLength = mask.info.dims[0];

    std::vector<TemplateArg> targs = {
        TemplateTypename<T>(),
        TemplateArg(isDilation),
        TemplateArg(SeLength),
    };
    vector<string> options = {
        DefineKeyValue(T, dtype_traits<T>::getName()),
        DefineValue(isDilation),
        DefineValue(SeLength),
        DefineKeyValue(init, toNumStr(DefaultVal)),
    };
    options.emplace_back(getTypeBuildDefinition<T>());

    auto morphOp =
        common::getKernel("morph3d", {{morph_cl_src}}, targs, options);

    NDRange local(CUBE_X, CUBE_Y, CUBE_Z);

    int blk_x = divup(in.info.dims[0], CUBE_X);
    int blk_y = divup(in.info.dims[1], CUBE_Y);
    int blk_z = divup(in.info.dims[2], CUBE_Z);

    NDRange global(blk_x * CUBE_X * in.info.dims[3], blk_y * CUBE_Y,
                   blk_z * CUBE_Z);

    cl_int seBytes = sizeof(T) * SeLength * SeLength * SeLength;
    auto mBuff =
        make_unique<cl::Buffer>(getContext(), CL_MEM_READ_ONLY, seBytes);
    morphOp.copyToReadOnly(mBuff.get(), mask.data, seBytes);

    // calculate shared memory size
    const int padding =
        (SeLength % 2 == 0 ? (SeLength - 1) : (2 * (SeLength / 2)));
    const int locLen  = CUBE_X + padding + 1;
    const int locArea = locLen * (CUBE_Y + padding);
    const int locSize = locArea * (CUBE_Z + padding);

    morphOp(EnqueueArgs(getQueue(), global, local), *out.data, out.info,
            *in.data, in.info, *mBuff, cl::Local(locSize * sizeof(T)), blk_x);
    CL_DEBUG_FINISH(getQueue());
}