Method Run

executor/operator/arm32/softmax_float.cpp:179–233

        }
    }
    bool Run(Node* node)
    {
        Tensor* input_tensor = node->GetInputTensor(0);
        Tensor* output_tensor = node->GetOutputTensor(0);
        const std::vector<int>& dims = input_tensor->GetShape().GetDim();
        Softmax* softmax_op = dynamic_cast<Softmax*>(node->GetOp());
        SoftmaxParam* param_ = softmax_op->GetParam();


        int dim_size = dims.size();
        int axis = param_->axis;
        if(axis > dim_size)
            axis = dim_size - 1;
        int out_size, in_size, on_size;
        out_size = 1;
        for(int i = 0; i < axis; i++)
        {
            out_size *= dims[i];
        }
        in_size = 1;
        for(size_t i = axis + 1; i < dims.size(); i++)
        {
            in_size *= dims[i];
        }
        on_size = dims[axis];

        float* input = ( float* )get_tensor_mem(input_tensor);
        float* output = ( float* )get_tensor_mem(output_tensor);
        float* max_array = ( float* )std::malloc(in_size * cpu_number*sizeof(float));
        float* sum_array = ( float* )std::malloc(in_size * cpu_number*sizeof(float));

        int on_in_size = on_size * in_size;
        if(cpu_number==1)
        {
            for(int i = 0; i < out_size; i++)
            {
                /* get max */
                int img_base = i * on_in_size;
                GetMaxArray(input + img_base, max_array, in_size, on_size);
                GetOutResult(input + img_base, output + img_base, max_array, sum_array, in_size, on_size);
            }
        }
        else
        {
            MULTI_THREAD_START(cpu_number, cpu_number, tid, param_step)
            softmax_kernel(0, tid, param_step, 
                            out_size, on_in_size,in_size,on_size,input,max_array,output,sum_array);
            MULTI_THREAD_END();
        }
        

        std::free(max_array);
        std::free(sum_array);
        return true;
    }
};

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