Method onResize

backupcode/cpubackend/CPUConvolution3D.cpp:128–224

    }

    ErrorCode CPUConvolution3D::onResize(const std::vector<Tensor *> &inputs, const std::vector<Tensor *> &outputs) {
        auto input = inputs[0];
        auto output = outputs[0];

        if (mPadMode == PadMode_SAME) {
            mPads.clear();
            for (int i = 0; i < 3; ++i) {
                int inputNeeded = (output->length(i + 2) - 1) * mStrides[i] + (mKernels[i] - 1) * mDilates[i] + 1;
                mPads.push_back((inputNeeded - input->length(i + 2)) / 2);
            }
        }

        const int batch = input->length(0), inputChannel = input->length(1), outputChannel = output->length(1);
        const int inputDepth = input->length(2), inputHeight = input->length(3), inputWidth = input->length(4);
        const int outputDepth = output->length(2), outputHeight = output->length(3), outputWidth = output->length(4);
        const int depthPad = mPads[0], kernelDepth = mKernels[0], kernelHeight = mKernels[1], kernelWidth = mKernels[2];
        auto cpuBackend = (CPUBackend*)backend();

        mBreakDown = true;
        mSubInputTensors.clear();
        mSubExecution.clear();

        do {
            bool useWinograd = ConvolutionWinograd3D::canUseWinograd(mCommon) || cpuBackend->memoryMode() != BackendConfig::Memory_Low;
            if (!useWinograd) {
                break;
            }
            auto unit = ConvolutionWinograd3D::bestWinogradUnit(mCommon, input, output, cpuBackend->threadNumber());
            if (unit > 4) {
                mSubExecution.emplace_back(
                            new ConvolutionWinograd3D(mCommon, input, output, cpuBackend, mWeights->host<float>(),
                                                      mWeights->elementSize(), mBias->host<float>(), outputChannel, unit));
            } else if (unit > 1 && kernelHeight == 3 && kernelWidth == 3) {
                mSubExecution.emplace_back(new Convolution3D3x3(mCommon, cpuBackend, mWeights->host<float>(), mWeights->elementSize(),
                                                                mBias->host<float>(), outputChannel));
            } else {
                break;
            }
            mSubExecution[0]->onResize(inputs, outputs);
            mBreakDown = false;
            return NO_ERROR;
        } while(0);

        mCrossDepth = (kernelDepth != 1 || kernelHeight != 1 || depthPad != 0 || mPads[1] != 0);

        if (!mCrossDepth) {
            mSubInputTensors.emplace_back(Tensor::create<float>({batch, inputChannel, inputDepth * inputHeight, inputWidth},
                                                                (void*)(input->host<float>()), Tensor::CAFFE_C4));
            mSubOutputTensor.reset(Tensor::create<float>({batch, outputChannel, outputDepth * outputHeight, outputWidth},
                                                               (void*)(output->host<float>()), Tensor::CAFFE_C4));
        } else {
            mInputStorage.reset(Tensor::createDevice<float>({inputDepth + 2 * depthPad, batch, ALIGN_UP4(inputChannel), inputHeight, inputWidth}));
            mSubOutputTensor.reset(Tensor::createDevice<float>({outputDepth * batch, outputChannel, outputHeight, outputWidth}, Tensor::CAFFE_C4));
            bool valid = true;
            valid = valid && backend()->onAcquireBuffer(mInputStorage.get(), Backend::DYNAMIC);
            valid = valid && backend()->onAcquireBuffer(mSubOutputTensor.get(), Backend::DYNAMIC);
            if (!valid) {
                return OUT_OF_MEMORY;