Method Run

executor/operator/arm64/eltwise_float.cpp:126–269

		return( kernel_run(param->output,param->input0,param->input1,param->type,param->in_size0,param->in_size1, param->stride));
	}
    bool Run(Node* node)

    {
        // input
        Tensor* input_tensor0 = node->GetInputTensor(0);
        int element_size = DataType::GetTypeSize(input_tensor0->GetDataType());
        float* input0 = (float*)get_tensor_mem(input_tensor0);
        
        Tensor* input_tensor1 = nullptr;
        float* input1 = nullptr;
        int in_size0 = input_tensor0->GetTotalSize() / element_size;
        int in_size1 = 0;
        if(node->GetInputNum() > 1)
        {
            input_tensor1 = node->GetInputTensor(1);
            input1 = (float*)get_tensor_mem(input_tensor1);
            in_size1 = input_tensor1->GetTotalSize() / element_size;
        }
		TShape ishape;
		int max_size = 0;
		int min_size = 0;
		float * main_data = NULL;
		float * scale_data = NULL;

		int batch_num = ishape.GetN();
		if(in_size0 >= in_size1)
		{
			ishape = input_tensor0->GetShape();
			main_data =  input0;
			scale_data =  input1;
			max_size = in_size0/batch_num;
			min_size = in_size1/batch_num;
		}
		else
		{
			ishape = input_tensor1->GetShape();
			main_data =  input1;
			scale_data =  input0;
			max_size = in_size1/batch_num;
			min_size = in_size0/batch_num;
		}

        // this version only support for input_num=2
        // int input_number=node->GetInputNum();

        // output
        Tensor* output_tensor = node->GetOutputTensor(0);
        float* output = (float*)get_tensor_mem(output_tensor);
        Eltwise* eltwise_op = dynamic_cast<Eltwise*>(node->GetOp());
        EltwiseParam* elt_param = eltwise_op->GetParam();
        bool result = true;

		int stride = ishape.GetH() * ishape.GetW();
		int channel = ishape.GetC();
		int cpu_number = cpu_info->GetCPUNumber();

		for(int n = 0; n < batch_num; n++)
		{