Method onExecute

source/backend/cpu/CPUGridSample.cpp:160–202

        return NO_ERROR;
    }
    virtual ErrorCode onExecute(const std::vector<Tensor *> &inputs, const std::vector<Tensor *> &outputs) override {
        auto inputTensor = outputs[0];
        ::memset(inputTensor->host<uint8_t>(), 0, static_cast<CPUBackend*>(backend())->getTensorSize(inputTensor, false) * static_cast<CPUBackend*>(backend())->functions()->bytes);
        auto gridTensor = inputs[1];
        auto outputTensor = inputs[0];
        auto inputPtr = inputTensor->host<uint8_t>();
        auto gridPtr = gridTensor->host<uint8_t>();
        auto outputPtr = outputTensor->host<uint8_t>();
        auto core = static_cast<CPUBackend*>(backend())->functions();
        auto batches = inputTensor->buffer().dim[0].extent;
        auto channels = inputTensor->buffer().dim[1].extent;
        auto channelC4 = UP_DIV(channels, core->pack);
        if (outputTensor->dimensions() != 4) {
            return NOT_SUPPORT;
        }
        auto inH = inputTensor->buffer().dim[2].extent;
        auto inW = inputTensor->buffer().dim[3].extent;
        auto outH = outputTensor->buffer().dim[2].extent;
        auto outW = outputTensor->buffer().dim[3].extent;
        auto threadCount = static_cast<CPUBackend*>(backend())->threadNumber();
        auto tileCount = outH;
        auto inOffset  = batches * inH * inW * core->pack;
        auto outOffset = batches * outH * outW * core->pack;
        auto cordPtr = mTempCordBuffer->host<uint8_t>();
        for (auto b = 0; b < batches; ++b) {
            auto _inputPtr = inputPtr + b * inH * inW * core->pack * core->bytes;
            auto _gridPtr = gridPtr + b * gridTensor->buffer().dim[0].stride * core->bytes;
            auto _outputPtr = outputPtr + b * outH * outW * core->pack * core->bytes;
            core->MNNGridSampleComputeCord((float *)cordPtr, (const float *)_gridPtr, inH, inW, outH, outW, mAlignCorners);
            // Compute cord
            for (int index=0; index < tileCount; index++) {
                auto c = index / outH;
                auto h = index % outH;
                auto inputC = _inputPtr + c * inW * inH * batches * core->pack * core->bytes;
                auto outputC = _outputPtr + c * outW * outH * batches * core->pack * core->bytes;
                auto cordH = cordPtr + h * outW * 2 * core->bytes;
                auto outputH = outputC + h * outW * core->pack * core->bytes;
                core->MNNGridSampleInterpGrad((float *)outputH, (float *)inputC, (const float *)cordH, inH, inW, outW, channelC4, inOffset, outOffset, (mMode == SampleMode_NEAREST), (mPaddingMode == BorderMode_ZEROS));
            }
        }

        return NO_ERROR;
    }
};
#endif
class CPUGridSampleCreator : public CPUBackend::Creator {