mirror of https://github.com/alibaba/MNN.git
148 lines
5.1 KiB
C++
148 lines
5.1 KiB
C++
//
|
|
// PoolBufExecution.cpp
|
|
// MNN
|
|
//
|
|
// Created by MNN on 2019/02/28.
|
|
// Copyright © 2018, Alibaba Group Holding Limited
|
|
//
|
|
|
|
#ifndef MNN_OPENCL_BUFFER_CLOSED
|
|
|
|
#include "backend/opencl/execution/buffer/PoolBufExecution.hpp"
|
|
#include "core/Macro.h"
|
|
#include "core/TensorUtils.hpp"
|
|
#include "backend/opencl/core/OpenCLBackend.hpp"
|
|
|
|
namespace MNN {
|
|
namespace OpenCL {
|
|
|
|
PoolBufExecution::PoolBufExecution(const std::vector<Tensor *> &inputs, const MNN::Op *op, Backend *backend)
|
|
: Execution(backend) {
|
|
mOpenCLBackend = static_cast<OpenCLBackend *>(backend);
|
|
mPoolParams = op->main_as_Pool();
|
|
mPoolType = mPoolParams->type();
|
|
|
|
mStrides[0] = mPoolParams->strideY();
|
|
mStrides[1] = mPoolParams->strideX();
|
|
mKernels[0] = mPoolParams->kernelY();
|
|
mKernels[1] = mPoolParams->kernelX();
|
|
|
|
mPaddings[0] = mPoolParams->padY() * 2;
|
|
mPaddings[1] = mPoolParams->padX() * 2;
|
|
mPadType = mPoolParams->padType();
|
|
if (mPadType == PoolPadType_VALID) {
|
|
mPaddings[0] = 0;
|
|
mPaddings[1] = 0;
|
|
}
|
|
}
|
|
|
|
ErrorCode PoolBufExecution::onResize(const std::vector<Tensor *> &inputs, const std::vector<Tensor *> &outputs) {
|
|
#ifdef LOG_VERBOSE
|
|
MNN_PRINT("start PoolBufExecution onResize !\n");
|
|
#endif
|
|
auto input = inputs[0];
|
|
auto output = outputs[0];
|
|
|
|
if (mPoolParams->isGlobal()) {
|
|
std::vector<int> inputShape = tensorShapeFormat(inputs[0]);
|
|
mKernels = {inputShape.at(1), inputShape.at(2)};
|
|
mStrides = {inputShape.at(1), inputShape.at(2)};
|
|
mPaddings = {0, 0};
|
|
}
|
|
|
|
if (mPadType == PoolPadType_SAME) {
|
|
int padNeededHeight = std::max(0, (output->height() - 1) * mStrides[0] + mKernels[0] - input->height());
|
|
int padNeededWidth = std::max(0, (output->width() - 1) * mStrides[1] + mKernels[1] - input->width());
|
|
|
|
mPaddings[0] = padNeededHeight;
|
|
mPaddings[1] = padNeededWidth;
|
|
}
|
|
|
|
MNN_ASSERT(mDilations[0] == 1 && mDilations[1] == 1);
|
|
|
|
std::vector<int> inputShape = tensorShapeFormat(input);
|
|
std::vector<int> outputShape = tensorShapeFormat(output);
|
|
|
|
const int batch = outputShape.at(0);
|
|
const int outputHeight = outputShape.at(1);
|
|
const int outputWidth = outputShape.at(2);
|
|
const int channels = outputShape.at(3);
|
|
|
|
const int inputHeight = inputShape.at(1);
|
|
const int inputWidth = inputShape.at(2);
|
|
int channelBlocks = (channels + 3) / 4;
|
|
|
|
std::set<std::string> buildOptions;
|
|
std::string kernelName = "pooling";
|
|
auto runtime = mOpenCLBackend->getOpenCLRuntime();
|
|
|
|
if (mPoolType == PoolType_AVEPOOL) {
|
|
buildOptions.emplace("-DPOOL_AVG");
|
|
}
|
|
|
|
mKernel = runtime->buildKernel("pooling_buf", kernelName, buildOptions);
|
|
mMaxWorkGroupSize = static_cast<uint32_t>(runtime->getMaxWorkGroupSize(mKernel));
|
|
|
|
mGlobalWorkSize = {
|
|
static_cast<uint32_t>(outputWidth),
|
|
static_cast<uint32_t>(batch * outputHeight),
|
|
static_cast<uint32_t>(channelBlocks),
|
|
};
|
|
|
|
int inputImageShape[2] = {inputHeight, inputWidth};
|
|
int outputImageShape[2] = {outputHeight, outputWidth};
|
|
int paddingShape[2] = {mPaddings[0] / 2, mPaddings[1] / 2};
|
|
int strideShape[2] = {mStrides[0], mStrides[1]};
|
|
int kernelShape[2] = {mKernels[0], mKernels[1]};
|
|
|
|
uint32_t idx = 0;
|
|
mKernel.setArg(idx++, mGlobalWorkSize[0]);
|
|
mKernel.setArg(idx++, mGlobalWorkSize[1]);
|
|
mKernel.setArg(idx++, mGlobalWorkSize[2]);
|
|
mKernel.setArg(idx++, openCLBuffer(input));
|
|
mKernel.setArg(idx++, sizeof(inputImageShape), inputImageShape);
|
|
mKernel.setArg(idx++, sizeof(outputImageShape), outputImageShape);
|
|
mKernel.setArg(idx++, sizeof(paddingShape), paddingShape);
|
|
mKernel.setArg(idx++, sizeof(strideShape), strideShape);
|
|
mKernel.setArg(idx++, sizeof(kernelShape), kernelShape);
|
|
mKernel.setArg(idx++, openCLBuffer(output));
|
|
mKernel.setArg(idx++, channelBlocks);
|
|
|
|
std::string kernelNameTune = "pooling_buf";
|
|
mLocalWorkSize =
|
|
localWS3DDefault(mGlobalWorkSize, mMaxWorkGroupSize, mOpenCLBackend->getOpenCLRuntime(), kernelNameTune, mKernel).first;
|
|
|
|
#ifdef LOG_VERBOSE
|
|
MNN_PRINT("end PoolBufExecution onResize !\n");
|
|
#endif
|
|
return NO_ERROR;
|
|
}
|
|
|
|
ErrorCode PoolBufExecution::onExecute(const std::vector<Tensor *> &inputs, const std::vector<Tensor *> &outputs) {
|
|
#ifdef LOG_VERBOSE
|
|
MNN_PRINT("start PoolBufExecution onExecute !\n");
|
|
#endif
|
|
|
|
#ifdef ENABLE_OPENCL_TIME_PROFILER
|
|
cl::Event event;
|
|
run3DKernelDefault(mKernel, mGlobalWorkSize, mLocalWorkSize,
|
|
mOpenCLBackend->getOpenCLRuntime(), &event);
|
|
|
|
int costTime = (int)mOpenCLBackend->getOpenCLRuntime()->getCostTime(&event);
|
|
MNN_PRINT("kernel cost:%d us Pooling\n",costTime);
|
|
#else
|
|
run3DKernelDefault(mKernel, mGlobalWorkSize, mLocalWorkSize,
|
|
mOpenCLBackend->getOpenCLRuntime());
|
|
#endif
|
|
|
|
#ifdef LOG_VERBOSE
|
|
MNN_PRINT("end PoolBufExecution onExecute !\n");
|
|
#endif
|
|
return NO_ERROR;
|
|
}
|
|
|
|
OpenCLCreatorRegister<TypedCreator<PoolBufExecution>> __PoolBuf_op(OpType_Pooling, BUFFER);
|
|
} // namespace OpenCL
|
|
} // namespace MNN
|
|
#endif /* MNN_OPENCL_BUFFER_CLOSED */
|