Method Run

executor/operator/arm32/prelu_float.cpp:93–137

}

bool PreluOps::Run(Node* node)
{
    // inplace implement
    Tensor* input_tensor = node->GetInputTensor(0);
    Tensor* output_tensor = node->GetOutputTensor(0);
    const TShape& shape = input_tensor->GetShape();
    const std::vector<int> dims = shape.GetDim();
    int channel_size = dims[2] * dims[3];
    int channel_num = dims[1];
    int img_size = channel_size * channel_num;
    const float* input = ( float* )get_tensor_mem(input_tensor);
    float* output = ( float* )get_tensor_mem(output_tensor);
    const Tensor* slope_tensor = node->GetInputTensor(1);
    float* slope = ( float* )get_tensor_mem(slope_tensor);

    int cpu_number = cpu_info->GetCPUNumber();
    int block = channel_num ;
    block = block > 0 ? block : 1;
    int num_task = cpu_number < block ? cpu_number : block;
    int step = channel_num / num_task;

    for(int n = 0; n < dims[0]; n++)
    {
        const float *input_data = input + n * img_size;
        float *out_data = output + n * img_size;

        if(num_task == 1)
            prelu_kernel( 0, 0, &step, input_data, out_data, slope, channel_size);
        else
        {
            MULTI_THREAD_START(num_task, step, p_id, p_param)
                    prelu_kernel(0, p_id, p_param, input_data, out_data, slope, channel_size);
            MULTI_THREAD_END();
        }
        if(num_task * step != channel_num)
        {
            int offset = num_task * step;
            int remain_num = channel_num - offset;
            input_data += offset * channel_size;
            out_data += offset * channel_size;
            prelu_kernel(0, 0, &remain_num, input_data, out_data, slope + offset, channel_size);
        }
    }
    return true;
}

NodeOps* SelectFunc(const CPUInfo* cpu_info, Node* node)
{