Method Run

executor/operator/common/arm/lrn_arm.cpp:238–317

    }

    bool Run(Node* node)
    {
        Tensor* input_tensor = node->GetInputTensor(0);
        Tensor* output_tensor = node->GetOutputTensor(0);

        LRN* lrn_op = dynamic_cast<LRN*>(node->GetOp());
        LRNParam* param = lrn_op->GetParam();

        const float* input = ( float* )get_tensor_mem(input_tensor);
        float* output = ( float* )get_tensor_mem(output_tensor);

        float* square = ( float* )(std::malloc(input_tensor->GetTotalSize()));

        const TShape& shape = input_tensor->GetShape();
        const std::vector<int>& dims = shape.GetDim();

        int n = dims[0];
        int c = dims[1];
        int h = dims[2];
        int w = dims[3];

        int img_size = c * h * w;
        int channel_size = h * w;
        float alpha = param->alpha;
        float beta = param->beta;
        float bias = param->k;
        int local_size = param->local_size;

        int cpu_number = cpu_info->GetCPUNumber();
        int num_task = c < cpu_number ? c : cpu_number;
        int step = c / num_task;
        for(int i = 0; i < n; i++)
        {
            /* get square value */
            const float* img_base = input + i * img_size;
            float* out_base = output + i * img_size;

            int j = 0;
            for(j = 0; j < (img_size & -4); j+=4)
            {
                float32x4_t in = vld1q_f32(img_base + j);
                in = vmulq_f32(in, in);
                vst1q_f32(square + j, in);
            }
            for(; j < img_size; j++)
                square[j] = img_base[j] * img_base[j];

            if(param->norm_region != LRN_ACROSS_CHANNELS)
            {
                std::free(square);
                LOG_ERROR() << "LRN: Only support Across_channels\n";
                return false;
            }
            if(num_task == 1)
            {
                lrn_kernel(0, 0, &step, img_base, out_base, square, alpha, beta, bias,
                    local_size, channel_size, c);
            }