Function DISPATCH_FUNC

dnn/src/arm_common/pooling/algo.cpp:308–360

        DISPATCH_FUNC(int8_t, int8, 1);
    } else if (param.src_type.enumv() == DTypeEnum::Quantized8Asymm) {
        DISPATCH_FUNC(uint8_t, uint8, 2);
#if __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
    } else if (param.src_type == dtype::Float16{}) {
        DISPATCH_FUNC(__fp16, float16, 3);
#endif
    }
#undef DISPATCH_FUNC
}
bool PoolingImpl::AlgoFilter3AverageStride2::usable(
        const PoolingKernSizeParam& param) const {
    bool avaible = (param.src_type.category() == DTypeCategory::FLOAT) &&
                   param.format == Param::Format::NCHW && param.mode == Mode::AVERAGE &&
                   param.filter[0] == 3 && param.filter[1] == 3 &&
                   param.stride[0] == 2 && param.stride[1] == 2 && param.isz[0] >= 2 &&
                   param.isz[1] >= 2;
    return avaible;
}

void PoolingImpl::AlgoFilter3AverageStride2::exec(const PoolingKernParam& param) const {
    auto IH = param.isz[0], IW = param.isz[1];
    auto OH = param.osz[0], OW = param.osz[1];
    auto N = param.n, C = param.ic;
    auto PH = param.padding[0];
    auto PW = param.padding[1];

    auto src_ptr = param.src_ptr;
    auto dst_ptr = param.dst_ptr;

#define DISPATCH_FUNC(type, MEGDNN_SIMD_WIDTH, midout_type_id)                         \
    MIDOUT_BEGIN(megdnn_arm_common_pooling, midout_iv(3), midout_iv(midout_type_id)) { \
        WorkspaceBundle wbundle = get_bundle(param);                                   \
        auto run = [C, IH, IW, OH, OW, PH, PW, src_ptr, dst_ptr, wbundle = wbundle,    \
                    workspace_ptr = param.workspace<dt_byte>()](                       \
                           size_t index, size_t thread_id) {                           \
            auto ws = wbundle;                                                         \
            ws.set(workspace_ptr + ws.total_size_in_bytes() * thread_id);              \
            size_t n = index / C;                                                      \
            size_t c = index % C;                                                      \
            do_average_pooling_3x3_s2x2_NEON(                                          \
                    static_cast<const type*>(src_ptr.get_ptr()) + n * C * IH * IW +    \
                            c * IH * IW,                                               \
                    static_cast<type*>(dst_ptr.get_ptr()) + n * C * OH * OW +          \
                            c * OH * OW,                                               \
                    IH, IW, OH, OW, PH, PW, ws, MEGDNN_SIMD_WIDTH);                    \
        };                                                                             \
        MEGDNN_DISPATCH_MULTI_THREAD_CPU_KERN(                                         \
                static_cast<::megdnn::naive::HandleImpl*>(param.handle), N* C, run);   \
    }                                                                                  \
    MIDOUT_END();
    if (param.src_type == dtype::Float32{}) {
        DISPATCH_FUNC(dt_float32, 4, 0);
#if __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
    } else if (param.src_type == dtype::Float16{}) {
        DISPATCH_FUNC(__fp16, 8, 1);
#endif
    }