Function morph

src/backend/opencl/kernel/morph.hpp:29–85

template<typename T>
void morph(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 THREADS_X = 16;
    constexpr int THREADS_Y = 16;

    ToNumStr<T> toNumStr;
    const T DefaultVal = isDilation ? common::Binary<T, af_max_t>::init()
                                    : common::Binary<T, af_min_t>::init();
    const int windLen  = mask.info.dims[0];
    const int SeLength = (windLen <= 10 ? windLen : 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("morph", {{morph_cl_src}}, targs, options);

    NDRange local(THREADS_X, THREADS_Y);

    int blk_x = divup(in.info.dims[0], THREADS_X);
    int blk_y = divup(in.info.dims[1], THREADS_Y);

    NDRange global(blk_x * THREADS_X * in.info.dims[2],
                   blk_y * THREADS_Y * in.info.dims[3]);

    // copy mask/filter to read-only memory
    auto seBytes = windLen * windLen * sizeof(T);
    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 =
        (windLen % 2 == 0 ? (windLen - 1) : (2 * (windLen / 2)));
    const int locLen  = THREADS_X + padding + 1;
    const int locSize = locLen * (THREADS_Y + padding);

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