Method testUnit

test/op/ConvolutionTest.cpp:526–677

    }

    bool testUnit(MNNForwardType type, const std::string& device_name, const std::string& test_op_name, int batch,
                     int ic, int oc, int ih, int iw, PadMode mode, int pad_h, int pad_w, int kh, int kw, int stride,
                  int dilation, int group, int precision, MNN::SparseAlgo sparseAlgo = MNN::SparseAlgo_RANDOM, int sparseBlockOC = 1, bool debug = false, int nbit = 8, bool async = false) {
        using namespace MNN::Express;
        std::map<PadMode, Express::PaddingMode> padMap = {
            {PadMode_CAFFE, CAFFE}, {PadMode_VALID, VALID}, {PadMode_SAME, SAME}};
        std::vector<float> weightData, biasData;

        generateWeight(weightData, ic, oc, kh, kw, dilation, group, sparseBlockOC);

        for (int i = 0; i < oc; i++) {
            auto data      = (((i / kw) % 1317) * ((i / kh) % 1317) + i / ic + i / oc + (oc - i) * ic + i * (oc - i)) % 1317;
            auto floatData = (float)(data % 255) / 255.0f;
            biasData.push_back(floatData);
        }

        std::vector<float> inputData, outputData, outputDataSeparateBias;
        float rate = 1.0f;
        if (ih * iw * ic * batch > 10000) {
            // Avoid exceed fp16 limit
            rate = 0.01f;
        }
        for (int i = 0; i < ih * iw * ic * batch; ++i) {
            auto data      = ((i / kw) % 1317) * ((i / kh) % 1317) + ((i / ic)% 1317) * ((i / oc) % 1317) + ((oc - i) % 1317) * ic + (i % 1317) * ((oc - i) % 1317);
            data = data % 1317;
            data           = (data * data) % 1317;
            auto floatData = (float)(data % 255) / 255.0f * rate;
            inputData.push_back(floatData);
        }
        float fac = 1.23;
        int res = 10;
        float tail = 0.2;
        float threshold = (float)(1 << (nbit - 1)) - 1.0f;
        float clampMin = -threshold;
        if (async) {
            clampMin = -threshold - 1;
        }
        int kernel_size = ic * kw * kh;
        std::vector<int8_t> quantWeight(oc*ic*kw*kh);
        std::vector<float> wScale;
        if (async) {

            wScale.resize(2 * oc);
            for (int k = 0; k < oc; ++k) {
                int beginIndex = k * kernel_size;
                auto minMax = findMinMax(weightData.data() + beginIndex, kernel_size);
                auto minValue = minMax.first;
                wScale[2*k] = minMax.first;
                auto absMax = minMax.second - minMax.first;
                wScale[2*k+1] = 0;

                float quantscale = 1.0f;
                if (absMax >= 0.000001f) {
                    wScale[2 * k + 1] = absMax / (threshold - clampMin);
                    quantscale = 1.0f / wScale[2*k+1];

                }
                float* ptr = weightData.data() + beginIndex;