mindspore-Ecosystem
/
mindspore
21
0
Fork 27
Code Issues Pull Requests 6 Projects Releases Wiki Activity

modify strategys to strategies

This commit is contained in:
yangzhenzhang 2022-07-08 10:17:45 +08:00
parent df68f7cb92
commit 3b7fc4db29
100 changed files with 461 additions and 461 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
mindspore/ccsrc/frontend/parallel/auto_parallel/graph_costmodel.cc
View File

@ -1674,7 +1674,7 @@ Status CostGraph::InitReshapeStrategy() {
if (stra.empty()) {
MS_LOG(EXCEPTION) << "Infer strategy by tensor_info failed";
}
Strategys stra_inputs = {stra};
Strategies stra_inputs = {stra};
StrategyPtr reshape_stra =
std::make_shared<Strategy>((*pre_iter)->prev_operator()->strategy()->GetInputStage(), stra_inputs);
reshape_info->set_strategy(reshape_stra);

102
mindspore/ccsrc/frontend/parallel/auto_parallel/rec_core/rec_generate_strategy.cc
View File

@ -80,9 +80,9 @@ Dimensions PrepareMatMulStrategy(const std::shared_ptr<Graph> &graph, const size
return s;
}
Strategys PrepareMatMul(const std::shared_ptr<Graph> &graph, const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const size_t iter_graph, const size_t iter_ops) {
Strategys strategies;
Strategies PrepareMatMul(const std::shared_ptr<Graph> &graph, const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const size_t iter_graph, const size_t iter_ops) {
Strategies strategies;
auto attrs = ops[iter_ops]->attrs();
bool transpose_a = attrs[TRANSPOSE_A]->cast<BoolImmPtr>()->value();
bool transpose_b = attrs[TRANSPOSE_B]->cast<BoolImmPtr>()->value();
@ -94,8 +94,8 @@ Strategys PrepareMatMul(const std::shared_ptr<Graph> &graph, const std::vector<s
return strategies;
}
Strategys PrepareBiasAdd(const std::shared_ptr<Dimensions> &s) {
Strategys strategies;
Strategies PrepareBiasAdd(const std::shared_ptr<Dimensions> &s) {
Strategies strategies;
strategies.push_back(*s);
Dimensions s_biasadd;
s_biasadd.push_back(s->at(1));
@ -103,9 +103,9 @@ Strategys PrepareBiasAdd(const std::shared_ptr<Dimensions> &s) {
return strategies;
}
Strategys PrepareStridedSlice(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops,
Dimensions basic_stra) {
Strategys stra;
Strategies PrepareStridedSlice(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops,
Dimensions basic_stra) {
Strategies stra;
auto begin = GetValue<std::vector<int64_t>>(ops[iter_ops]->input_value().at(1));
auto end = GetValue<std::vector<int64_t>>(ops[iter_ops]->input_value().at(2));
@ -128,9 +128,9 @@ Strategys PrepareStridedSlice(const std::vector<std::shared_ptr<OperatorInfo>> &
return stra;
}
Strategys PrepareSoftMax(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops,
Dimensions basic_stra) {
Strategys strategies;
Strategies PrepareSoftMax(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops,
Dimensions basic_stra) {
Strategies strategies;
strategies.push_back(basic_stra);
std::vector<int64_t> axis_list;
string axis_name = AXIS;
@ -173,8 +173,8 @@ Strategys PrepareSoftMax(const std::vector<std::shared_ptr<OperatorInfo>> &ops,
return strategies;
}
Strategys PrepareOneHot(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops, Dimensions s) {
Strategys strategies;
Strategies PrepareOneHot(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops, Dimensions s) {
Strategies strategies;
// The Dimension size of the first input tensor of OneHot should be 2 even its Shape size is 1. Using the division of
// the number of devices and the partition parts of the first dimension.
@ -206,8 +206,8 @@ Strategys PrepareOneHot(const std::vector<std::shared_ptr<OperatorInfo>> &ops, c
return strategies;
}
Strategys PrepareGatherV2(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops, Dimensions s) {
Strategys strategies;
Strategies PrepareGatherV2(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops, Dimensions s) {
Strategies strategies;
auto output_shape = ops[iter_ops]->outputs_tensor_info()[0].shape();
Dimensions index(output_shape.size() - 1, 0);
@ -302,8 +302,8 @@ Dimensions PrepareGatherV2OutputStrategy(const std::vector<std::shared_ptr<Opera
return strategie;
}
Strategys PrepareL2Normalize(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops,
Dimensions s) {
Strategies PrepareL2Normalize(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops,
Dimensions s) {
int64_t axis = 0;
auto iter = ops[iter_ops]->attrs().find(AXIS);
if (iter != ops[iter_ops]->attrs().end()) {
@ -323,15 +323,15 @@ Strategys PrepareL2Normalize(const std::vector<std::shared_ptr<OperatorInfo>> &o
s[LongToSize(axis_index)] = 1;
Strategys strategies;
Strategies strategies;
strategies.push_back(s);
return strategies;
}
Strategys PrepareAxisRelatedStrategy(const std::shared_ptr<Graph> &graph,
const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_graph,
const size_t iter_ops) {
Strategys strategies = MakeRecSearchStrategy(graph, ops, iter_graph, iter_ops);
Strategies PrepareAxisRelatedStrategy(const std::shared_ptr<Graph> &graph,
const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_graph,
const size_t iter_ops) {
Strategies strategies = MakeRecSearchStrategy(graph, ops, iter_graph, iter_ops);
if (strategies.size() < 1) {
MS_LOG(EXCEPTION) << ops[iter_ops]->name() << ": get empty Strategy.";
}
@ -380,9 +380,9 @@ Strategys PrepareAxisRelatedStrategy(const std::shared_ptr<Graph> &graph,
return strategies;
}
Strategys MakeRecSearchStrategy(const std::shared_ptr<Graph> &graph,
const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_graph,
const size_t iter_ops) {
Strategies MakeRecSearchStrategy(const std::shared_ptr<Graph> &graph,
const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_graph,
const size_t iter_ops) {
if (ops.empty()) {
MS_LOG(EXCEPTION) << "Failure: Operators is empty.";
}
@ -394,7 +394,7 @@ Strategys MakeRecSearchStrategy(const std::shared_ptr<Graph> &graph,
}
StrategyPtr origin_strategy = ops[iter_ops]->strategy();
Strategys strategies;
Strategies strategies;
for (size_t iter_op_inputs = 0; iter_op_inputs < ops[iter_ops]->inputs_tensor_info().size(); iter_op_inputs++) {
if (iter_op_inputs >= origin_strategy->GetInputDim().size()) {
MS_LOG(EXCEPTION) << "Failure: Strategy's InputDim out of range.";
@ -437,9 +437,9 @@ Strategys MakeRecSearchStrategy(const std::shared_ptr<Graph> &graph,
return strategies;
}
Strategys MakeDataParallelStrategy(const std::shared_ptr<Graph> &graph,
const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_graph,
const size_t iter_ops) {
Strategies MakeDataParallelStrategy(const std::shared_ptr<Graph> &graph,
const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_graph,
const size_t iter_ops) {
if (ops.empty()) {
MS_LOG(EXCEPTION) << "Failure: Operators is empty.";
}
@ -448,7 +448,7 @@ Strategys MakeDataParallelStrategy(const std::shared_ptr<Graph> &graph,
}
StrategyPtr origin_strategy = ops[iter_ops]->strategy();
Strategys strategies;
Strategies strategies;
size_t max_device_num = g_device_manager->DeviceNum();
size_t target_tensor_batch = ops[iter_ops]->inputs_tensor_info()[0].shape()[0];
for (size_t iter_op_inputs = 0; iter_op_inputs < ops[iter_ops]->inputs_tensor_info().size(); iter_op_inputs++) {
@ -500,9 +500,9 @@ Strategys MakeDataParallelStrategy(const std::shared_ptr<Graph> &graph,
return strategies;
}
Strategys MakeFullBatchStrategy(const std::shared_ptr<Graph> &graph,
const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_graph,
const size_t iter_ops) {
Strategies MakeFullBatchStrategy(const std::shared_ptr<Graph> &graph,
const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_graph,
const size_t iter_ops) {
if (ops.empty()) {
MS_LOG(EXCEPTION) << "Failure: Operators is empty.";
}
@ -511,7 +511,7 @@ Strategys MakeFullBatchStrategy(const std::shared_ptr<Graph> &graph,
}
StrategyPtr origin_strategy = ops[iter_ops]->strategy();
Strategys strategies;
Strategies strategies;
for (size_t iter_op_inputs = 0; iter_op_inputs < ops[iter_ops]->inputs_tensor_info().size(); iter_op_inputs++) {
if (iter_op_inputs >= origin_strategy->GetInputDim().size()) {
MS_LOG(EXCEPTION) << "Failure: Strategy's InputDim out of range.";
@ -540,7 +540,7 @@ Strategys MakeFullBatchStrategy(const std::shared_ptr<Graph> &graph,
void SetBackToRawStrategy(const std::shared_ptr<OperatorInfo> &op) {
StrategyPtr origin_strategy = op->strategy();
Strategys strategies;
Strategies strategies;
for (size_t iter_strategy = 0; iter_strategy < origin_strategy->GetInputDim().size(); iter_strategy++) {
Dimensions s;
@ -561,8 +561,8 @@ void SetBackToRawStrategy(const std::shared_ptr<OperatorInfo> &op) {
op->SetSelectedStrategyAndCost(sp, op->selected_cost());
}
Strategys PrepareStrategy(const std::shared_ptr<Graph> &graph, const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const size_t iter_graph, const size_t iter_ops) {
Strategies PrepareStrategy(const std::shared_ptr<Graph> &graph, const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const size_t iter_graph, const size_t iter_ops) {
if (ops.empty()) {
MS_LOG(EXCEPTION) << "Failure: Operators is empty.";
}
@ -593,7 +593,7 @@ void GeneratePartitionedOperatorStrategy(const std::shared_ptr<Graph> &graph,
const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const std::shared_ptr<std::vector<size_t>> &index_list) {
for (size_t iter_ops = 0; iter_ops < (size_t)index_list->size(); iter_ops++) {
Strategys strategies;
Strategies strategies;
size_t iter_graph = index_list->at(iter_ops);
if (iter_graph != SIZE_MAX && ops[iter_ops]->type() != GET_NEXT) {
strategies = PrepareStrategy(graph, ops, iter_graph, iter_ops);
@ -618,7 +618,7 @@ void ModifyParamSharingOpsStrategy(const std::vector<std::shared_ptr<OperatorInf
} else {
continue;
}
Strategys strategies;
Strategies strategies;
Dimensions str1, str2;
str1 = str_j;
size_t num_device_used = 1;
@ -1107,9 +1107,9 @@ Dimensions CopyIncomingOperatorInputStrategy(const std::vector<std::shared_ptr<O
return s;
}
Strategys GenerateStrategiesFromStrategy(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops,
Dimensions basic_stra) {
Strategys stra;
Strategies GenerateStrategiesFromStrategy(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops,
Dimensions basic_stra) {
Strategies stra;
MS_EXCEPTION_IF_NULL(ops[iter_ops]);
if (iter_ops >= ops.size()) {
@ -1157,9 +1157,9 @@ Strategys GenerateStrategiesFromStrategy(const std::vector<std::shared_ptr<Opera
}
// Function to deal with ops with broadcasting, like TensorAdd/Sub/Mul/Div etc.
Strategys CheckBroadcast(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops,
const Dimensions s) {
Strategys stra;
Strategies CheckBroadcast(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops,
const Dimensions s) {
Strategies stra;
size_t first_tensor_dim = ops[iter_ops]->inputs_tensor_info()[0].shape().size();
size_t second_tensor_dim = ops[iter_ops]->inputs_tensor_info()[1].shape().size();
@ -1256,10 +1256,10 @@ Dimensions ApplyBroadcast(const std::vector<std::shared_ptr<OperatorInfo>> &ops,
}
// Check whether the operator can be divided by the current strategy.
Strategys CheckDivisible(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops,
const Dimensions basic_stra) {
Strategies CheckDivisible(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops,
const Dimensions basic_stra) {
Dimensions s_empty = {};
Strategys stra;
Strategies stra;
// For all the input tensors.
for (size_t iter_op_inputs = 0; iter_op_inputs < (size_t)ops[iter_ops]->inputs_tensor_info().size();
@ -1302,7 +1302,7 @@ void GenerateEliminatedOperatorStrategyForward(const std::shared_ptr<Graph> &gra
for (size_t iter_list = no_stra_op_list->size(); iter_list > 0; iter_list--) {
size_t iter_ops = no_stra_op_list->at(iter_list - 1);
Strategys stra;
Strategies stra;
Dimensions s;
size_t incoming_op_index = FindIndexOfOperatorIncoming(input_tensor_names, iter_ops);
if (incoming_op_index != SIZE_MAX) {
@ -1405,7 +1405,7 @@ void GenerateEliminatedOperatorStrategyBackward(const std::vector<std::shared_pt
for (size_t iter_list = no_stra_op_list->size(); iter_list > 0; iter_list--) {
auto iter_ops = no_stra_op_list->at(iter_list - 1);
Strategys stra;
Strategies stra;
Dimensions s = CopyOutgoingOperatorInputStrategy(ops, input_tensor_names, iter_ops);
if (s.size() != 0 && ops[iter_ops]->type() == SQUEEZE) {
s = ModifyStrategyIfSqueezeOutgoing(ops, iter_ops, s);
@ -1444,7 +1444,7 @@ void GenerateRemainingOperatorStrategy(const std::shared_ptr<Graph> &graph,
for (size_t iter_list = 0; iter_list < no_stra_op_list->size(); iter_list++) {
auto iter_ops = no_stra_op_list->at(iter_list);
Strategys stra;
Strategies stra;
Dimensions s;
size_t max_dim_num = 0;

58
mindspore/ccsrc/frontend/parallel/auto_parallel/rec_core/rec_generate_strategy.h
View File

@ -34,38 +34,38 @@ void GenerateStrategy(const std::shared_ptr<Graph> &graph, const std::vector<std
const std::vector<std::vector<size_t>> &shared_tensors_ops);
Dimensions PrepareMatMulStrategy(const std::shared_ptr<Graph> &graph, const size_t iter_graph, bool transpose_a,
bool transpose_b, size_t iter_op_inputs);
Strategys PrepareMatMul(const std::shared_ptr<Graph> &graph, const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const size_t iter_graph, const size_t iter_ops);
Strategys PrepareBiasAdd(const std::shared_ptr<Dimensions> &s);
Strategys PrepareStridedSlice(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops,
Dimensions basic_stra);
Strategys PrepareSoftMax(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops,
Dimensions basic_stra);
Strategys PrepareOneHot(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops, Dimensions s);
Strategys PrepareAxisRelatedStrategy(const std::shared_ptr<Graph> &graph,
const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_graph,
const size_t iter_ops);
Strategys PrepareGatherV2(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops, Dimensions s);
Strategies PrepareMatMul(const std::shared_ptr<Graph> &graph, const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const size_t iter_graph, const size_t iter_ops);
Strategies PrepareBiasAdd(const std::shared_ptr<Dimensions> &s);
Strategies PrepareStridedSlice(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops,
Dimensions basic_stra);
Strategies PrepareSoftMax(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops,
Dimensions basic_stra);
Strategies PrepareOneHot(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops, Dimensions s);
Strategies PrepareAxisRelatedStrategy(const std::shared_ptr<Graph> &graph,
const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_graph,
const size_t iter_ops);
Strategies PrepareGatherV2(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops, Dimensions s);
Dimensions PrepareGatherV2OutputStrategy(const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const size_t incoming_op_index);
Strategys PrepareL2Normalize(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops,
Dimensions s);
Strategys MakeRecSearchStrategy(const std::shared_ptr<Graph> &graph,
const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_graph,
const size_t iter_ops);
Strategys CheckBroadcast(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops, Dimensions s);
Strategies PrepareL2Normalize(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops,
Dimensions s);
Strategies MakeRecSearchStrategy(const std::shared_ptr<Graph> &graph,
const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_graph,
const size_t iter_ops);
Strategies CheckBroadcast(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops, Dimensions s);
Dimensions ApplyBroadcast(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops, Dimensions s,
size_t first_tensor_dim, size_t second_tensor_dim, bool broadcast_first_tensor);
Strategys CheckDivisible(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops, Dimensions s);
Strategys MakeDataParallelStrategy(const std::shared_ptr<Graph> &graph,
const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_graph,
const size_t iter_ops);
Strategys MakeFullBatchStrategy(const std::shared_ptr<Graph> &graph,
const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_graph,
const size_t iter_ops);
Strategies CheckDivisible(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops, Dimensions s);
Strategies MakeDataParallelStrategy(const std::shared_ptr<Graph> &graph,
const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_graph,
const size_t iter_ops);
Strategies MakeFullBatchStrategy(const std::shared_ptr<Graph> &graph,
const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_graph,
const size_t iter_ops);
void SetBackToRawStrategy(const std::shared_ptr<OperatorInfo> &op);
Strategys PrepareStrategy(const std::shared_ptr<Graph> &graph, const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const size_t iter_graph, const size_t iter_ops);
Strategies PrepareStrategy(const std::shared_ptr<Graph> &graph, const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const size_t iter_graph, const size_t iter_ops);
void GeneratePartitionedOperatorStrategy(const std::shared_ptr<Graph> &graph,
const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const std::shared_ptr<std::vector<size_t>> &index_list);
@ -97,8 +97,8 @@ Dimensions ModifyStrategyIfArgIncoming(const std::vector<std::shared_ptr<Operato
const size_t incoming_op_index, Dimensions s);
Dimensions CopyIncomingOperatorInputStrategy(const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const size_t iter_ops, const size_t incoming_op_index);
Strategys GenerateStrategiesFromStrategy(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops,
Dimensions basic_stra);
Strategies GenerateStrategiesFromStrategy(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops,
Dimensions basic_stra);
void GenerateEliminatedOperatorStrategyForward(const std::shared_ptr<Graph> &graph,
const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const std::vector<std::vector<std::string>> &input_tensor_names,

6
mindspore/ccsrc/frontend/parallel/ops_info/activation_info.cc
View File

@ -108,7 +108,7 @@ Status Softmax::CheckStrategy(const StrategyPtr &strategy) {
return FAILED;
}
Strategys stra = strategy->GetInputDim();
Strategies stra = strategy->GetInputDim();
Dimensions input_strategy = stra.at(0);
for (auto &element : axis_) {
@ -243,7 +243,7 @@ Status CumOpBase::CheckStrategy(const StrategyPtr &strategy) {
return FAILED;
}
Strategys stra = strategy->GetInputDim();
Strategies stra = strategy->GetInputDim();
Dimensions input_strategy = stra.at(0);
if (input_strategy.size() <= LongToSize(axis_)) {
MS_LOG(ERROR) << "The " << name_ << " input strategy length: " << input_strategy.size() << ", is less ot equal to "
@ -292,7 +292,7 @@ Status CumOpBase::InferMirrorOps() {
}
Status ActivationBase::InferDevMatrixShape() {
Strategys stra = strategy_->GetInputDim();
Strategies stra = strategy_->GetInputDim();
Dimensions input_strategy = stra.at(0);
dev_matrix_shape_ = input_strategy;

4
mindspore/ccsrc/frontend/parallel/ops_info/activation_info.h
View File

@ -256,8 +256,8 @@ class ExpandDimsInfo : public ActivationOther {
private:
int64_t positive_axis_ = -1;
Strategys inputs_strategy_;
Strategys outputs_strategy_;
Strategies inputs_strategy_;
Strategies outputs_strategy_;
};
class SqueezeInfo : public ActivationOther {

6
mindspore/ccsrc/frontend/parallel/ops_info/addn_info.cc
View File

@ -27,7 +27,7 @@ Status AddNInfo::CheckStrategy(const StrategyPtr &strategy) {
}
// The strategy for each input tensor must be equal
Strategys strategies = strategy->GetInputDim();
Strategies strategies = strategy->GetInputDim();
for (size_t i = 1; i < strategies.size(); ++i) {
if (strategies[i] != strategies[0]) {
return FAILED;
@ -39,7 +39,7 @@ Status AddNInfo::CheckStrategy(const StrategyPtr &strategy) {
Status AddNInfo::InferDevMatrixShape() {
dev_matrix_shape_.clear();
Strategys strategies = strategy_->GetInputDim();
Strategies strategies = strategy_->GetInputDim();
if (strategies.empty()) {
return SUCCESS;
}
@ -59,7 +59,7 @@ Status AddNInfo::InferTensorMap() {
sub_tensor_map.push_back(dev_size - i - 1);
}
Strategys strategies = strategy_->GetInputDim();
Strategies strategies = strategy_->GetInputDim();
for (size_t i = 0; i < strategies.size(); ++i) {
inputs_tensor_map_.push_back(sub_tensor_map);
}

22
mindspore/ccsrc/frontend/parallel/ops_info/arithmetic_info.cc
View File

@ -53,9 +53,9 @@ Shapes ArithmeticBase::InferExpandShape() {
return input_shapes;
}
Strategys ExpandStrategy(const StrategyPtr &strategy) {
Strategys expand_strategy;
Strategys stra = strategy->GetInputDim();
Strategies ExpandStrategy(const StrategyPtr &strategy) {
Strategies expand_strategy;
Strategies stra = strategy->GetInputDim();
Dimensions sub_a_strategy = stra.at(0);
Dimensions sub_b_strategy = stra.at(1);
size_t input_a_size = sub_a_strategy.size();
@ -77,7 +77,7 @@ Status ArithmeticBase::CheckStrategy(const StrategyPtr &strategy) {
return FAILED;
}
Shapes input_shapes = InferExpandShape();
Strategys expand_strategy = ExpandStrategy(strategy);
Strategies expand_strategy = ExpandStrategy(strategy);
Dimensions sub_a_strategy = expand_strategy.at(0);
Dimensions sub_b_strategy = expand_strategy.at(1);
Shape input_a_shape = input_shapes.at(0);
@ -93,7 +93,7 @@ Status ArithmeticBase::CheckStrategy(const StrategyPtr &strategy) {
}
Status ArithmeticBase::InferDevMatrixShape() {
Strategys expand_strategy = ExpandStrategy(strategy_);
Strategies expand_strategy = ExpandStrategy(strategy_);
Dimensions sub_a_strategy = expand_strategy.at(0);
Dimensions sub_b_strategy = expand_strategy.at(1);
Shape dev_shape;
@ -150,10 +150,10 @@ void ArithmeticBase::ReComputeBatchSplitFlagList() {
Status ArithmeticBase::InferTensorMap() {
Shape tensor_map_index;
Strategys expand_strategy = ExpandStrategy(strategy_);
Strategies expand_strategy = ExpandStrategy(strategy_);
Dimensions sub_a_expand_strategy = expand_strategy.at(0);
Dimensions sub_b_expand_strategy = expand_strategy.at(1);
Strategys stra = strategy_->GetInputDim();
Strategies stra = strategy_->GetInputDim();
Dimensions sub_a_strategy = stra.at(0);
Dimensions sub_b_strategy = stra.at(1);
for (size_t i = 0; i < sub_a_expand_strategy.size(); ++i) {
@ -251,7 +251,7 @@ Status LerpInfo::CheckStrategy(const StrategyPtr &strategy) {
}
// validate strategy of weight
Strategys expand_strategy = ExpandStrategy(strategy);
Strategies expand_strategy = ExpandStrategy(strategy);
Dimensions expand_begin_strategy = expand_strategy.at(0);
Dimensions expand_end_strategy = expand_strategy.at(1);
Dimensions expand_cmp_strategy;
@ -286,7 +286,7 @@ Status LerpInfo::InferDevMatrixShape() {
}
dev_matrix_shape_.clear();
Strategys expand_strategy = ExpandStrategy(strategy_);
Strategies expand_strategy = ExpandStrategy(strategy_);
Dimensions expand_start_strategy = expand_strategy.at(0);
Dimensions expand_end_strategy = expand_strategy.at(1);
auto strategies = strategy_->GetInputDim();
@ -316,9 +316,9 @@ Status LerpInfo::InferTensorMap() {
return FAILED;
}
// Generate tensor map for 'weight'
Strategys stra = strategy_->GetInputDim();
Strategies stra = strategy_->GetInputDim();
Dimensions weight_strategy = stra.at(2);
Strategys expand_strategy = ExpandStrategy(strategy_);
Strategies expand_strategy = ExpandStrategy(strategy_);
Dimensions expand_start_strategy = expand_strategy.at(0);
Dimensions expand_weight_strategy = ExpandShape(expand_start_strategy, weight_strategy);
Shape dev_shape = dev_matrix_shape_;

8
mindspore/ccsrc/frontend/parallel/ops_info/batch_parallel_info.cc
View File

@ -32,7 +32,7 @@ Status BatchParallelInfo::CheckStrategy(const StrategyPtr &strategy) {
}
size_t strategy_size = strategy->GetInputNumber();
Strategys stra = strategy->GetInputDim();
Strategies stra = strategy->GetInputDim();
for (size_t i = 0; i < strategy_size; ++i) {
Shape sub_strategy = stra.at(i);
size_t strategy_len = sub_strategy.size();
@ -122,7 +122,7 @@ Status BatchParallelInfo::SetCostUnderStrategy(const StrategyPtr &strategy) {
std::vector<StrategyPtr> BatchParallelInfo::GenerateOpStrategies(int64_t stage_id) {
StrategyPtr sp;
Strategys strategy;
Strategies strategy;
ComputeBatchSplitFlagList();
for (size_t i = 0; i < inputs_shape_.size(); i++) {
@ -181,7 +181,7 @@ Status CheckValidInfo::CheckStrategy(const StrategyPtr &strategy) {
return FAILED;
}
Strategys stra = strategy->GetInputDim();
Strategies stra = strategy->GetInputDim();
if (stra[0][1] != 1) {
MS_LOG(ERROR) << name_ << ": The second dimension of the first input can not be split, but got " << stra[0][1];
return FAILED;
@ -195,7 +195,7 @@ Status CheckValidInfo::CheckStrategy(const StrategyPtr &strategy) {
}
Status CheckValidInfo::InferDevMatrixShape() {
Strategys stra = strategy_->GetInputDim();
Strategies stra = strategy_->GetInputDim();
dev_matrix_shape_.push_back(stra[0][0]);
return SUCCESS;
}

2
mindspore/ccsrc/frontend/parallel/ops_info/batchnorm_info.cc
View File

@ -315,7 +315,7 @@ std::vector<StrategyPtr> BatchNormInfo::GenerateOpStrategies(int64_t stage_id) {
if ((sp == nullptr) || sp->GetInputDim().empty()) {
MS_LOG(EXCEPTION) << name_ << ": The strategy is null or empty";
}
Strategys tmp_strategy;
Strategies tmp_strategy;
Dimensions first_input_strategy = sp->GetInputDim()[0];
if (first_input_strategy.size() < 2) {
MS_LOG(EXCEPTION) << name_ << ": The size of first input strategy can not smaller than 2, but got "

8
mindspore/ccsrc/frontend/parallel/ops_info/bias_add_info.cc
View File

@ -30,7 +30,7 @@ Status BiasAddInfo::CheckStrategy(const StrategyPtr &strategy) {
if (CheckStrategyValue(strategy, inputs_shape_) != SUCCESS) {
return FAILED;
}
Strategys stra = strategy->GetInputDim();
Strategies stra = strategy->GetInputDim();
Dimensions sub_a_strategy = stra.at(0);
Dimensions sub_b_strategy = stra.at(1);
int64_t channel_a_strategy = sub_a_strategy.at(1);
@ -43,7 +43,7 @@ Status BiasAddInfo::CheckStrategy(const StrategyPtr &strategy) {
}
Status BiasAddInfo::InferDevMatrixShape() {
Strategys stra = strategy_->GetInputDim();
Strategies stra = strategy_->GetInputDim();
Dimensions sub_a_strategy = stra.at(0);
dev_matrix_shape_ = sub_a_strategy;
return SUCCESS;
@ -57,7 +57,7 @@ void BiasAddInfo::ReComputeBatchSplitFlagList() {
Status BiasAddInfo::InferTensorMap() {
TensorMap sub_a_tensor_map;
TensorMap sub_b_tensor_map;
Strategys stra = strategy_->GetInputDim();
Strategies stra = strategy_->GetInputDim();
Dimensions sub_a_strategy = stra.at(0);
size_t sub_a_strategy_size = sub_a_strategy.size();
for (size_t i = 0; i < sub_a_strategy_size; ++i) {
@ -88,7 +88,7 @@ std::vector<StrategyPtr> BiasAddInfo::GenerateOpStrategies(int64_t stage_id) {
MS_LOG(INFO) << name_ << " : Generate strategies success.";
for (auto &sp : sp_vector) {
Strategys tmp_strategy;
Strategies tmp_strategy;
Dimensions input0_strategy = sp->GetInputDim()[0];
tmp_strategy.push_back(input0_strategy); // input0

6
mindspore/ccsrc/frontend/parallel/ops_info/bounding_box_encode_info.cc
View File

@ -23,7 +23,7 @@ Status BoundingBoxEncodeInfo::CheckStrategy(const StrategyPtr &strategy) {
return FAILED;
}
Strategys strategies = strategy->GetInputDim();
Strategies strategies = strategy->GetInputDim();
Dimensions input_a_strategy = strategies[0];
Dimensions input_b_strategy = strategies[1];
if (input_a_strategy != input_b_strategy) {
@ -45,7 +45,7 @@ Status BoundingBoxEncodeInfo::CheckStrategy(const StrategyPtr &strategy) {
}
Status BoundingBoxEncodeInfo::InferDevMatrixShape() {
Strategys strategies = strategy_->GetInputDim();
Strategies strategies = strategy_->GetInputDim();
Dimensions input_a_strategy = strategies.at(0);
dev_matrix_shape_.clear();
@ -106,7 +106,7 @@ Status BoundingBoxEncodeInfo::PrepareStrategy(int64_t stage_id, int64_t split_nu
Dimensions input0_partitions = {split_num, 1};
Dimensions input1_partitions = {split_num, 1};
Strategys strategies = {input0_partitions, input1_partitions};
Strategies strategies = {input0_partitions, input1_partitions};
(*sp) = std::make_shared<Strategy>(stage_id, strategies);
return SUCCESS;
}

2
mindspore/ccsrc/frontend/parallel/ops_info/broadcast_to_info.cc
View File

@ -141,7 +141,7 @@ std::vector<StrategyPtr> BroadcastToInfo::GenerateOpStrategies(int64_t stage_id)
if ((sp == nullptr) || sp->GetInputDim().empty()) {
MS_LOG(EXCEPTION) << name_ << ": The strategy is null or empty";
}
Strategys tmp_strategy;
Strategies tmp_strategy;
Dimensions first_input_strategy = sp->GetInputDim()[0];
for (size_t i = 0; i < inputs_shape_.size(); ++i) {
tmp_strategy.push_back(first_input_strategy);

2
mindspore/ccsrc/frontend/parallel/ops_info/concat_info.cc
View File

@ -172,7 +172,7 @@ std::vector<StrategyPtr> ConcatInfo::GenerateOpStrategies(int64_t stage_id) {
if ((sp == nullptr) || sp->GetInputDim().empty()) {
MS_LOG(EXCEPTION) << name_ << ": The strategy is null or empty";
}
Strategys tmp_strategy;
Strategies tmp_strategy;
Dimensions first_input_strategy = sp->GetInputDim()[0];
for (size_t i = 0; i < inputs_shape_.size(); ++i) {
tmp_strategy.push_back(first_input_strategy);

4
mindspore/ccsrc/frontend/parallel/ops_info/conv2d_info.cc
View File

@ -936,7 +936,7 @@ std::vector<StrategyPtr> Conv2DInfo::GenerateOpStrategies(int64_t stage_id) {
auto search_mode = parallel_context->strategy_search_mode();
// generate data parallel strategy when the search mode is not sharding propagation
if (parallel_mode == parallel::kAutoParallel && search_mode != parallel::kShardingPropagation) {
Strategys strategy = {{stage_device_size_, 1, 1, 1}, {1, 1, 1, 1}};
Strategies strategy = {{stage_device_size_, 1, 1, 1}, {1, 1, 1, 1}};
StrategyPtr data_parallel_sp = std::make_shared<Strategy>(stage_id, strategy);
sp_vector.push_back(data_parallel_sp);
return sp_vector;
@ -960,7 +960,7 @@ std::vector<StrategyPtr> Conv2DInfo::GenerateOpStrategies(int64_t stage_id) {
if ((sp == nullptr) || sp->GetInputDim().empty()) {
MS_LOG(EXCEPTION) << name_ << ": The strategy is null or empty";
}
Strategys replace_strategy;
Strategies replace_strategy;
Dimensions tmp_strategy = sp->GetInputDim()[0];
if (tmp_strategy.size() != 5) {
MS_LOG(EXCEPTION) << name_ << ": The size of first tmp strategy must be 5, but got " << tmp_strategy.size();

2
mindspore/ccsrc/frontend/parallel/ops_info/crop_and_resize_info.cc
View File

@ -29,7 +29,7 @@ Status CropAndResizeInfo::CheckStrategy(const StrategyPtr &strategy) {
return FAILED;
}
Strategys strategies = strategy->GetInputDim();
Strategies strategies = strategy->GetInputDim();
auto x_strategy = strategies.at(0);
auto boxes_strategy = strategies.at(1);
auto index_strategy = strategies.at(2);

10
mindspore/ccsrc/frontend/parallel/ops_info/dropout_do_mask_info.cc
View File

@ -39,7 +39,7 @@ Status DropoutDoMaskInfo::CheckStrategy(const StrategyPtr &strategy) {
return FAILED;
}
Strategys stra = strategy->GetInputDim();
Strategies stra = strategy->GetInputDim();
if (stra.size() != 1) {
MS_LOG(ERROR) << name_ << ": Invalid strategy size " << stra.size() << ", it must be 1";
return FAILED;
@ -61,7 +61,7 @@ Status DropoutDoMaskInfo::InferDevMatrixShape() {
return FAILED;
}
Strategys strategy = strategy_->GetInputDim();
Strategies strategy = strategy_->GetInputDim();
if (strategy.empty()) {
MS_LOG(ERROR) << name_ << ": The strategy is empty";
return FAILED;
@ -110,11 +110,11 @@ std::vector<StrategyPtr> DropoutDoMaskInfo::GenerateOpStrategies(int64_t stage_i
return sp_vector;
}
std::shared_ptr<Strategys> DropoutDoMaskInfo::GenerateBatchStrategies() {
std::shared_ptr<Strategies> DropoutDoMaskInfo::GenerateBatchStrategies() {
Dimensions strategy(inputs_shape_[0].size() - 1, 1);
(void)strategy.insert(strategy.begin(), stage_device_size_);
Strategys strategy_v = {strategy};
return std::make_shared<Strategys>(strategy_v);
Strategies strategy_v = {strategy};
return std::make_shared<Strategies>(strategy_v);
}
size_t GetNonMonadInputSize(const CNodePtr &cnode) {

2
mindspore/ccsrc/frontend/parallel/ops_info/dropout_do_mask_info.h
View File

@ -38,7 +38,7 @@ class DropoutDoMaskInfo : public OperatorInfo {
std::vector<StrategyPtr> GenerateOpStrategies(int64_t stage_id) override;
Status SetCostUnderStrategy(const StrategyPtr &strategy) override;
std::shared_ptr<Strategys> GenerateBatchStrategies() override;
std::shared_ptr<Strategies> GenerateBatchStrategies() override;
std::vector<Operator> GetDropoutGenMaskReplaceOp(const CNodePtr &cnode);
void ReplaceNodeInputOrAttrs() override;

6
mindspore/ccsrc/frontend/parallel/ops_info/dsd_matmul_info.cc
View File

@ -48,7 +48,7 @@ Status DSDMatmulInfo::CheckStrategy(const StrategyPtr &strategy) {
if (CheckStrategyValue(strategy, inputs_shape_) != SUCCESS) {
return FAILED;
}
Strategys stras = strategy->GetInputDim();
Strategies stras = strategy->GetInputDim();
if (stras.size() != DSD_MATMUL_INPUTS_SIZE) {
MS_LOG(ERROR) << name_ << ": Invalid strategy. The strategys size should be 3.";
return FAILED;
@ -89,7 +89,7 @@ Status DSDMatmulInfo::CheckStrategy(const StrategyPtr &strategy) {
* device matrix use the strategy0.
*/
Status DSDMatmulInfo::InferDevMatrixShape() {
Strategys stra = strategy_->GetInputDim();
Strategies stra = strategy_->GetInputDim();
Dimensions input_strategy = stra.at(0);
input_strategy_ = input_strategy;
dev_matrix_shape_ = input_strategy;
@ -172,7 +172,7 @@ std::vector<StrategyPtr> DSDMatmulInfo::GenerateOpStrategies(int64_t stage_id) {
if ((sp == nullptr) || sp->GetInputDim().empty()) {
MS_LOG(EXCEPTION) << name_ << ": The strategy is null or empty";
}
Strategys tmp_strategy;
Strategies tmp_strategy;
Dimensions input_w1_strategy = sp->GetInputDim()[0];
Dimensions input_w2_strategy = input_w1_strategy;
Dimensions input_v_strategy = {input_w1_strategy[0], input_w1_strategy[1], 1, 1};

10
mindspore/ccsrc/frontend/parallel/ops_info/gather_info.cc
View File

@ -175,7 +175,7 @@ Status GatherInfo::GetAttrs() {
// output's strategy: [a, b, ..., c] or [1, a, b, ..., c]
// dev_matrix: [a, b, ..., c]
// can not support repeated calculation
Status GatherInfo::CheckManualSplit(const Strategys &strategy) {
Status GatherInfo::CheckManualSplit(const Strategies &strategy) {
if (strategy.size() != 2) {
MS_LOG(ERROR) << name_ << ": The size of strategy must be 2, but got " << strategy.size();
return FAILED;
@ -270,7 +270,7 @@ Status GatherInfo::CheckSplitAxisStrategy(const StrategyPtr &strategy) {
// return true: axis is 0, and split the first dimension of parameter and the first dimension of indices
// otherwise return false
bool GatherInfo::ShardBatchAndAxis(const Strategys &strategy) const {
bool GatherInfo::ShardBatchAndAxis(const Strategies &strategy) const {
if (axis_ != 0) {
return false;
}
@ -1015,7 +1015,7 @@ std::vector<StrategyPtr> GatherInfo::GenerateOpStrategies(int64_t stage_id) {
return sp_vector;
}
std::shared_ptr<Strategys> GatherInfo::GenerateBatchStrategies() {
std::shared_ptr<Strategies> GatherInfo::GenerateBatchStrategies() {
if (GetAttrs() != SUCCESS) {
MS_LOG(EXCEPTION) << name_ << ": Get attr failed";
}
@ -1029,8 +1029,8 @@ std::shared_ptr<Strategys> GatherInfo::GenerateBatchStrategies() {
for (size_t i = 1; i < inputs_shape_[1].size(); i++) {
index_strategy.push_back(1);
}
Strategys strategy_v = {param_strategy, index_strategy};
return std::make_shared<Strategys>(strategy_v);
Strategies strategy_v = {param_strategy, index_strategy};
return std::make_shared<Strategies>(strategy_v);
}
} // namespace parallel
} // namespace mindspore

6
mindspore/ccsrc/frontend/parallel/ops_info/gather_info.h
View File

@ -45,7 +45,7 @@ class GatherInfo : public OperatorInfo {
std::vector<StrategyPtr> GenerateOpStrategies(int64_t stage_id) override;
Status SetCostUnderStrategy(const StrategyPtr &strategy) override;
ReplaceGraphPtr replace_graph(const CNodePtr &cnode) override;
std::shared_ptr<Strategys> GenerateBatchStrategies() override;
std::shared_ptr<Strategies> GenerateBatchStrategies() override;
const std::vector<int64_t> &param_split_shapes() const { return param_split_shapes_; }
const std::vector<int64_t> &index_offsets() const { return index_offsets_; }
@ -64,7 +64,7 @@ class GatherInfo : public OperatorInfo {
void InferOutputsTensorMap();
void InferTensorMapForManualSplit();
Status ComputeReplaceGraph(const CNodePtr &cnode);
Status CheckManualSplit(const Strategys &strategy);
Status CheckManualSplit(const Strategies &strategy);
Status CheckSplitAxisStrategy(const StrategyPtr &strategy);
void SetAttribute(const StrategyPtr &strategy);
Status GetManualSplitAttr();
@ -73,7 +73,7 @@ class GatherInfo : public OperatorInfo {
Status InferBias();
Status InferOffset();
Status InferGroup();
bool ShardBatchAndAxis(const Strategys &strategy) const;
bool ShardBatchAndAxis(const Strategies &strategy) const;
Shape InferOutputsTensorMapSplitAxis();
int64_t axis_;

2
mindspore/ccsrc/frontend/parallel/ops_info/gatherd_info.cc
View File

@ -206,7 +206,7 @@ std::vector<StrategyPtr> GatherDInfo::GenerateOpStrategies(int64_t stage_id) {
if ((sp == nullptr) || sp->GetInputDim().empty()) {
MS_LOG(EXCEPTION) << name_ << ": The strategy is null or empty";
}
Strategys tmp_strategy;
Strategies tmp_strategy;
Dimensions first_input_strategy = sp->GetInputDim()[0];
for (size_t i = 0; i < inputs_shape_.size(); ++i) {
tmp_strategy.push_back(first_input_strategy);

2
mindspore/ccsrc/frontend/parallel/ops_info/gathernd_info.cc
View File

@ -139,7 +139,7 @@ std::vector<StrategyPtr> GatherNdInfo::GenerateOpStrategies(int64_t stage_id) {
if ((sp == nullptr) || sp->GetInputDim().empty()) {
MS_LOG(EXCEPTION) << name_ << ": The strategy is null or empty";
}
Strategys tmp_strategy;
Strategies tmp_strategy;
Dimensions indices_strategy = sp->GetInputDim()[0];
Dimensions input_strategy(inputs_shape_[0].size(), 1);
tmp_strategy.push_back(input_strategy);

4
mindspore/ccsrc/frontend/parallel/ops_info/get_next_info.cc
View File

@ -105,7 +105,7 @@ Status GetNextInfo::InferDevMatrixShape() {
}
Status GetNextInfo::CheckStrategy(const StrategyPtr &strategy) {
Strategys stras = strategy->GetInputDim();
Strategies stras = strategy->GetInputDim();
for (Dimensions stra : stras) {
if (stra.size() != 0) {
MS_LOG(ERROR) << name_ << " : Invalid strategy.";
@ -219,7 +219,7 @@ void GetNextInfo::InferReplaceOps() {
Status GetNextInfo::SetCostUnderStrategy(const StrategyPtr &strategy) { return SetCostUnderStrategyBase(strategy); }
std::vector<StrategyPtr> GetNextInfo::GenerateOpStrategies(int64_t stage_id) {
Strategys stra;
Strategies stra;
StrategyPtr sp = std::make_shared<Strategy>(stage_id, stra);
std::vector<StrategyPtr> sp_vector;
sp_vector.push_back(sp);

2
mindspore/ccsrc/frontend/parallel/ops_info/get_next_info.h
View File

@ -60,7 +60,7 @@ class GetNextInfo : public OperatorInfo {
int64_t output_num_ = 0;
int64_t shard_num_ = 1;
std::string shared_name_;
Strategys dataset_strategy_;
Strategies dataset_strategy_;
Shape dev_matrix_shape_origin_;
};
} // namespace parallel

2
mindspore/ccsrc/frontend/parallel/ops_info/inplace_add_info.cc
View File

@ -27,7 +27,7 @@ Status InplaceAddInfo::CheckStrategy(const StrategyPtr &strategy) {
MS_LOG(ERROR) << name_ << ": Invalid strategy";
return FAILED;
}
Strategys strategies = strategy->GetInputDim();
Strategies strategies = strategy->GetInputDim();
auto x_strategy = strategies.at(0);
auto input_v_strategy = strategies.at(1);
if (x_strategy[0] != 1 || input_v_strategy[0] != 1) {

4
mindspore/ccsrc/frontend/parallel/ops_info/iou_info.cc
View File

@ -24,7 +24,7 @@ Status IOUInfo::CheckStrategy(const StrategyPtr &strategy) {
return FAILED;
}
Strategys strategies = strategy->GetInputDim();
Strategies strategies = strategy->GetInputDim();
if (strategies[0][1] != 1 || strategies[1][1] != 1) {
MS_LOG(ERROR) << name_ << ": Only supports shard the 0th dimension of each input tensor, but got strategy "
<< StrategyToString(strategies);
@ -34,7 +34,7 @@ Status IOUInfo::CheckStrategy(const StrategyPtr &strategy) {
}
Status IOUInfo::InferDevMatrixShape() {
Strategys strategise = strategy_->GetInputDim();
Strategies strategise = strategy_->GetInputDim();
int64_t dev1 = strategise[0][0];
int64_t dev0 = strategise[1][0];

2
mindspore/ccsrc/frontend/parallel/ops_info/l2_normalize_info.cc
View File

@ -31,7 +31,7 @@ Status L2NormalizeInfo::CheckStrategy(const StrategyPtr &strategy) {
return FAILED;
}
Strategys stra = strategy->GetInputDim();
Strategies stra = strategy->GetInputDim();
Dimensions input_strategy = stra.at(0);
int64_t axis_index = axis_;
if (axis_ < 0) {

6
mindspore/ccsrc/frontend/parallel/ops_info/layer_norm_info.cc
View File

@ -61,7 +61,7 @@ Status LayerNormInfo::GetAttrs() {
Status LayerNormInfo::CheckStrategy(const StrategyPtr &strategy) {
MS_EXCEPTION_IF_NULL(strategy);
Strategys stra = strategy->GetInputDim();
Strategies stra = strategy->GetInputDim();
if (stra.size() != LAYER_NORM_INPUT_SIZE) {
MS_LOG(ERROR) << name_ << ": Invalid strategy size " << stra.size();
return FAILED;
@ -116,7 +116,7 @@ Status LayerNormInfo::InferDevMatrixShape() {
MS_LOG(ERROR) << name_ << ": The strategy is null";
return FAILED;
}
Strategys stra = strategy_->GetInputDim();
Strategies stra = strategy_->GetInputDim();
if (stra.empty()) {
MS_LOG(ERROR) << name_ << ": The strategy is empty";
return FAILED;
@ -187,7 +187,7 @@ Status LayerNormInfo::GenerateGammaAndBetaStrategies(const std::vector<StrategyP
MS_LOG(ERROR) << name_ << ": Invalid strategy";
return FAILED;
}
Strategys tmp_strategy;
Strategies tmp_strategy;
Dimensions input_strategy = sp->GetInputDim()[0];
Dimensions gamma_strategy = input_strategy;
(void)gamma_strategy.erase(gamma_strategy.begin(),

6
mindspore/ccsrc/frontend/parallel/ops_info/lin_space_info.cc
View File

@ -85,14 +85,14 @@ std::vector<StrategyPtr> LinSpaceInfo::GenerateOpStrategies(int64_t stage_id) {
return sp_vector;
}
std::shared_ptr<Strategys> LinSpaceInfo::GenerateBatchStrategies() {
std::shared_ptr<Strategies> LinSpaceInfo::GenerateBatchStrategies() {
if (InferAttrs() != SUCCESS) {
MS_LOG(EXCEPTION) << name_ << ": Infer attrs failed";
}
int64_t dev_num = g_device_manager->stage_device_num();
Strategys strategies = {Dimensions{dev_num}};
return std::make_shared<Strategys>(strategies);
Strategies strategies = {Dimensions{dev_num}};
return std::make_shared<Strategies>(strategies);
}
int64_t LinSpaceInfo::GetSplitNum() {

2
mindspore/ccsrc/frontend/parallel/ops_info/lin_space_info.h
View File

@ -38,7 +38,7 @@ class LinSpaceInfo : public OperatorInfo {
Status SetCostUnderStrategy(const StrategyPtr &strategy) override { return SetCostUnderStrategyBase(strategy); }
std::vector<StrategyPtr> GenerateOpStrategies(int64_t stage_id) override;
std::shared_ptr<Strategys> GenerateBatchStrategies() override;
std::shared_ptr<Strategies> GenerateBatchStrategies() override;
ReplaceGraphPtr replace_graph(const CNodePtr &cnode) override;
protected:

4
mindspore/ccsrc/frontend/parallel/ops_info/loss_info.cc
View File

@ -32,7 +32,7 @@ Status SoftmaxCrossEntropyWithLogitsInfo::CheckStrategy(const mindspore::paralle
return FAILED;
}
Strategys stra = strategy->GetInputDim();
Strategies stra = strategy->GetInputDim();
Dimensions input_strategy = stra.at(0);
Dimensions label_strategy = stra.at(1);
if (input_strategy != label_strategy) {
@ -69,7 +69,7 @@ Status SoftmaxCrossEntropyWithLogitsInfo::GetAttrs() {
}
Status SoftmaxCrossEntropyWithLogitsInfo::InferDevMatrixShape() {
Strategys stra = strategy_->GetInputDim();
Strategies stra = strategy_->GetInputDim();
Dimensions input_strategy = stra.at(0);
dev_matrix_shape_ = input_strategy;
return SUCCESS;

8
mindspore/ccsrc/frontend/parallel/ops_info/matmul_dds_info.cc
View File

@ -43,7 +43,7 @@ namespace parallel {
* Only bs and num_heads can be splited, thus the q[0] should at least be size_per_head,
* q[1] should at least be seq_len // 16. The strategy check can use bs/head from attrs.
*/
Status MatmulDDSInfo::CheckStrategys(const Strategys &stras) {
Status MatmulDDSInfo::CheckStrategys(const Strategies &stras) {
if (stras.size() != MATMUL_DDS_INPUTS_SIZE) {
MS_LOG(ERROR) << name_ << ": Invalid strategy. The strategys size should be 4.";
return FAILED;
@ -106,7 +106,7 @@ Status MatmulDDSInfo::CheckStrategy(const StrategyPtr &strategy) {
MS_LOG(ERROR) << name_ << ": Invalid strategy.";
return FAILED;
}
Strategys stras = strategy->GetInputDim();
Strategies stras = strategy->GetInputDim();
if (CheckStrategys(stras) != SUCCESS) {
return FAILED;
}
@ -117,7 +117,7 @@ Status MatmulDDSInfo::CheckStrategy(const StrategyPtr &strategy) {
* device matrix is extended by the strategy0.
*/
Status MatmulDDSInfo::InferDevMatrixShape() {
Strategys stra = strategy_->GetInputDim();
Strategies stra = strategy_->GetInputDim();
Dimensions input_strategy = stra.at(0);
input_strategy_ = input_strategy;
dev_matrix_shape_ = input_strategy;
@ -288,7 +288,7 @@ std::vector<StrategyPtr> MatmulDDSInfo::GenerateOpStrategies(int64_t stage_id) {
if ((sp == nullptr) || sp->GetInputDim().empty()) {
MS_LOG(EXCEPTION) << name_ << ": The strategy is null or empty";
}
Strategys tmp_strategy;
Strategies tmp_strategy;
Dimensions q_strategy = sp->GetInputDim()[0];
Dimensions k_strategy = q_strategy;
Dimensions local_mask_strategy = {1, q_strategy[0], 1, 1};

2
mindspore/ccsrc/frontend/parallel/ops_info/matmul_dds_info.h
View File

@ -50,7 +50,7 @@ class MatmulDDSInfo : public OperatorInfo {
Status GetAttrs() override;
Status InferAsLossDivisor() override { return SUCCESS; }
Status ComputeReplaceGraph(const CNodePtr &cnode);
Status CheckStrategys(const Strategys &stras);
Status CheckStrategys(const Strategies &stras);
private:
Dimensions input_strategy_;

16
mindspore/ccsrc/frontend/parallel/ops_info/matmul_info.cc
View File

@ -152,7 +152,7 @@ Status MatMul::CheckStrategy(const StrategyPtr &strategy) {
return FAILED;
}
Strategys stra = strategy->GetInputDim();
Strategies stra = strategy->GetInputDim();
Dimensions mat_a_strategy = stra.at(0);
Dimensions mat_b_strategy = stra.at(1);
@ -209,7 +209,7 @@ Status MatMul::CheckOutputStrategy(const StrategyPtr &out_strategy) {
return FAILED;
}
Strategys in_stra = strategy_->GetInputDim();
Strategies in_stra = strategy_->GetInputDim();
Dimensions x_strategy = in_stra.at(0);
Dimensions w_strategy = in_stra.at(1);
@ -222,7 +222,7 @@ Status MatMul::CheckOutputStrategy(const StrategyPtr &out_strategy) {
in_shard_c = w_strategy[1];
}
Strategys out_stra = out_strategy->GetInputDim();
Strategies out_stra = out_strategy->GetInputDim();
Dimensions output_strategy = out_stra[0];
int64_t out_shard_a_or_ab = output_strategy[0];
@ -248,7 +248,7 @@ Status MatMul::CheckOutputStrategy(const StrategyPtr &out_strategy) {
}
Status MatMulBase::InferDevMatrixShape() {
Strategys stra = strategy_->GetInputDim();
Strategies stra = strategy_->GetInputDim();
Dimensions mat_a_strategy = stra.at(0);
Dimensions mat_b_strategy = stra.at(1);
@ -460,7 +460,7 @@ std::vector<StrategyPtr> MatMulBase::GenerateOpStrategies(int64_t stage_id) {
if ((sp == nullptr) || sp->GetInputDim().empty()) {
MS_LOG(EXCEPTION) << name_ << ": The strategy is null or empty";
}
Strategys replace_strategy;
Strategies replace_strategy;
Dimensions tmp_strategy = sp->GetInputDim()[0];
Dimensions mat_a_strategy = tmp_strategy;
mat_a_strategy.pop_back();
@ -483,11 +483,11 @@ std::vector<StrategyPtr> MatMulBase::GenerateOpStrategies(int64_t stage_id) {
return sp_vector;
}
std::shared_ptr<Strategys> BatchMatMulInfo::GenerateBatchStrategies() {
std::shared_ptr<Strategies> BatchMatMulInfo::GenerateBatchStrategies() {
Dimensions batch_strategy(inputs_shape_[1].size() - 1, 1);
(void)batch_strategy.insert(batch_strategy.begin(), stage_device_size_);
Strategys strategy_v = {batch_strategy, batch_strategy};
return std::make_shared<Strategys>(strategy_v);
Strategies strategy_v = {batch_strategy, batch_strategy};
return std::make_shared<Strategies>(strategy_v);
}
Status MatMulBase::SetCostUnderStrategy(const StrategyPtr &strategy) { return SetCostUnderStrategyBase(strategy); }

2
mindspore/ccsrc/frontend/parallel/ops_info/matmul_info.h
View File

@ -86,7 +86,7 @@ class BatchMatMulInfo : public MatMul {
: MatMul(name, inputs_shape, outputs_shape, attrs) {}
~BatchMatMulInfo() override = default;
std::shared_ptr<Strategys> GenerateBatchStrategies() override;
std::shared_ptr<Strategies> GenerateBatchStrategies() override;
};
} // namespace parallel
} // namespace mindspore

8
mindspore/ccsrc/frontend/parallel/ops_info/onehot_info.cc
View File

@ -70,7 +70,7 @@ Status OneHotInfo::CheckStrategy(const StrategyPtr &strategy) {
}
Status OneHotInfo::InferDevMatrixShape() {
Strategys stra = strategy_->GetInputDim();
Strategies stra = strategy_->GetInputDim();
Dimensions input_strategy = stra.at(0);
if (axis_ == 0) {
@ -235,11 +235,11 @@ std::vector<StrategyPtr> OneHotInfo::GenerateOpStrategies(int64_t stage_id) {
Status OneHotInfo::SetCostUnderStrategy(const StrategyPtr &strategy) { return SetCostUnderStrategyBase(strategy); }
std::shared_ptr<Strategys> OneHotInfo::GenerateBatchStrategies() {
std::shared_ptr<Strategies> OneHotInfo::GenerateBatchStrategies() {
Dimensions strategy = {stage_device_size_, 1};
Dimensions empty_strategy;
Strategys strategy_v = {strategy, empty_strategy, empty_strategy};
return std::make_shared<Strategys>(strategy_v);
Strategies strategy_v = {strategy, empty_strategy, empty_strategy};
return std::make_shared<Strategies>(strategy_v);
}
Shapes OneHotInfo::InferParamStrategy(const Shapes &default_strategy) {

2
mindspore/ccsrc/frontend/parallel/ops_info/onehot_info.h
View File

@ -39,7 +39,7 @@ class OneHotInfo : public OperatorInfo {
std::vector<StrategyPtr> GenerateOpStrategies(int64_t stage_id) override;
Status SetCostUnderStrategy(const StrategyPtr &strategy) override;
ReplaceGraphPtr replace_graph(const CNodePtr &cnode) override;
std::shared_ptr<Strategys> GenerateBatchStrategies() override;
std::shared_ptr<Strategies> GenerateBatchStrategies() override;
Shapes InferParamStrategy(const Shapes &default_strategy) override;
protected:

26
mindspore/ccsrc/frontend/parallel/ops_info/operator_info.cc
View File

@ -91,7 +91,7 @@ struct OutStrategyValueRegister {
} out_regist;
} // namespace
std::string StrategyToString(const Strategys &strategy) {
std::string StrategyToString(const Strategies &strategy) {
std::string strategy_str = "";
strategy_str += "(";
for (size_t i = 0; i < strategy.size(); ++i) {
@ -130,7 +130,7 @@ Status OperatorInfo::CheckStrategyValue(const StrategyPtr &strategy, const Shape
size_t strategy_size = strategy->GetInputNumber();
size_t inputs_shape_size = inputs_shape.size();
Strategys stra = strategy->GetInputDim();
Strategies stra = strategy->GetInputDim();
if (strategy_size != inputs_shape_size) {
MS_LOG(ERROR) << name_ << ": The strategy is " << StrategyToString(stra) << ", strategy size: " << strategy_size
<< " is not equal to inputs size: " << inputs_shape_size;
@ -790,7 +790,7 @@ Shape GetSliceShape(const Shape &tensor_shape, const Dimensions &strategy) {
return slice_shape;
}
Status InferSliceShapeByStrategy(const Strategys &strategys, const Shapes &shapes, Shapes *slice_shapes) {
Status InferSliceShapeByStrategy(const Strategies &strategys, const Shapes &shapes, Shapes *slice_shapes) {
if (slice_shapes == nullptr) {
MS_LOG(ERROR) << "The slice_shapes is null.";
return FAILED;
@ -829,7 +829,7 @@ Status InferSliceShapeByStrategy(const Strategys &strategys, const Shapes &shape
return SUCCESS;
}
Status OperatorInfo::InferSliceShape(const Strategys &inputs_strategy, const Strategys &outputs_strategy,
Status OperatorInfo::InferSliceShape(const Strategies &inputs_strategy, const Strategies &outputs_strategy,
Shapes *inputs_slice_shape, Shapes *outputs_slice_shape) {
if (inputs_slice_shape == nullptr || outputs_slice_shape == nullptr) {
MS_LOG(ERROR) << name_ << ": The slice_shape is null.";
@ -1061,8 +1061,8 @@ void OperatorInfo::ReplaceSuccEdges(const std::shared_ptr<OperatorInfo> &op,
succ_edges_ = update_pre_edges;
}
std::shared_ptr<Strategys> GenerateBatchStrategiesBySplitFlag(const Shapes &shapes,
const std::vector<bool> &split_flag_list) {
std::shared_ptr<Strategies> GenerateBatchStrategiesBySplitFlag(const Shapes &shapes,
const std::vector<bool> &split_flag_list) {
if (shapes.size() != split_flag_list.size()) {
MS_LOG(ERROR) << "Split_flag_list do not have the same size as inputs shape, " << split_flag_list.size() << " : "
<< shapes.size();
@ -1070,7 +1070,7 @@ std::shared_ptr<Strategys> GenerateBatchStrategiesBySplitFlag(const Shapes &shap
}
CheckGlobalDeviceManager();
int64_t dev_num = g_device_manager->stage_device_num();
Strategys strategy_v;
Strategies strategy_v;
for (size_t i = 0; i != shapes.size(); i++) {
if (shapes[i].empty()) {
MS_LOG(INFO) << "Elements of shapes is empty.";
@ -1084,7 +1084,7 @@ std::shared_ptr<Strategys> GenerateBatchStrategiesBySplitFlag(const Shapes &shap
strategy_v.push_back(element);
}
}
return std::make_shared<Strategys>(strategy_v);
return std::make_shared<Strategies>(strategy_v);
}
void OperatorInfo::ReComputeBatchSplitFlagList() {
@ -1122,12 +1122,12 @@ Status PrepareStrategyBase(int64_t stage_id, size_t dev_num, const Shapes &input
return FAILED;
}
}
Strategys stras(inputs_partitions);
Strategies stras(inputs_partitions);
(*sp) = std::make_shared<Strategy>(stage_id, stras);
return SUCCESS;
}
std::shared_ptr<Strategys> OperatorInfo::GenerateBatchStrategies() {
std::shared_ptr<Strategies> OperatorInfo::GenerateBatchStrategies() {
if (inputs_shape_.empty() && InferAttrs() != SUCCESS) {
MS_LOG(EXCEPTION) << name_ << ": Infer attrs failed";
}
@ -1212,7 +1212,7 @@ Status GenerateStrategiesForBroadcastLeft(int64_t stage_id, const Shapes &inputs
// second, get the correct strategy for input0
for (auto &sp : *sp_vector) {
Strategys tmp_strategy;
Strategies tmp_strategy;
Dimensions input0_strategy = sp->GetInputDim()[0];
size_t size_diff = inputs_shape[1].size() - inputs_shape[0].size();
@ -1261,7 +1261,7 @@ Status GenerateStrategiesForBroadcastRight(int64_t stage_id, const Shapes &input
// second, get the correct strategy for input1
for (auto &sp : *sp_vector) {
Strategys tmp_strategy;
Strategies tmp_strategy;
tmp_strategy.push_back(sp->GetInputDim()[0]); // input0
Dimensions input1_strategy = sp->GetInputDim()[1];
@ -1503,7 +1503,7 @@ Status GenerateStrategiesForDependentInputs(int64_t stage_id, const Shapes &inpu
[stage_id, &indices_mp, &splittable_inputs](const StrategyPtr &sp) {
auto sp_strategies = sp->GetInputDim();
auto sp_sub_strategy = sp_strategies.at(0);
Strategys strategies(splittable_inputs);
Strategies strategies(splittable_inputs);
for (size_t i = 0; i < strategies.size(); ++i) {
for (size_t j = 0; j < strategies[i].size(); ++j) {
if (splittable_inputs[i][j] == 0) {

10
mindspore/ccsrc/frontend/parallel/ops_info/operator_info.h
View File

@ -97,7 +97,7 @@ class OperatorInfo {
virtual Status SetCostUnderStrategy(const StrategyPtr &strategy) = 0;
Shapes GenerateParamStrategy(const Shapes &default_strategy);
virtual std::shared_ptr<Strategys> GenerateBatchStrategies();
virtual std::shared_ptr<Strategies> GenerateBatchStrategies();
virtual void ReComputeBatchSplitFlagList();
void ComputeBatchSplitFlagList();
@ -242,7 +242,7 @@ class OperatorInfo {
// The tensor map of Outputs[0] is used by default. If there are multiple outputs, need to identify which output
// is used for grad and overload the function. If the output is a scalar, need to override the function too.
virtual Status InferAsLossDivisor();
Status InferSliceShape(const Strategys &inputs_strategy, const Strategys &outputs_strategy,
Status InferSliceShape(const Strategies &inputs_strategy, const Strategies &outputs_strategy,
Shapes *inputs_slice_shape, Shapes *outputs_slice_shape);
void BreakingTiesForPerferringDataParallel(const StrategyPtr &, const CostPtr &);
int64_t GetIntAttr(const std::string &attr_name);
@ -351,9 +351,9 @@ void AddCommOpParamFlag(const CNodePtr &comm_node);
Operator CreateGetTensorSliceOp(const TensorLayout &tensor_layout);
OperatorVector CreateMirrorOps(const std::string &group_name, size_t dev_num);
int64_t ComputeRepeatDeviceNumByTensorMap(const Shape &dev_matrix_shape, const Shape &tensor_map);
std::shared_ptr<Strategys> GenerateBatchStrategiesBySplitFlag(const Shapes &shapes,
const std::vector<bool> &split_flag_list);
std::string StrategyToString(const Strategys &strategy);
std::shared_ptr<Strategies> GenerateBatchStrategiesBySplitFlag(const Shapes &shapes,
const std::vector<bool> &split_flag_list);
std::string StrategyToString(const Strategies &strategy);
void PrintStrategy(const StrategyPtr &strategy);
Status GenerateStrategiesForIndependentInputsBase(int64_t stage_id, size_t dev_num, const Shapes &inputs_shape,
const Shapes &splittable_inputs,

2
mindspore/ccsrc/frontend/parallel/ops_info/pack_info.cc
View File

@ -150,7 +150,7 @@ std::vector<StrategyPtr> StackInfo::GenerateOpStrategies(int64_t stage_id) {
if ((sp == nullptr) || sp->GetInputDim().empty()) {
MS_LOG(EXCEPTION) << name_ << ": The strategy is null or empty";
}
Strategys tmp_strategy;
Strategies tmp_strategy;
Dimensions first_input_strategy = sp->GetInputDim()[0];
for (size_t i = 0; i < inputs_shape_.size(); ++i) {
tmp_strategy.push_back(first_input_strategy);

4
mindspore/ccsrc/frontend/parallel/ops_info/prelu_info.cc
View File

@ -37,7 +37,7 @@ Status PReLUInfo::CheckStrategy(const StrategyPtr &strategy) {
if (CheckStrategyValue(strategy, inputs_shape_) != SUCCESS) {
return FAILED;
}
Strategys stra = strategy->GetInputDim();
Strategies stra = strategy->GetInputDim();
if (stra[1].size() != PRELU_SECOND_INPUT_SIZE) {
MS_LOG(ERROR) << name_ << ": Invalid strategy size.";
return FAILED;
@ -53,7 +53,7 @@ Status PReLUInfo::CheckStrategy(const StrategyPtr &strategy) {
* device matrix is same with the strategy matrix
*/
Status PReLUInfo::InferDevMatrixShape() {
Strategys stra = strategy_->GetInputDim();
Strategies stra = strategy_->GetInputDim();
Dimensions input_strategy = stra.at(0);
input_strategy_ = input_strategy;
dev_matrix_shape_ = input_strategy;

4
mindspore/ccsrc/frontend/parallel/ops_info/random_choice_with_mask_info.cc
View File

@ -36,7 +36,7 @@ Status RandomChoiceWithMaskInfo::CheckStrategy(const StrategyPtr &strategy) {
return FAILED;
}
Strategys strategies = strategy->GetInputDim();
Strategies strategies = strategy->GetInputDim();
Dimensions input_strategy = strategies[0];
auto is_shard = [](int64_t val) -> bool { return val != 1; };
if (std::any_of(input_strategy.begin(), input_strategy.end(), is_shard)) {
@ -66,7 +66,7 @@ Status RandomChoiceWithMaskInfo::InferTensorMap() {
std::vector<StrategyPtr> RandomChoiceWithMaskInfo::GenerateOpStrategies(int64_t stage_id) {
Dimensions input_partitions(inputs_shape_[0].size(), 1);
Strategys strategies = {input_partitions};
Strategies strategies = {input_partitions};
std::vector<StrategyPtr> sp_vector;
(void)sp_vector.emplace_back(std::make_shared<Strategy>(stage_id, strategies));
return sp_vector;

2
mindspore/ccsrc/frontend/parallel/ops_info/range_info.cc
View File

@ -65,7 +65,7 @@ Status RangeInfo::CheckStrategy(const StrategyPtr &strategy) {
}
Status RangeInfo::InferDevMatrixShape() {
Strategys stra = strategy_->GetInputDim();
Strategies stra = strategy_->GetInputDim();
dev_matrix_shape_ = stra[0];
split_num_ = stra[0][0];
return SUCCESS;

22
mindspore/ccsrc/frontend/parallel/ops_info/reduce_method_info.cc
View File

@ -33,7 +33,7 @@ namespace parallel {
Status ReduceMethod::CheckStrategy(const StrategyPtr &strategy) { return CheckStrategyValue(strategy, inputs_shape_); }
Status ReduceMethod::InferDevMatrixShape() {
Strategys stra = strategy_->GetInputDim();
Strategies stra = strategy_->GetInputDim();
Dimensions input_strategy = stra.at(0);
dev_matrix_shape_ = input_strategy;
@ -400,10 +400,10 @@ Status ReduceMethod::InferTensorInfo() {
// infer slice shape
Shapes inputs_slice_shape, outputs_slice_shape;
Strategys inputs_strategy = strategy_->GetInputDim();
Strategies inputs_strategy = strategy_->GetInputDim();
Dimensions output_strategy = InferOutputStrategy();
Strategys outputs_strategy = {output_strategy};
Strategies outputs_strategy = {output_strategy};
if (InferSliceShape(inputs_strategy, outputs_strategy, &inputs_slice_shape, &outputs_slice_shape) != SUCCESS) {
return FAILED;
}
@ -478,7 +478,7 @@ Status ArgMaxWithValueInfo::CheckStrategy(const StrategyPtr &strategy) {
std::vector<int64_t> dim_list = reduce_dim();
MS_ASSERT(dim_list.size() == 1);
Strategys stra = strategy->GetInputDim();
Strategies stra = strategy->GetInputDim();
MS_ASSERT(stra.size() == 1);
Shape input_strategy = stra.at(0);
MS_ASSERT(dim_list.at(0) < input_strategy.size());
@ -510,10 +510,10 @@ Status ArgMaxWithValueInfo::InferTensorInfo() {
// infer slice shape
Shapes inputs_slice_shape, outputs_slice_shape;
Strategys inputs_strategy = strategy_->GetInputDim();
Strategies inputs_strategy = strategy_->GetInputDim();
Dimensions output_strategy = InferOutputStrategy();
Strategys outputs_strategy = {output_strategy, output_strategy};
Strategies outputs_strategy = {output_strategy, output_strategy};
if (InferSliceShape(inputs_strategy, outputs_strategy, &inputs_slice_shape, &outputs_slice_shape) != SUCCESS) {
return FAILED;
}
@ -627,7 +627,7 @@ Status ArgmaxInfo::CheckStrategy(const StrategyPtr &strategy) {
std::vector<int64_t> dim_list = reduce_dim();
MS_ASSERT(dim_list.size() == 1);
Strategys stra = strategy->GetInputDim();
Strategies stra = strategy->GetInputDim();
MS_ASSERT(stra.size() == 1);
Shape input_strategy = stra.at(0);
MS_ASSERT(dim_list.at(0) < input_strategy.size());
@ -689,7 +689,7 @@ Status SquareSumAllInfo::CheckStrategy(const StrategyPtr &strategy) {
return FAILED;
}
Strategys stra = strategy->GetInputDim();
Strategies stra = strategy->GetInputDim();
Dimensions sub_a_strategy = stra.at(0);
Dimensions sub_b_strategy = stra.at(1);
Shape input_a_shape = inputs_shape_.at(0);
@ -707,7 +707,7 @@ Status SquareSumAllInfo::CheckStrategy(const StrategyPtr &strategy) {
}
Status SquareSumAllInfo::InferDevMatrixShape() {
Strategys strategy = strategy_->GetInputDim();
Strategies strategy = strategy_->GetInputDim();
Dimensions sub_a_strategy = strategy.at(0);
Shape dev_shape;
for (size_t i = 0; i < sub_a_strategy.size(); ++i) {
@ -736,10 +736,10 @@ Status SquareSumAllInfo::InferTensorInfo() {
// infer slice shape
Shapes inputs_slice_shape, outputs_slice_shape;
Strategys inputs_strategy = strategy_->GetInputDim();
Strategies inputs_strategy = strategy_->GetInputDim();
Dimensions output_strategy = InferOutputStrategy();
Strategys outputs_strategy = {output_strategy, output_strategy};
Strategies outputs_strategy = {output_strategy, output_strategy};
if (InferSliceShape(inputs_strategy, outputs_strategy, &inputs_slice_shape, &outputs_slice_shape) != SUCCESS) {
return FAILED;
}

4
mindspore/ccsrc/frontend/parallel/ops_info/reluv2_info.cc
View File

@ -38,7 +38,7 @@ Status ReLUV2Info::CheckStrategy(const StrategyPtr &strategy) {
return FAILED;
}
Strategys stra = strategy->GetInputDim();
Strategies stra = strategy->GetInputDim();
Dimensions input_strategy = stra.at(0);
if (input_strategy[1] != 1) {
MS_LOG(ERROR) << name_ << "The second dimension is not splitable.";
@ -65,7 +65,7 @@ std::vector<StrategyPtr> ReLUV2Info::GenerateOpStrategies(int64_t stage_id) {
}
Status ReLUV2Info::InferDevMatrixShape() {
Strategys stra = strategy_->GetInputDim();
Strategies stra = strategy_->GetInputDim();
Dimensions input_strategy = stra.at(0);
dev_matrix_shape_ = input_strategy;

12
mindspore/ccsrc/frontend/parallel/ops_info/reshape_info.cc
View File

@ -37,7 +37,7 @@ Status ReshapeInfo::CheckStrategy(const StrategyPtr &strategy) { return CheckStr
* only support batch parallel reshape operator in ReID (batch parallel degree can be smaller than device number)
*/
Status ReshapeInfo::InferDevMatrixShape() {
Strategys stra = strategy_->GetInputDim();
Strategies stra = strategy_->GetInputDim();
input_strategy_ = stra.at(0);
dev_matrix_shape_ = stra.at(0);
return SUCCESS;
@ -195,8 +195,8 @@ Status ReshapeInfo::InferTensorMap() {
* the output tensor strategy is the same as input tensor strategy
* only support batch parallel reshape operator in ReID (batch parallel degree can be smaller than device number)
*/
Strategys ReshapeInfo::GetOutputsStrategy() {
Strategys outputs_strategy;
Strategies ReshapeInfo::GetOutputsStrategy() {
Strategies outputs_strategy;
Dimensions strategy;
for (size_t j = 0; j < outputs_shape_[0].size(); ++j) {
strategy.push_back(1);
@ -269,8 +269,8 @@ Status ReshapeInfo::InferTensorInfo() {
}
Shapes inputs_slice_shape, outputs_slice_shape;
Strategys inputs_strategy = strategy_->GetInputDim();
Strategys outputs_strategy = GetOutputsStrategy();
Strategies inputs_strategy = strategy_->GetInputDim();
Strategies outputs_strategy = GetOutputsStrategy();
if (InferSliceShape(inputs_strategy, outputs_strategy, &inputs_slice_shape, &outputs_slice_shape) != SUCCESS) {
return FAILED;
}
@ -460,7 +460,7 @@ Status ReshapeInfo::GenerateStrategyCosts(const std::vector<std::shared_ptr<Stra
MS_LOG(ERROR) << "Infer strategy by tensor_info failed";
return FAILED;
}
Strategys stra_inputs = {stra};
Strategies stra_inputs = {stra};
StrategyPtr reshape_stra = std::make_shared<Strategy>(pre_stra_cost->strategy_ptr->GetInputStage(), stra_inputs);
if (is_next_reshape) {
SetOutputLayout(pre_out_tensor_info.tensor_layout());

2
mindspore/ccsrc/frontend/parallel/ops_info/reshape_info.h
View File

@ -87,7 +87,7 @@ class ReshapeInfo : public OperatorInfo {
Status InferDevMatrixShape() override;
Status InferTensorLayout(TensorLayouts *inputs_layout, TensorLayouts *outputs_layout);
Status GetAttrs() override;
Strategys GetOutputsStrategy();
Strategies GetOutputsStrategy();
private:
Status GetParameterInput();

2
mindspore/ccsrc/frontend/parallel/ops_info/roi_align_info.cc
View File

@ -40,7 +40,7 @@ Status ROIAlignInfo::CheckStrategy(const StrategyPtr &strategy) {
return FAILED;
}
Strategys strategies = strategy->GetInputDim();
Strategies strategies = strategy->GetInputDim();
auto features_strategy = strategies.at(0);
auto rois_strategy = strategies.at(1);
if (features_strategy[2] != 1 || features_strategy[3] != 1) {

2
mindspore/ccsrc/frontend/parallel/ops_info/scatter_update_info.cc
View File

@ -158,7 +158,7 @@ std::vector<StrategyPtr> ScatterUpdateInfo::GenerateOpStrategies(int64_t stage_i
if ((sp == nullptr) || sp->GetInputDim().empty()) {
MS_LOG(EXCEPTION) << name_ << ": The strategy is null or empty";
}
Strategys tmp_strategy;
Strategies tmp_strategy;
Dimensions first_input_strategy = sp->GetInputDim()[0];
Dimensions indices_strategy(inputs_shape_[1].size(), 1);
// updates_strategy = indices_strategy + input_strategy[1:]

2
mindspore/ccsrc/frontend/parallel/ops_info/select_info.cc
View File

@ -115,7 +115,7 @@ std::vector<StrategyPtr> SelectInfo::GenerateOpStrategies(int64_t stage_id) {
if ((sp == nullptr) || sp->GetInputDim().empty()) {
MS_LOG(EXCEPTION) << name_ << ": The strategy is null or empty";
}
Strategys tmp_strategy;
Strategies tmp_strategy;
Dimensions first_input_strategy = sp->GetInputDim()[0];
for (size_t i = 0; i < inputs_shape_.size(); ++i) {
tmp_strategy.push_back(first_input_strategy);

2
mindspore/ccsrc/frontend/parallel/ops_info/slice_info.cc
View File

@ -149,7 +149,7 @@ Status SliceInfo::InferMirrorOps() {
}
// Note: if the batch dimension is not fully fetched, the batch strategy may not work.
std::shared_ptr<Strategys> SliceInfo::GenerateBatchStrategies() {
std::shared_ptr<Strategies> SliceInfo::GenerateBatchStrategies() {
split_flag_list_ = {true};
return GenerateBatchStrategiesBySplitFlag(inputs_shape_, split_flag_list_);
}

2
mindspore/ccsrc/frontend/parallel/ops_info/slice_info.h
View File

@ -40,7 +40,7 @@ class SliceInfo : public OperatorInfo {
std::vector<StrategyPtr> GenerateOpStrategies(int64_t) override;
Status SetCostUnderStrategy(const StrategyPtr &) override;
std::shared_ptr<Strategys> GenerateBatchStrategies() override;
std::shared_ptr<Strategies> GenerateBatchStrategies() override;
protected:
Status GetAttrs() override;

6
mindspore/ccsrc/frontend/parallel/ops_info/split_info.cc
View File

@ -144,7 +144,7 @@ std::vector<StrategyPtr> SplitInfo::GenerateOpStrategies(int64_t stage_id) {
return sp_vector;
}
std::shared_ptr<Strategys> SplitInfo::GenerateBatchStrategies() {
std::shared_ptr<Strategies> SplitInfo::GenerateBatchStrategies() {
if (GetAttrs() != SUCCESS) {
MS_LOG(EXCEPTION) << name_ << ": Get attr failed";
}
@ -157,8 +157,8 @@ std::shared_ptr<Strategys> SplitInfo::GenerateBatchStrategies() {
input_strategy[0] = stage_device_size_;
}
}
Strategys strategy_v = {input_strategy};
return std::make_shared<Strategys>(strategy_v);
Strategies strategy_v = {input_strategy};
return std::make_shared<Strategies>(strategy_v);
}
Status SplitInfo::InferAsLossDivisor() {

2
mindspore/ccsrc/frontend/parallel/ops_info/split_info.h
View File

@ -36,7 +36,7 @@ class SplitInfo : public OperatorInfo {
~SplitInfo() override = default;
std::vector<StrategyPtr> GenerateOpStrategies(int64_t) override;
std::shared_ptr<Strategys> GenerateBatchStrategies() override;
std::shared_ptr<Strategies> GenerateBatchStrategies() override;
Status SetCostUnderStrategy(const StrategyPtr &) override;
protected:

2
mindspore/ccsrc/frontend/parallel/ops_info/strided_slice_info.cc
View File

@ -249,7 +249,7 @@ Status StridedSliceInfo::InferMirrorOps() {
}
// Note: if the batch dimension is not fully fetched, the batch strategy may not work.
std::shared_ptr<Strategys> StridedSliceInfo::GenerateBatchStrategies() {
std::shared_ptr<Strategies> StridedSliceInfo::GenerateBatchStrategies() {
split_flag_list_ = {true};
return GenerateBatchStrategiesBySplitFlag(inputs_shape_, split_flag_list_);
}

2
mindspore/ccsrc/frontend/parallel/ops_info/strided_slice_info.h
View File

@ -39,7 +39,7 @@ class StridedSliceInfo : public OperatorInfo {
std::vector<StrategyPtr> GenerateOpStrategies(int64_t) override;
Status SetCostUnderStrategy(const StrategyPtr &) override;
std::shared_ptr<Strategys> GenerateBatchStrategies() override;
std::shared_ptr<Strategies> GenerateBatchStrategies() override;
void ComputeBeginMask(int64_t begin_mask_);
void ComputeEndMask(int64_t end_mask_);
void ComputeEllipsisMask(int64_t ellipsis_mask_);

10
mindspore/ccsrc/frontend/parallel/ops_info/tensordot_info.cc
View File

@ -117,7 +117,7 @@ Status TensorDotInfo::CheckStrategy(const StrategyPtr &strategy) {
return FAILED;
}
Strategys stra = strategy->GetInputDim();
Strategies stra = strategy->GetInputDim();
if (stra.size() != 2) {
MS_LOG(ERROR) << name_ << ": Invalid strategy size " << stra.size();
return FAILED;
@ -148,7 +148,7 @@ Status TensorDotInfo::CheckStrategy(const StrategyPtr &strategy) {
}
Status TensorDotInfo::InferDevMatrixShape() {
Strategys stra = strategy_->GetInputDim();
Strategies stra = strategy_->GetInputDim();
Dimensions input_a_strategy = stra.at(0);
Dimensions input_b_strategy = stra.at(1);
@ -306,7 +306,7 @@ Status TensorDotInfo::InferTensorMap() {
return SUCCESS;
}
std::shared_ptr<Strategys> TensorDotInfo::GenerateBatchStrategies() {
std::shared_ptr<Strategies> TensorDotInfo::GenerateBatchStrategies() {
if (GetAttrs() != SUCCESS) {
MS_LOG(EXCEPTION) << name_ << ": Get attr failed";
}
@ -339,8 +339,8 @@ std::shared_ptr<Strategys> TensorDotInfo::GenerateBatchStrategies() {
MS_LOG(EXCEPTION) << name_ << ": Now do not support TUPLE_TYPE";
}
Strategys strategy = {input_a_strategy, input_b_strategy};
return std::make_shared<Strategys>(strategy);
Strategies strategy = {input_a_strategy, input_b_strategy};
return std::make_shared<Strategies>(strategy);
}
std::vector<StrategyPtr> TensorDotInfo::GenerateOpStrategies(int64_t) {

2
mindspore/ccsrc/frontend/parallel/ops_info/tensordot_info.h
View File

@ -45,7 +45,7 @@ class TensorDotInfo : public OperatorInfo {
~TensorDotInfo() override = default;
std::vector<StrategyPtr> GenerateOpStrategies(int64_t stage_id) override;
std::shared_ptr<Strategys> GenerateBatchStrategies() override;
std::shared_ptr<Strategies> GenerateBatchStrategies() override;
Status SetCostUnderStrategy(const StrategyPtr &strategy) override;
Status PrepareStrategy(int32_t stage_id, size_t dev_num, Dimensions combined_partitions, size_t input0_shape_size,
size_t input1_shape_size, StrategyPtr *sp);

2
mindspore/ccsrc/frontend/parallel/ops_info/tile_info.cc
View File

@ -179,7 +179,7 @@ void TileInfo::UpdateMultiples() {
void TileInfo::ReplaceNodeInputOrAttrs() { UpdateMultiples(); }
std::shared_ptr<Strategys> TileInfo::GenerateBatchStrategies() {
std::shared_ptr<Strategies> TileInfo::GenerateBatchStrategies() {
if (InferAttrs() != SUCCESS) {
MS_LOG(EXCEPTION) << name_ << ": Infer attrs failed";
}

2
mindspore/ccsrc/frontend/parallel/ops_info/tile_info.h
View File

@ -39,7 +39,7 @@ class TileInfo : public OperatorInfo {
std::vector<StrategyPtr> GenerateOpStrategies(int64_t) override;
Status SetCostUnderStrategy(const StrategyPtr &) override;
std::shared_ptr<Strategys> GenerateBatchStrategies() override;
std::shared_ptr<Strategies> GenerateBatchStrategies() override;
void UpdateMultiples();
void ReplaceNodeInputOrAttrs() override;

2
mindspore/ccsrc/frontend/parallel/ops_info/tmp_identity_info.cc
View File

@ -29,7 +29,7 @@ Status TmpIdentityInfo::CheckStrategy(const mindspore::parallel::StrategyPtr &st
}
Status TmpIdentityInfo::InferDevMatrixShape() {
Strategys stra = strategy_->GetInputDim();
Strategies stra = strategy_->GetInputDim();
Dimensions input_strategy = stra.at(0);
dev_matrix_shape_ = input_strategy;
return SUCCESS;

2
mindspore/ccsrc/frontend/parallel/ops_info/transpose_info.cc
View File

@ -30,7 +30,7 @@ namespace parallel {
Status TransposeInfo::CheckStrategy(const StrategyPtr &strategy) { return CheckStrategyValue(strategy, inputs_shape_); }
Status TransposeInfo::InferDevMatrixShape() {
Strategys stra = strategy_->GetInputDim();
Strategies stra = strategy_->GetInputDim();
input_strategy_ = stra.at(0);
for (auto &iter : input_strategy_) {
dev_matrix_shape_.push_back(iter);

6
mindspore/ccsrc/frontend/parallel/ops_info/uniform_candidate_sampler_info.cc
View File

@ -171,14 +171,14 @@ std::vector<StrategyPtr> UniformCandidateSamplerInfo::GenerateOpStrategies(int64
return sp_vector;
}
std::shared_ptr<Strategys> UniformCandidateSamplerInfo::GenerateBatchStrategies() {
std::shared_ptr<Strategies> UniformCandidateSamplerInfo::GenerateBatchStrategies() {
if (GetAttrs() != SUCCESS) {
MS_LOG(EXCEPTION) << name_ << ": Get attr failed";
}
CheckGlobalDeviceManager();
Dimensions input_strategy(inputs_shape_[0].size(), 1);
Strategys strategy_v = {input_strategy};
return std::make_shared<Strategys>(strategy_v);
Strategies strategy_v = {input_strategy};
return std::make_shared<Strategies>(strategy_v);
}
ReplaceGraphPtr UniformCandidateSamplerInfo::replace_graph(const CNodePtr &cnode) {

2
mindspore/ccsrc/frontend/parallel/ops_info/uniform_candidate_sampler_info.h
View File

@ -44,7 +44,7 @@ class UniformCandidateSamplerInfo : public OperatorInfo {
~UniformCandidateSamplerInfo() override = default;
std::vector<StrategyPtr> GenerateOpStrategies(int64_t) override;
std::shared_ptr<Strategys> GenerateBatchStrategies() override;
std::shared_ptr<Strategies> GenerateBatchStrategies() override;
Status SetCostUnderStrategy(const StrategyPtr &) override;
Status InferAsLossDivisor() override;
ReplaceGraphPtr replace_graph(const CNodePtr &cnode) override;

2
mindspore/ccsrc/frontend/parallel/ops_info/unique_info.cc
View File

@ -60,7 +60,7 @@ Status UniqueInfo::InferDevMatrixShape() {
}
Status UniqueInfo::CheckStrategy(const StrategyPtr &strategy) {
Strategys stras = strategy->GetInputDim();
Strategies stras = strategy->GetInputDim();
if (CheckStrategyValue(strategy, inputs_shape_) != SUCCESS) {
return FAILED;
}

12
mindspore/ccsrc/frontend/parallel/ops_info/unsorted_segment_op_info.cc
View File

@ -73,7 +73,7 @@ Status UnsortedSegmentOpInfo::CheckStrategy(const StrategyPtr &strategy) {
if (CheckStrategyValue(strategy, {inputs_shape_.at(0), inputs_shape_.at(1)}) != SUCCESS) {
return FAILED;
}
Strategys stra = strategy->GetInputDim();
Strategies stra = strategy->GetInputDim();
Dimensions sub_a_strategy = stra.at(0);
Dimensions sub_b_strategy = stra.at(1);
Shape input_a_shape = inputs_shape_.at(0);
@ -91,7 +91,7 @@ Status UnsortedSegmentOpInfo::CheckStrategy(const StrategyPtr &strategy) {
}
Status UnsortedSegmentOpInfo::InferDevMatrixShape() {
Strategys stra = strategy_->GetInputDim();
Strategies stra = strategy_->GetInputDim();
dev_matrix_shape_ = stra.at(0);
return SUCCESS;
}
@ -173,7 +173,7 @@ std::vector<StrategyPtr> UnsortedSegmentOpInfo::GenerateOpStrategies(int64_t sta
MS_LOG(EXCEPTION) << name_ << " : Generate strategies for independent inputs() failed.";
}
for (auto &sp : sp_vector) {
Strategys tmp_strategy;
Strategies tmp_strategy;
Dimensions first_input_strategy = sp->GetInputDim()[0];
Dimensions second_input_strategy;
for (size_t i = 0; i < inputs_shape_[1].size(); ++i) {
@ -214,7 +214,7 @@ Status UnsortedSegmentOpInfo::SetCostUnderStrategy(const StrategyPtr &strategy)
return SetCostUnderStrategyBase(strategy);
}
std::shared_ptr<Strategys> UnsortedSegmentOpInfo::GenerateBatchStrategies() {
std::shared_ptr<Strategies> UnsortedSegmentOpInfo::GenerateBatchStrategies() {
if (inputs_shape_.size() != UNSORTEDSEGMENTOP_INPUTS_SIZE) {
MS_LOG(EXCEPTION) << name_ << ": inputs shape size must be " << UNSORTEDSEGMENTOP_INPUTS_SIZE << ", but is "
<< inputs_shape_.size();
@ -233,8 +233,8 @@ std::shared_ptr<Strategys> UnsortedSegmentOpInfo::GenerateBatchStrategies() {
for (size_t i = 1; i < inputs_shape_[1].size(); i++) {
strategy_b.push_back(1);
}
Strategys strategy_v = {strategy_a, strategy_b};
return std::make_shared<Strategys>(strategy_v);
Strategies strategy_v = {strategy_a, strategy_b};
return std::make_shared<Strategies>(strategy_v);
}
// When the index is splited, the graph should be replaced

2
mindspore/ccsrc/frontend/parallel/ops_info/unsorted_segment_op_info.h
View File

@ -47,7 +47,7 @@ class UnsortedSegmentOpInfo : public OperatorInfo {
std::vector<StrategyPtr> GenerateOpStrategies(int64_t stage_id) override;
Status SetCostUnderStrategy(const StrategyPtr &strategy) override;
std::shared_ptr<Strategys> GenerateBatchStrategies() override;
std::shared_ptr<Strategies> GenerateBatchStrategies() override;
protected:
std::string reduce_method_;

6
mindspore/ccsrc/frontend/parallel/ops_info/virtual_dataset_info.cc
View File

@ -35,7 +35,7 @@ Status VirtualDatasetInfo::CheckStrategy(const StrategyPtr &strategy) {
return FAILED;
}
Strategys stra = strategy->GetInputDim();
Strategies stra = strategy->GetInputDim();
if (stra.size() < 1) {
MS_LOG(ERROR) << name_ << ": Strategy size must be larger than 1.";
return FAILED;
@ -84,7 +84,7 @@ Status VirtualDatasetInfo::CheckStrategy(const StrategyPtr &strategy) {
}
Status VirtualDatasetInfo::InferDevMatrixShape() {
Strategys stra = strategy_->GetInputDim();
Strategies stra = strategy_->GetInputDim();
dev_matrix_shape_ = stra[max_size_strategy_dim_];
return SUCCESS;
}
@ -162,7 +162,7 @@ Status VirtualDatasetInfo::SetCostUnderStrategy(const StrategyPtr &strategy) {
std::vector<StrategyPtr> VirtualDatasetInfo::GenerateOpStrategies(int64_t stage_id) {
MS_EXCEPTION_IF_NULL(ParallelContext::GetInstance());
StrategyPtr sp;
Strategys strategy;
Strategies strategy;
if (!ParallelContext::GetInstance()->dataset_strategy().empty()) {
strategy = ParallelContext::GetInstance()->dataset_strategy();
} else {

6
mindspore/ccsrc/frontend/parallel/ops_info/virtual_output_info.cc
View File

@ -33,9 +33,9 @@ Status VirtualOutputInfo::CheckStrategy(const StrategyPtr &strategy) {
return FAILED;
}
Strategys stra = strategy->GetInputDim();
Strategies stra = strategy->GetInputDim();
if (stra.size() != 1) {
MS_LOG(ERROR) << name_ << ": Strategys size must be 1.";
MS_LOG(ERROR) << name_ << ": Strategies size must be 1.";
return FAILED;
}
Dimensions strategy_first = stra.at(0);
@ -53,7 +53,7 @@ Status VirtualOutputInfo::CheckStrategy(const StrategyPtr &strategy) {
std::vector<StrategyPtr> VirtualOutputInfo::GenerateOpStrategies(int64_t stage_id) {
StrategyPtr sp;
Strategys strategy;
Strategies strategy;
bool full_batch = ParallelContext::GetInstance()->full_batch();
size_t total_dev_num;
if (full_batch) {

4
mindspore/ccsrc/frontend/parallel/step_parallel.cc
View File

@ -1250,7 +1250,7 @@ StrategyPtr ExtractStrategy(const ValuePtr &stra) {
MS_LOG(INFO) << "Extract information: strategy " << stra->ToString();
if (var->size() > 0) {
std::vector<ValuePtr> elements = var->value();
Strategys strategy;
Strategies strategy;
for (uint64_t index = 0; index < elements.size(); ++index) {
Dimensions dim;
if (elements[index]->isa<ValueSequence>()) {
@ -1725,7 +1725,7 @@ StrategyPtr GenerateBatchParallelStrategy(const OperatorInfoPtr operator_, const
MS_EXCEPTION_IF_NULL(operator_);
MS_EXCEPTION_IF_NULL(prim);
StrategyPtr strategyPtr;
std::shared_ptr<Strategys> strategy_v_ptr = operator_->GenerateBatchStrategies();
std::shared_ptr<Strategies> strategy_v_ptr = operator_->GenerateBatchStrategies();
MS_EXCEPTION_IF_NULL(strategy_v_ptr);
strategyPtr = NewStrategy(0, *strategy_v_ptr);
std::vector<ValuePtr> elements;

12
mindspore/ccsrc/frontend/parallel/strategy.h
View File

@ -31,13 +31,13 @@ namespace parallel {
#define MIN_SLICE_NUM 1
using Dimensions = Shape;
using Strategys = std::vector<Dimensions>;
using Strategies = std::vector<Dimensions>;
class Strategy;
using StrategyPtr = std::shared_ptr<Strategy>;
class Strategy {
public:
Strategy(int64_t stage, Strategys inputs)
Strategy(int64_t stage, Strategies inputs)
: stage_(stage), inputs_(std::move(inputs)), internal_size_(0), internal_stragies_() {}
Strategy(const Strategy &another_stra) : stage_(another_stra.GetInputStage()) {
@ -52,14 +52,14 @@ class Strategy {
~Strategy() = default;
size_t GetInputNumber() const { return inputs_.size(); }
Strategys GetInputDim() const { return inputs_; }
Strategies GetInputDim() const { return inputs_; }
int64_t GetInputStage() const { return stage_; }
void ExpandInputDimFromOneToTwo() {
if (inputs_.size() == 1) {
inputs_.push_back(inputs_[0]);
}
}
void ResetInputs(const Strategys &input) { inputs_ = input; }
void ResetInputs(const Strategies &input) { inputs_ = input; }
std::vector<StrategyPtr> GetInternalStrategies() const { return internal_stragies_; }
size_t GetInternalSize() const { return internal_size_; }
@ -103,12 +103,12 @@ class Strategy {
const int64_t stage_;
// The size of Dimensions must be equal to inputs_ tensor dimension.
Strategys inputs_;
Strategies inputs_;
size_t internal_size_ = 0;
std::vector<StrategyPtr> internal_stragies_;
};
inline StrategyPtr NewStrategy(const int64_t stage, const Strategys &inputs) {
inline StrategyPtr NewStrategy(const int64_t stage, const Strategies &inputs) {
return std::make_shared<Strategy>(stage, inputs);
}
} // namespace parallel

2
mindspore/ccsrc/frontend/parallel/strategy_checkpoint/parallel_strategy_checkpoint.cc
View File

@ -123,7 +123,7 @@ Status StrategyCheckpoint::Load(StrategyMap *strategy_map) {
straspb::ParallelStrategys parallel_strategys = parallel_strategy_item.parallel_strategys();
auto stage = (int64_t)parallel_strategys.stage();
size_t strategys_num = LongToSize(parallel_strategys.parallel_strategy_size());
Strategys strategy_inputs;
Strategies strategy_inputs;
for (size_t j = 0; j < strategys_num; j++) {
straspb::ParallelStrategy parallel_strategy = parallel_strategys.parallel_strategy(SizeToInt(j));
Dimensions dimension;

2
mindspore/ccsrc/pipeline/jit/pipeline.cc
View File

@ -523,7 +523,7 @@ py::list GraphExecutorPy::GetParallelParameterNameList(const std::string &phase)
return mindspore::parallel::GetParallelParameterNameListFromGraph(graph);
}
void GraphExecutorPy::SetCNodeStrategy(const std::string &name, const parallel::Strategys &strategy) {
void GraphExecutorPy::SetCNodeStrategy(const std::string &name, const parallel::Strategies &strategy) {
MS_LOG(DEBUG) << "SetCNodeStrategy!";
stra_dict_[phase_][py::str(name)] = strategy;
}

2
mindspore/ccsrc/pipeline/jit/pipeline.h
View File

@ -108,7 +108,7 @@ class GraphExecutorPy : public std::enable_shared_from_this<GraphExecutorPy> {
py::dict GetParallelGraphInfo(const std::string &phase);
py::dict GetCNodeStrategy(const std::string &phase);
py::list GetParallelParameterNameList(const std::string &phase);
void SetCNodeStrategy(const std::string &name, const parallel::Strategys &strategy);
void SetCNodeStrategy(const std::string &name, const parallel::Strategies &strategy);
size_t GetNumOpsInfo(const std::string &phase);
void SetNumOpsInfo(size_t);
py::dict GetAllreduceFusion(const std::string &phase);

6
mindspore/lite/tools/optimizer/parallel/conv2d_info.cc
View File

@ -40,7 +40,7 @@ constexpr auto kAnfConvWeight = 2;
constexpr auto kAnfConvBias = 3;
int Conv2DInfo::CheckStrategy(const SplitStrategy &strategy) {
int split_count = 0;
Strategys strategys = strategy.strategys;
Strategies strategys = strategy.strategys;
MS_CHECK_GE(strategys.size(), kInputSizeTwo, RET_ERROR);
MS_CHECK_GE(strategys[0].size(), kInputSizeFour, RET_ERROR);
MS_CHECK_GE(strategys[1].size(), kInputSizeFour, RET_ERROR);
@ -281,7 +281,7 @@ std::shared_ptr<ops::Conv2DFusion> Conv2DInfo::GetNewConvPrimitive(const api::Sh
prim->set_pad_list(conv_prim->get_pad_list());
prim->set_stride(conv_prim->get_stride());
prim->set_activation_type(conv_prim->get_activation_type());
Strategys strategys = strategy_.strategys;
Strategies strategys = strategy_.strategys;
size_t dev_num = strategy_.dev_num;
switch (split_mode_) {
case SplitH: {
@ -327,7 +327,7 @@ int Conv2DInfo::ConstructOutputCNodes(const api::SharedPtr<ops::Conv2DFusion> &c
const std::vector<AnfNodePtr> &kernel_split_outputs,
const std::vector<AnfNodePtr> &bias_split_outputs) {
MS_ASSERT(conv_prim != nullptr);
Strategys strategys = strategy_.strategys;
Strategies strategys = strategy_.strategys;
size_t dev_num = strategy_.dev_num;
int cin_strategy_sum = std::accumulate(strategys[0][kAxisCIn].begin(), strategys[0][kAxisCIn].end(), 0);
int cout_strategy_sum = std::accumulate(strategys[1][kAxisCOut].begin(), strategys[1][kAxisCOut].end(), 0);

2
mindspore/lite/tools/optimizer/parallel/depthwise_conv2d_info.cc
View File

@ -131,7 +131,7 @@ int DepthwiseConv2DInfo::CheckStrategy(const SplitStrategy &strategy) {
// for depthwise conv2d, we only split channel && include split feature map, weight && bias
// so just get the ratio from strategy
int split_count = 0;
Strategys strategys = strategy.strategys;
Strategies strategys = strategy.strategys;
MS_CHECK_GE(strategys.size(), kInputSizeTwo, RET_ERROR);
MS_CHECK_GE(strategys[0].size(), kInputSizeFour, RET_ERROR);
MS_CHECK_GE(strategys[1].size(), kInputSizeFour, RET_ERROR);

2
mindspore/lite/tools/optimizer/parallel/split_strategy.cc
View File

@ -76,7 +76,7 @@ std::unordered_map<std::string, opt::SplitStrategy> ParserSplitStrategy(const st
default:
return split_strategys;
}
opt::Strategys strategys = {split_feature_map, split_weight};
opt::Strategies strategys = {split_feature_map, split_weight};
for (const auto &supported_parallel_op : kParallelOpNames) {
split_strategys[supported_parallel_op.second] = {strategys, kSplitDevTypes, kSplitDevTypes.size(), split_mode};
}

4
mindspore/lite/tools/optimizer/parallel/split_strategy.h
View File

@ -37,7 +37,7 @@ const std::vector<int64_t> kSplitDefaultRatio = {0, 0};
// user's device to split, only split to cpu && gpu, no support npu
const std::vector<std::string> kSplitDevTypes = {"cpu", "gpu"};
using Strategys = std::vector<std::vector<std::vector<int64_t>>>;
using Strategies = std::vector<std::vector<std::vector<int64_t>>>;
constexpr auto kDeviceTypeNone = -1;
// strategy format is NHWC-KHWC
@ -71,7 +71,7 @@ enum SplitMode {
};
struct SplitStrategy {
Strategys strategys{};
Strategies strategys{};
std::vector<std::string> dev_types{};
size_t dev_num{0};
SplitMode split_mode_{NoSplit};

16
tests/ut/cpp/parallel/ops_info/activation_info_test.cc
View File

@ -64,7 +64,7 @@ void TestActivationInfo::SetUp() {
}
TEST_F(TestActivationInfo, InferDevMatrixShape1) {
Strategys inputs = {{2, 4, 8, 16}};
Strategies inputs = {{2, 4, 8, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
activation->Init(strategy, nullptr);
@ -75,7 +75,7 @@ TEST_F(TestActivationInfo, InferDevMatrixShape1) {
}
TEST_F(TestActivationInfo, InferSliceShape1) {
Strategys str = {{2, 4, 8, 16}};
Strategies str = {{2, 4, 8, 16}};
StrategyPtr strategy = NewStrategy(0, str);
activation->Init(strategy, nullptr);
@ -96,7 +96,7 @@ TEST_F(TestActivationInfo, InferSliceShape1) {
}
TEST_F(TestActivationInfo, GetTensorLayout1) {
Strategys str = {{2, 4, 8, 16}};
Strategies str = {{2, 4, 8, 16}};
StrategyPtr strategy = NewStrategy(0, str);
activation->Init(strategy, nullptr);
@ -117,7 +117,7 @@ TEST_F(TestActivationInfo, GetTensorLayout1) {
}
TEST_F(TestActivationInfo, GetForwardOp1) {
Strategys inputs = {{2, 4, 8, 16}};
Strategies inputs = {{2, 4, 8, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
activation->Init(strategy, nullptr);
@ -128,7 +128,7 @@ TEST_F(TestActivationInfo, GetForwardOp1) {
}
TEST_F(TestActivationInfo, GetMirrorOPs1) {
Strategys inputs = {{1, 4, 8, 16}};
Strategies inputs = {{1, 4, 8, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
activation->Init(strategy, nullptr);
@ -148,7 +148,7 @@ TEST_F(TestActivationInfo, GetMirrorOPs1) {
}
TEST_F(TestActivationInfo, GetMirrorOPs2) {
Strategys inputs = {{2, 4, 8, 16}};
Strategies inputs = {{2, 4, 8, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
activation->Init(strategy, nullptr);
@ -161,7 +161,7 @@ TEST_F(TestActivationInfo, GetMirrorOPs2) {
TEST_F(TestActivationInfo, CheckStrategy1) {
// Success: {{2,4,8,16}}
Strategys inputs = {{2, 2, 8, 16}, {2, 4, 16, 1}};
Strategies inputs = {{2, 2, 8, 16}, {2, 4, 16, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = activation->Init(strategy, nullptr);
@ -170,7 +170,7 @@ TEST_F(TestActivationInfo, CheckStrategy1) {
TEST_F(TestActivationInfo, CheckStrategy2) {
// Success: {{2,4,8,16}}
Strategys inputs = {{2, 4, 8}};
Strategies inputs = {{2, 4, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = activation->Init(strategy, nullptr);

2
tests/ut/cpp/parallel/ops_info/activation_test.cc
View File

@ -101,7 +101,7 @@ TEST_F(TestActivation, test_softmax_strategies) {
ASSERT_NE(sp, nullptr);
Cost cost = *(swc->cost_list[0]);
Strategys stra = sp->GetInputDim();
Strategies stra = sp->GetInputDim();
ASSERT_GT(stra.size(), 0);
Dimensions input0_stra = stra[0];
ASSERT_GT(input0_stra.size(), 2);

16
tests/ut/cpp/parallel/ops_info/gelu_info_test.cc
View File

@ -63,7 +63,7 @@ void TestGeLUInfo::SetUp() {
}
TEST_F(TestGeLUInfo, InferDevMatrixShape1) {
Strategys inputs = {{2, 4, 1, 16}};
Strategies inputs = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
gelu->Init(strategy, nullptr);
@ -74,7 +74,7 @@ TEST_F(TestGeLUInfo, InferDevMatrixShape1) {
}
TEST_F(TestGeLUInfo, InferSliceShape1) {
Strategys str = {{2, 4, 1, 16}};
Strategies str = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, str);
gelu->Init(strategy, nullptr);
@ -95,7 +95,7 @@ TEST_F(TestGeLUInfo, InferSliceShape1) {
}
TEST_F(TestGeLUInfo, GetTensorLayout1) {
Strategys str = {{2, 4, 1, 16}};
Strategies str = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, str);
gelu->Init(strategy, nullptr);
@ -116,7 +116,7 @@ TEST_F(TestGeLUInfo, GetTensorLayout1) {
}
TEST_F(TestGeLUInfo, GetForwardOp1) {
Strategys inputs = {{2, 4, 1, 16}};
Strategies inputs = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
gelu->Init(strategy, nullptr);
@ -127,7 +127,7 @@ TEST_F(TestGeLUInfo, GetForwardOp1) {
}
TEST_F(TestGeLUInfo, GetMirrorOPs1) {
Strategys inputs = {{2, 4, 1, 16}};
Strategies inputs = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
gelu->Init(strategy, nullptr);
@ -140,7 +140,7 @@ TEST_F(TestGeLUInfo, GetMirrorOPs1) {
TEST_F(TestGeLUInfo, CheckStrategy1) {
// Success: {{2,4,1,16}}
Strategys inputs = {{2, 2, 8, 16}, {2, 4, 16, 1}};
Strategies inputs = {{2, 2, 8, 16}, {2, 4, 16, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = gelu->Init(strategy, nullptr);
@ -149,7 +149,7 @@ TEST_F(TestGeLUInfo, CheckStrategy1) {
TEST_F(TestGeLUInfo, CheckStrategy2) {
// Success: {{2,4,1,16}}
Strategys inputs = {{2, 4, 8}};
Strategies inputs = {{2, 4, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = gelu->Init(strategy, nullptr);
@ -158,7 +158,7 @@ TEST_F(TestGeLUInfo, CheckStrategy2) {
TEST_F(TestGeLUInfo, CheckStrategy3) {
// Success: {{2,4,1,16}}
Strategys inputs = {{2, 4, 1, 16}};
Strategies inputs = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = gelu->Init(strategy, nullptr);

20
tests/ut/cpp/parallel/ops_info/l2_normalize_info_test.cc
View File

@ -64,7 +64,7 @@ void TestL2NormalizeInfo::SetUp() {
}
TEST_F(TestL2NormalizeInfo, InferDevMatrixShape1) {
Strategys inputs = {{4, 1, 8}};
Strategies inputs = {{4, 1, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
norm->Init(strategy, nullptr);
@ -75,7 +75,7 @@ TEST_F(TestL2NormalizeInfo, InferDevMatrixShape1) {
}
TEST_F(TestL2NormalizeInfo, InferSliceShape1) {
Strategys str = {{4, 1, 8}};
Strategies str = {{4, 1, 8}};
StrategyPtr strategy = NewStrategy(0, str);
norm->Init(strategy, nullptr);
@ -96,7 +96,7 @@ TEST_F(TestL2NormalizeInfo, InferSliceShape1) {
}
TEST_F(TestL2NormalizeInfo, GetTensorLayout1) {
Strategys str = {{4, 1, 8}};
Strategies str = {{4, 1, 8}};
StrategyPtr strategy = NewStrategy(0, str);
norm->Init(strategy, nullptr);
@ -117,7 +117,7 @@ TEST_F(TestL2NormalizeInfo, GetTensorLayout1) {
}
TEST_F(TestL2NormalizeInfo, GetForwardOp1) {
Strategys inputs = {{4, 1, 8}};
Strategies inputs = {{4, 1, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
norm->Init(strategy, nullptr);
@ -128,7 +128,7 @@ TEST_F(TestL2NormalizeInfo, GetForwardOp1) {
}
TEST_F(TestL2NormalizeInfo, GetMirrorOPs1) {
Strategys inputs = {{4, 1, 8}};
Strategies inputs = {{4, 1, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
norm->Init(strategy, nullptr);
@ -140,7 +140,7 @@ TEST_F(TestL2NormalizeInfo, GetMirrorOPs1) {
}
TEST_F(TestL2NormalizeInfo, CheckStrategy1) {
Strategys inputs = {{4, 1, 8}, {4, 1, 8}};
Strategies inputs = {{4, 1, 8}, {4, 1, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = norm->Init(strategy, nullptr);
@ -148,7 +148,7 @@ TEST_F(TestL2NormalizeInfo, CheckStrategy1) {
}
TEST_F(TestL2NormalizeInfo, CheckStrategy2) {
Strategys inputs = {{4, 2, 3}};
Strategies inputs = {{4, 2, 3}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = norm->Init(strategy, nullptr);
@ -156,7 +156,7 @@ TEST_F(TestL2NormalizeInfo, CheckStrategy2) {
}
TEST_F(TestL2NormalizeInfo, CheckStrategy3) {
Strategys inputs = {{4, 2, 3, 4}};
Strategies inputs = {{4, 2, 3, 4}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = norm->Init(strategy, nullptr);
@ -164,7 +164,7 @@ TEST_F(TestL2NormalizeInfo, CheckStrategy3) {
}
TEST_F(TestL2NormalizeInfo, CheckStrategy4) {
Strategys inputs = {{4, 1, 8}};
Strategies inputs = {{4, 1, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = norm->Init(strategy, nullptr);
@ -172,7 +172,7 @@ TEST_F(TestL2NormalizeInfo, CheckStrategy4) {
}
TEST_F(TestL2NormalizeInfo, mirror_ops) {
Strategys inputs = {{2, 1, 8}};
Strategies inputs = {{2, 1, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
norm->Init(strategy, nullptr);

18
tests/ut/cpp/parallel/ops_info/log_softmax_info_test.cc
View File

@ -64,7 +64,7 @@ void TestLogSoftmaxInfo::SetUp() {
}
TEST_F(TestLogSoftmaxInfo, InferDevMatrixShape1) {
Strategys inputs = {{2, 4, 1, 16}};
Strategies inputs = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
log_softmax->Init(strategy, nullptr);
@ -75,7 +75,7 @@ TEST_F(TestLogSoftmaxInfo, InferDevMatrixShape1) {
}
TEST_F(TestLogSoftmaxInfo, InferSliceShape1) {
Strategys str = {{2, 4, 1, 16}};
Strategies str = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, str);
log_softmax->Init(strategy, nullptr);
@ -96,7 +96,7 @@ TEST_F(TestLogSoftmaxInfo, InferSliceShape1) {
}
TEST_F(TestLogSoftmaxInfo, GetTensorLayout1) {
Strategys str = {{2, 4, 1, 16}};
Strategies str = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, str);
log_softmax->Init(strategy, nullptr);
@ -117,7 +117,7 @@ TEST_F(TestLogSoftmaxInfo, GetTensorLayout1) {
}
TEST_F(TestLogSoftmaxInfo, GetForwardOp1) {
Strategys inputs = {{2, 4, 1, 16}};
Strategies inputs = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
log_softmax->Init(strategy, nullptr);
@ -128,7 +128,7 @@ TEST_F(TestLogSoftmaxInfo, GetForwardOp1) {
}
TEST_F(TestLogSoftmaxInfo, GetMirrorOPs1) {
Strategys inputs = {{2, 4, 1, 16}};
Strategies inputs = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
log_softmax->Init(strategy, nullptr);
@ -141,7 +141,7 @@ TEST_F(TestLogSoftmaxInfo, GetMirrorOPs1) {
TEST_F(TestLogSoftmaxInfo, CheckStrategy1) {
// Success: {{2,4,1,16}}
Strategys inputs = {{2, 2, 8, 16}, {2, 4, 16, 1}};
Strategies inputs = {{2, 2, 8, 16}, {2, 4, 16, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = log_softmax->Init(strategy, nullptr);
@ -150,7 +150,7 @@ TEST_F(TestLogSoftmaxInfo, CheckStrategy1) {
TEST_F(TestLogSoftmaxInfo, CheckStrategy2) {
// Success: {{2,4,1,16}}
Strategys inputs = {{2, 4, 8}};
Strategies inputs = {{2, 4, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = log_softmax->Init(strategy, nullptr);
@ -159,7 +159,7 @@ TEST_F(TestLogSoftmaxInfo, CheckStrategy2) {
TEST_F(TestLogSoftmaxInfo, CheckStrategy3) {
// Success: {{2,4,1,16}}
Strategys inputs = {{2, 4, 8, 16}};
Strategies inputs = {{2, 4, 8, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = log_softmax->Init(strategy, nullptr);
@ -167,7 +167,7 @@ TEST_F(TestLogSoftmaxInfo, CheckStrategy3) {
}
TEST_F(TestLogSoftmaxInfo, GetDeviceList1) {
Strategys inputs = {{2, 4, 1, 16}};
Strategies inputs = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
log_softmax->Init(strategy, nullptr);

58
tests/ut/cpp/parallel/ops_info/matmul_info_test.cc
View File

@ -97,7 +97,7 @@ void TestMatmulInfo::SetUp() {
/// Description: infer dev matrix
/// Expectation: the dev matrix is right
TEST_F(TestMatmulInfo, InferDevMatrixShape1) {
Strategys inputs = {{2, 4, 8, 16}, {2, 4, 16, 1}};
Strategies inputs = {{2, 4, 8, 16}, {2, 4, 16, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
matmul1->Init(strategy, nullptr);
@ -111,7 +111,7 @@ TEST_F(TestMatmulInfo, InferDevMatrixShape1) {
/// Description: infer dev matrix
/// Expectation: the dev matrix is right
TEST_F(TestMatmulInfo, InferDevMatrixShape2) {
Strategys inputs = {{2, 4, 8, 8}, {2, 4, 8, 2}};
Strategies inputs = {{2, 4, 8, 8}, {2, 4, 8, 2}};
StrategyPtr strategy = NewStrategy(0, inputs);
matmul1->Init(strategy, nullptr);
@ -125,7 +125,7 @@ TEST_F(TestMatmulInfo, InferDevMatrixShape2) {
/// Description: infer dev matrix
/// Expectation: the dev matrix is right
TEST_F(TestMatmulInfo, InferDevMatrixShape3) {
Strategys inputs = {{2, 4, 8, 16}, {1, 16}};
Strategies inputs = {{2, 4, 8, 16}, {1, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
matmul2->Init(strategy, nullptr);
@ -139,7 +139,7 @@ TEST_F(TestMatmulInfo, InferDevMatrixShape3) {
/// Description: infer dev matrix
/// Expectation: the dev matrix is right
TEST_F(TestMatmulInfo, InferDevMatrixShape4) {
Strategys inputs = {{2, 4, 8, 8}, {2, 8}};
Strategies inputs = {{2, 4, 8, 8}, {2, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
matmul2->Init(strategy, nullptr);
@ -153,7 +153,7 @@ TEST_F(TestMatmulInfo, InferDevMatrixShape4) {
/// Description: infer dev matrix
/// Expectation: the dev matrix is right
TEST_F(TestMatmulInfo, InferDevMatrixShape5) {
Strategys inputs = {{8, 16}, {2, 4, 1, 16}};
Strategies inputs = {{8, 16}, {2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
matmul3->Init(strategy, nullptr);
@ -167,7 +167,7 @@ TEST_F(TestMatmulInfo, InferDevMatrixShape5) {
/// Description: infer dev matrix
/// Expectation: the dev matrix is right
TEST_F(TestMatmulInfo, InferDevMatrixShape6) {
Strategys inputs = {{8, 8}, {2, 4, 2, 8}};
Strategies inputs = {{8, 8}, {2, 4, 2, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
matmul3->Init(strategy, nullptr);
@ -181,7 +181,7 @@ TEST_F(TestMatmulInfo, InferDevMatrixShape6) {
/// Description: infer tensor map
/// Expectation: the tensor map is right
TEST_F(TestMatmulInfo, InferTensorMap1) {
Strategys str = {{2, 4, 8, 16}, {2, 4, 16, 1}};
Strategies str = {{2, 4, 8, 16}, {2, 4, 16, 1}};
StrategyPtr strategy = NewStrategy(0, str);
matmul1->Init(strategy, nullptr);
@ -209,7 +209,7 @@ TEST_F(TestMatmulInfo, InferTensorMap1) {
/// Description: infer tensor map
/// Expectation: the tensor map is right
TEST_F(TestMatmulInfo, InferTensorMap2) {
Strategys str = {{2, 4, 8, 16}, {1, 16}};
Strategies str = {{2, 4, 8, 16}, {1, 16}};
StrategyPtr strategy = NewStrategy(0, str);
matmul2->Init(strategy, nullptr);
@ -237,7 +237,7 @@ TEST_F(TestMatmulInfo, InferTensorMap2) {
/// Description: infer tensor map
/// Expectation: the tensor map is right
TEST_F(TestMatmulInfo, InferTensorMap3) {
Strategys str = {{8, 16}, {2, 4, 1, 16}};
Strategies str = {{8, 16}, {2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, str);
matmul3->Init(strategy, nullptr);
@ -265,7 +265,7 @@ TEST_F(TestMatmulInfo, InferTensorMap3) {
/// Description: infer slice shape
/// Expectation: the slice shape is right
TEST_F(TestMatmulInfo, InferSliceShape1) {
Strategys str = {{2, 4, 8, 16}, {2, 4, 16, 1}};
Strategies str = {{2, 4, 8, 16}, {2, 4, 16, 1}};
StrategyPtr strategy = NewStrategy(0, str);
matmul1->Init(strategy, nullptr);
@ -293,7 +293,7 @@ TEST_F(TestMatmulInfo, InferSliceShape1) {
/// Description: infer slice shape
/// Expectation: the slice shape is right
TEST_F(TestMatmulInfo, InferSliceShape2) {
Strategys str = {{2, 4, 8, 16}, {1, 16}};
Strategies str = {{2, 4, 8, 16}, {1, 16}};
StrategyPtr strategy = NewStrategy(0, str);
matmul2->Init(strategy, nullptr);
@ -321,7 +321,7 @@ TEST_F(TestMatmulInfo, InferSliceShape2) {
/// Description: infer slice shape
/// Expectation: the slice shape is right
TEST_F(TestMatmulInfo, InferSliceShape3) {
Strategys str = {{8, 16}, {2, 4, 1, 16}};
Strategies str = {{8, 16}, {2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, str);
matmul3->Init(strategy, nullptr);
@ -349,7 +349,7 @@ TEST_F(TestMatmulInfo, InferSliceShape3) {
/// Description: get tensor layout
/// Expectation: the tensor layout is right
TEST_F(TestMatmulInfo, GetTensorLayout3) {
Strategys str = {{8, 16}, {2, 4, 1, 16}};
Strategies str = {{8, 16}, {2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, str);
matmul3->Init(strategy, nullptr);
@ -377,7 +377,7 @@ TEST_F(TestMatmulInfo, GetTensorLayout3) {
/// Description: infer forward op
/// Expectation: the forward op is right
TEST_F(TestMatmulInfo, GetForwardOp1) {
Strategys inputs = {{2, 4, 8, 16}, {2, 4, 16, 1}};
Strategies inputs = {{2, 4, 8, 16}, {2, 4, 16, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
matmul1->Init(strategy, nullptr);
@ -406,7 +406,7 @@ TEST_F(TestMatmulInfo, GetForwardOp1) {
/// Description: infer forward op
/// Expectation: the forward op is right
TEST_F(TestMatmulInfo, GetForwardOp2) {
Strategys inputs = {{2, 4, 8, 1}, {2, 4, 1, 16}};
Strategies inputs = {{2, 4, 8, 1}, {2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
matmul1->Init(strategy, nullptr);
@ -419,7 +419,7 @@ TEST_F(TestMatmulInfo, GetForwardOp2) {
/// Description: infer virtual_div op
/// Expectation: the virtual_div op is right
TEST_F(TestMatmulInfo, GetVirtualDivOp1) {
Strategys inputs = {{2, 4, 8, 16}, {2, 4, 16, 1}};
Strategies inputs = {{2, 4, 8, 16}, {2, 4, 16, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
matmul1->Init(strategy, nullptr);
@ -441,7 +441,7 @@ TEST_F(TestMatmulInfo, GetVirtualDivOp1) {
/// Description: infer mirror op
/// Expectation: the mirror op is right
TEST_F(TestMatmulInfo, GetMirrorOPs1) {
Strategys inputs = {{2, 4, 8, 16}, {2, 4, 16, 1}};
Strategies inputs = {{2, 4, 8, 16}, {2, 4, 16, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
matmul1->Init(strategy, nullptr);
@ -463,7 +463,7 @@ TEST_F(TestMatmulInfo, GetMirrorOPs1) {
/// Description: infer mirror op
/// Expectation: the mirror op is right
TEST_F(TestMatmulInfo, GetMirrorOPs2) {
Strategys inputs = {{2, 4, 1, 16}, {8, 16}};
Strategies inputs = {{2, 4, 1, 16}, {8, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
matmul2->Init(strategy, nullptr);
@ -485,7 +485,7 @@ TEST_F(TestMatmulInfo, GetMirrorOPs2) {
/// Description: infer mirror op
/// Expectation: the mirror op is right
TEST_F(TestMatmulInfo, GetMirrorOPs3) {
Strategys inputs = {{8, 16}, {2, 4, 1, 16}};
Strategies inputs = {{8, 16}, {2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
matmul3->Init(strategy, nullptr);
@ -506,7 +506,7 @@ TEST_F(TestMatmulInfo, GetMirrorOPs3) {
/// Description: infer mirror op
/// Expectation: the mirror op is right
TEST_F(TestMatmulInfo, GetMirrorOPs4) {
Strategys inputs = {{2, 4, 1, 16}, {2, 4, 16, 8}};
Strategies inputs = {{2, 4, 1, 16}, {2, 4, 16, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
matmul1->Init(strategy, nullptr);
@ -519,7 +519,7 @@ TEST_F(TestMatmulInfo, GetMirrorOPs4) {
/// Description: init twice
/// Expectation: the mirror op is right
TEST_F(TestMatmulInfo, InitTwice) {
Strategys inputs = {{2, 4, 8, 16}, {2, 4, 16, 1}};
Strategies inputs = {{2, 4, 8, 16}, {2, 4, 16, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
// init twice
@ -544,7 +544,7 @@ TEST_F(TestMatmulInfo, InitTwice) {
/// Expectation: return FAILED
TEST_F(TestMatmulInfo, CheckStrategy1) {
// Success: {{2,4,8,16}, {2,4,16,1}}
Strategys inputs = {{2, 2, 8, 16}, {2, 4, 16, 1}};
Strategies inputs = {{2, 2, 8, 16}, {2, 4, 16, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = matmul1->Init(strategy, nullptr);
@ -556,7 +556,7 @@ TEST_F(TestMatmulInfo, CheckStrategy1) {
/// Expectation: return FAILED
TEST_F(TestMatmulInfo, CheckStrategy2) {
// Success: {{2,4,8,16}, {2,4,16,1}}
Strategys inputs = {{2, 4, 8, 16}, {4, 16, 1}};
Strategies inputs = {{2, 4, 8, 16}, {4, 16, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = matmul1->Init(strategy, nullptr);
@ -568,7 +568,7 @@ TEST_F(TestMatmulInfo, CheckStrategy2) {
/// Expectation: return FAILED
TEST_F(TestMatmulInfo, CheckStrategy3) {
// Success: {{2,4,8,16}, {2,4,16,1}}
Strategys inputs = {{2, 4, 8, 16}, {2, 4, 8, 1}};
Strategies inputs = {{2, 4, 8, 16}, {2, 4, 8, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = matmul1->Init(strategy, nullptr);
@ -580,7 +580,7 @@ TEST_F(TestMatmulInfo, CheckStrategy3) {
/// Expectation: return FAILED
TEST_F(TestMatmulInfo, CheckStrategy4) {
// Success: {{2,4,8,16}, {2,4,16,1}}
Strategys inputs = {{2, 4, 8, 16}, {2, 3, 16, 1}};
Strategies inputs = {{2, 4, 8, 16}, {2, 3, 16, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = matmul1->Init(strategy, nullptr);
@ -592,7 +592,7 @@ TEST_F(TestMatmulInfo, CheckStrategy4) {
/// Expectation: return FAILED
TEST_F(TestMatmulInfo, CheckStrategy5) {
// Success: {{2,4,8,16}, {2,4,16,1}}
Strategys inputs = {{0, 4, 8, 16}, {2, 4, 16, 1}};
Strategies inputs = {{0, 4, 8, 16}, {2, 4, 16, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = matmul1->Init(strategy, nullptr);
@ -604,7 +604,7 @@ TEST_F(TestMatmulInfo, CheckStrategy5) {
/// Expectation: return FAILED
TEST_F(TestMatmulInfo, CheckStrategy6) {
// Success: {{2,4,8,16}, {2,4,16,1}}
Strategys inputs = {{-1, 4, 8, 16}, {2, 4, 16, 1}};
Strategies inputs = {{-1, 4, 8, 16}, {2, 4, 16, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = matmul1->Init(strategy, nullptr);
@ -616,7 +616,7 @@ TEST_F(TestMatmulInfo, CheckStrategy6) {
/// Expectation: return FAILED
TEST_F(TestMatmulInfo, CheckStrategy7) {
// Success: {{2,4,8,16}, {2,4,16,1}}
Strategys inputs = {{4, 4, 8, 16}, {2, 4, 16, 1}};
Strategies inputs = {{4, 4, 8, 16}, {2, 4, 16, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = matmul1->Init(strategy, nullptr);
@ -628,7 +628,7 @@ TEST_F(TestMatmulInfo, CheckStrategy7) {
/// Expectation: return FAILED
TEST_F(TestMatmulInfo, InitFailed) {
// matmul4 attr is wrong
Strategys inputs = {{4, 4, 8, 16}, {2, 4, 16, 1}};
Strategies inputs = {{4, 4, 8, 16}, {2, 4, 16, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = matmul4->Init(strategy, nullptr);

18
tests/ut/cpp/parallel/ops_info/onehot_info_test.cc
View File

@ -64,7 +64,7 @@ void TestOneHotInfo::SetUp() {
}
TEST_F(TestOneHotInfo, InferDevMatrixShape1) {
Strategys inputs = {{8, 1}, {}, {}};
Strategies inputs = {{8, 1}, {}, {}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status status = onehot_info->Init(strategy, nullptr);
@ -76,7 +76,7 @@ TEST_F(TestOneHotInfo, InferDevMatrixShape1) {
}
TEST_F(TestOneHotInfo, InferDevMatrixShape2) {
Strategys inputs = {{4, 1}, {}, {}};
Strategies inputs = {{4, 1}, {}, {}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status status = onehot_info->Init(strategy, nullptr);
@ -88,7 +88,7 @@ TEST_F(TestOneHotInfo, InferDevMatrixShape2) {
}
TEST_F(TestOneHotInfo, InferDevMatrixShape3) {
Strategys inputs = {{4, 2}, {}, {}};
Strategies inputs = {{4, 2}, {}, {}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status status = onehot_info->Init(strategy, nullptr);
@ -100,7 +100,7 @@ TEST_F(TestOneHotInfo, InferDevMatrixShape3) {
}
TEST_F(TestOneHotInfo, InferTensorMap2) {
Strategys str = {{8, 1}, {}, {}};
Strategies str = {{8, 1}, {}, {}};
StrategyPtr strategy = NewStrategy(0, str);
Status status = onehot_info->Init(strategy, nullptr);
@ -122,7 +122,7 @@ TEST_F(TestOneHotInfo, InferTensorMap2) {
}
TEST_F(TestOneHotInfo, InferSliceShape1) {
Strategys str = {{8, 1}, {}, {}};
Strategies str = {{8, 1}, {}, {}};
StrategyPtr strategy = NewStrategy(0, str);
Status status = onehot_info->Init(strategy, nullptr);
@ -144,7 +144,7 @@ TEST_F(TestOneHotInfo, InferSliceShape1) {
}
TEST_F(TestOneHotInfo, InferSliceShape2) {
Strategys str = {{4, 2}, {}, {}};
Strategies str = {{4, 2}, {}, {}};
StrategyPtr strategy = NewStrategy(0, str);
Status status = onehot_info->Init(strategy, nullptr);
@ -166,7 +166,7 @@ TEST_F(TestOneHotInfo, InferSliceShape2) {
}
TEST_F(TestOneHotInfo, InferSliceShape3) {
Strategys str = {{2, 2}, {}, {}};
Strategies str = {{2, 2}, {}, {}};
StrategyPtr strategy = NewStrategy(0, str);
Status status = onehot_info->Init(strategy, nullptr);
@ -188,7 +188,7 @@ TEST_F(TestOneHotInfo, InferSliceShape3) {
}
TEST_F(TestOneHotInfo, GetMirrorOPs1) {
Strategys inputs = {{8, 1}, {}, {}};
Strategies inputs = {{8, 1}, {}, {}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status status = onehot_info->Init(strategy, nullptr);
@ -199,7 +199,7 @@ TEST_F(TestOneHotInfo, GetMirrorOPs1) {
}
TEST_F(TestOneHotInfo, CheckStrategy1) {
Strategys inputs = {{16}, {}, {}};
Strategies inputs = {{16}, {}, {}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = onehot_info->Init(strategy, nullptr);

14
tests/ut/cpp/parallel/ops_info/onehot_info_test_axis_0.cc
View File

@ -64,7 +64,7 @@ void TestOneHotInfo2::SetUp() {
}
TEST_F(TestOneHotInfo2, InferDevMatrixShape1) {
Strategys inputs = {{1, 8}, {}, {}};
Strategies inputs = {{1, 8}, {}, {}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status status = onehot_info2->Init(strategy, nullptr);
@ -76,7 +76,7 @@ TEST_F(TestOneHotInfo2, InferDevMatrixShape1) {
}
TEST_F(TestOneHotInfo2, InferDevMatrixShape2) {
Strategys inputs = {{1, 4}, {}, {}};
Strategies inputs = {{1, 4}, {}, {}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status status = onehot_info2->Init(strategy, nullptr);
@ -88,7 +88,7 @@ TEST_F(TestOneHotInfo2, InferDevMatrixShape2) {
}
TEST_F(TestOneHotInfo2, InferDevMatrixShape3) {
Strategys inputs = {{2, 4}, {}, {}};
Strategies inputs = {{2, 4}, {}, {}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status status = onehot_info2->Init(strategy, nullptr);
@ -100,7 +100,7 @@ TEST_F(TestOneHotInfo2, InferDevMatrixShape3) {
}
TEST_F(TestOneHotInfo2, InferTensorMap2) {
Strategys str = {{1, 8}, {}, {}};
Strategies str = {{1, 8}, {}, {}};
StrategyPtr strategy = NewStrategy(0, str);
Status status = onehot_info2->Init(strategy, nullptr);
@ -122,7 +122,7 @@ TEST_F(TestOneHotInfo2, InferTensorMap2) {
}
TEST_F(TestOneHotInfo2, InferSliceShape1) {
Strategys str = {{1, 8}, {}, {}};
Strategies str = {{1, 8}, {}, {}};
StrategyPtr strategy = NewStrategy(0, str);
Status status = onehot_info2->Init(strategy, nullptr);
@ -144,7 +144,7 @@ TEST_F(TestOneHotInfo2, InferSliceShape1) {
}
TEST_F(TestOneHotInfo2, InferSliceShape2) {
Strategys str = {{2, 4}, {}, {}};
Strategies str = {{2, 4}, {}, {}};
StrategyPtr strategy = NewStrategy(0, str);
Status status = onehot_info2->Init(strategy, nullptr);
@ -166,7 +166,7 @@ TEST_F(TestOneHotInfo2, InferSliceShape2) {
}
TEST_F(TestOneHotInfo2, InferSliceShape3) {
Strategys str = {{2, 2}, {}, {}};
Strategies str = {{2, 2}, {}, {}};
StrategyPtr strategy = NewStrategy(0, str);
Status status = onehot_info2->Init(strategy, nullptr);

16
tests/ut/cpp/parallel/ops_info/pow_info_test.cc
View File

@ -63,7 +63,7 @@ void TestPowInfo::SetUp() {
}
TEST_F(TestPowInfo, InferDevMatrixShape1) {
Strategys inputs = {{2, 4, 8}, {2, 4, 8}};
Strategies inputs = {{2, 4, 8}, {2, 4, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
pow->Init(strategy, nullptr);
@ -74,7 +74,7 @@ TEST_F(TestPowInfo, InferDevMatrixShape1) {
}
TEST_F(TestPowInfo, InferSliceShape1) {
Strategys str = {{2, 4, 8}, {2, 4, 8}};
Strategies str = {{2, 4, 8}, {2, 4, 8}};
StrategyPtr strategy = NewStrategy(0, str);
pow->Init(strategy, nullptr);
@ -95,7 +95,7 @@ TEST_F(TestPowInfo, InferSliceShape1) {
}
TEST_F(TestPowInfo, GetTensorLayout1) {
Strategys str = {{2, 4, 8}, {2, 4, 8}};
Strategies str = {{2, 4, 8}, {2, 4, 8}};
StrategyPtr strategy = NewStrategy(0, str);
pow->Init(strategy, nullptr);
@ -116,7 +116,7 @@ TEST_F(TestPowInfo, GetTensorLayout1) {
}
TEST_F(TestPowInfo, GetForwardOp1) {
Strategys inputs = {{2, 4, 8}, {2, 4, 8}};
Strategies inputs = {{2, 4, 8}, {2, 4, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
pow->Init(strategy, nullptr);
@ -127,7 +127,7 @@ TEST_F(TestPowInfo, GetForwardOp1) {
}
TEST_F(TestPowInfo, GetMirrorOPs1) {
Strategys inputs = {{2, 4, 8}, {2, 4, 8}};
Strategies inputs = {{2, 4, 8}, {2, 4, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
pow->Init(strategy, nullptr);
@ -139,7 +139,7 @@ TEST_F(TestPowInfo, GetMirrorOPs1) {
}
TEST_F(TestPowInfo, CheckStrategy1) {
Strategys inputs = {{2, 2, 8}, {2, 4, 8}};
Strategies inputs = {{2, 2, 8}, {2, 4, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = pow->Init(strategy, nullptr);
@ -147,7 +147,7 @@ TEST_F(TestPowInfo, CheckStrategy1) {
}
TEST_F(TestPowInfo, CheckStrategy2) {
Strategys inputs = {{2, 4, 8, 16}, {2, 4, 8, 16}};
Strategies inputs = {{2, 4, 8, 16}, {2, 4, 8, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = pow->Init(strategy, nullptr);
@ -155,7 +155,7 @@ TEST_F(TestPowInfo, CheckStrategy2) {
}
TEST_F(TestPowInfo, CheckStrategy3) {
Strategys inputs = {{2, 4, 8}, {2, 4, 8}};
Strategies inputs = {{2, 4, 8}, {2, 4, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = pow->Init(strategy, nullptr);

24
tests/ut/cpp/parallel/ops_info/prelu_test.cc
View File

@ -64,7 +64,7 @@ void TestPReLUInfo::SetUp() {
}
TEST_F(TestPReLUInfo, InferDevMatrixShape1) {
Strategys inputs = {{2, 1, 8, 16}, {1}};
Strategies inputs = {{2, 1, 8, 16}, {1}};
StrategyPtr strategy = NewStrategy(0, inputs);
prelu->Init(strategy, nullptr);
@ -75,7 +75,7 @@ TEST_F(TestPReLUInfo, InferDevMatrixShape1) {
}
TEST_F(TestPReLUInfo, InferSliceShape1) {
Strategys str = {{2, 1, 8, 16}, {1}};
Strategies str = {{2, 1, 8, 16}, {1}};
StrategyPtr strategy = NewStrategy(0, str);
prelu->Init(strategy, nullptr);
@ -98,7 +98,7 @@ TEST_F(TestPReLUInfo, InferSliceShape1) {
}
TEST_F(TestPReLUInfo, GetTensorLayout1) {
Strategys str = {{2, 1, 8, 16}, {1}};
Strategies str = {{2, 1, 8, 16}, {1}};
StrategyPtr strategy = NewStrategy(0, str);
prelu->Init(strategy, nullptr);
@ -122,7 +122,7 @@ TEST_F(TestPReLUInfo, GetTensorLayout1) {
}
TEST_F(TestPReLUInfo, GetMirrorOPs1) {
Strategys str = {{2, 1, 2, 2}, {1}};
Strategies str = {{2, 1, 2, 2}, {1}};
StrategyPtr strategy = NewStrategy(0, str);
prelu->Init(strategy, nullptr);
MirrorOps mirror_ops = prelu->mirror_ops();
@ -139,14 +139,14 @@ TEST_F(TestPReLUInfo, GetMirrorOPs1) {
TEST_F(TestPReLUInfo, CheckStrategy1) {
// Success: {{2,1,8,16},{1}}
Strategys inputs = {{2, 1, 8, 16}};
Strategies inputs = {{2, 1, 8, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = prelu->Init(strategy, nullptr);
ASSERT_EQ(ret, FAILED);
}
TEST_F(TestPReLUInfo, CheckStrategy2) {
Strategys inputs = {{2, 4, 8, 16}, {4}};
Strategies inputs = {{2, 4, 8, 16}, {4}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = prelu->Init(strategy, nullptr);
ASSERT_EQ(ret, SUCCESS);
@ -169,7 +169,7 @@ TEST_F(TestPReLUInfo, AutoStrategy1) {
}
TEST_F(TestPReLUInfo, InferDevMatrixShape_2d1) {
Strategys inputs = {{128, 1}, {1}};
Strategies inputs = {{128, 1}, {1}};
StrategyPtr strategy = NewStrategy(0, inputs);
prelu_2d->Init(strategy, nullptr);
@ -180,7 +180,7 @@ TEST_F(TestPReLUInfo, InferDevMatrixShape_2d1) {
}
TEST_F(TestPReLUInfo, InferSliceShape_2d1) {
Strategys str = {{128, 1}, {1}};
Strategies str = {{128, 1}, {1}};
StrategyPtr strategy = NewStrategy(0, str);
prelu_2d->Init(strategy, nullptr);
@ -203,7 +203,7 @@ TEST_F(TestPReLUInfo, InferSliceShape_2d1) {
}
TEST_F(TestPReLUInfo, GetTensorLayout_2d1) {
Strategys str = {{128, 1}, {1}};
Strategies str = {{128, 1}, {1}};
StrategyPtr strategy = NewStrategy(0, str);
prelu_2d->Init(strategy, nullptr);
@ -227,7 +227,7 @@ TEST_F(TestPReLUInfo, GetTensorLayout_2d1) {
}
TEST_F(TestPReLUInfo, GetMirrorOPs_2d1) {
Strategys str = {{128, 1}, {1}};
Strategies str = {{128, 1}, {1}};
StrategyPtr strategy = NewStrategy(0, str);
prelu_2d->Init(strategy, nullptr);
MirrorOps mirror_ops = prelu_2d->mirror_ops();
@ -244,14 +244,14 @@ TEST_F(TestPReLUInfo, GetMirrorOPs_2d1) {
TEST_F(TestPReLUInfo, CheckStrategy_2d1) {
// Success: {{2,1,8,16},{1}}
Strategys inputs = {{128, 1}};
Strategies inputs = {{128, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = prelu_2d->Init(strategy, nullptr);
ASSERT_EQ(ret, FAILED);
}
TEST_F(TestPReLUInfo, CheckStrategy_2d2) {
Strategys inputs = {{128, 4}, {4}};
Strategies inputs = {{128, 4}, {4}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = prelu_2d->Init(strategy, nullptr);
ASSERT_EQ(ret, SUCCESS);

22
tests/ut/cpp/parallel/ops_info/reduce_method_test.cc
View File

@ -68,7 +68,7 @@ void TestReduceSumInfo::SetUp() {
}
TEST_F(TestReduceSumInfo, InferDevMatrixShape1) {
Strategys inputs = {{4, 8, 1}};
Strategies inputs = {{4, 8, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
reduce_sum->Init(strategy, nullptr);
@ -79,7 +79,7 @@ TEST_F(TestReduceSumInfo, InferDevMatrixShape1) {
}
TEST_F(TestReduceSumInfo, InferSliceShape1) {
Strategys str = {{4, 8, 1}};
Strategies str = {{4, 8, 1}};
StrategyPtr strategy = NewStrategy(0, str);
reduce_sum->Init(strategy, nullptr);
@ -100,7 +100,7 @@ TEST_F(TestReduceSumInfo, InferSliceShape1) {
}
TEST_F(TestReduceSumInfo, GetTensorLayout1) {
Strategys str = {{4, 8, 1}};
Strategies str = {{4, 8, 1}};
StrategyPtr strategy = NewStrategy(0, str);
reduce_sum->Init(strategy, nullptr);
@ -121,7 +121,7 @@ TEST_F(TestReduceSumInfo, GetTensorLayout1) {
}
TEST_F(TestReduceSumInfo, GetForwardOp1) {
Strategys inputs = {{4, 8, 1}};
Strategies inputs = {{4, 8, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
reduce_sum->Init(strategy, nullptr);
@ -132,7 +132,7 @@ TEST_F(TestReduceSumInfo, GetForwardOp1) {
}
TEST_F(TestReduceSumInfo, GetForwardOp2) {
Strategys inputs = {{4, 4, 2}};
Strategies inputs = {{4, 4, 2}};
StrategyPtr strategy = NewStrategy(0, inputs);
reduce_sum->Init(strategy, nullptr);
@ -156,7 +156,7 @@ TEST_F(TestReduceSumInfo, GetForwardOp2) {
}
TEST_F(TestReduceSumInfo, GetMirrorOPs1) {
Strategys inputs = {{4, 8, 1}};
Strategies inputs = {{4, 8, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
reduce_sum->Init(strategy, nullptr);
@ -168,7 +168,7 @@ TEST_F(TestReduceSumInfo, GetMirrorOPs1) {
}
TEST_F(TestReduceSumInfo, GetMirrorOPs2) {
Strategys inputs = {{4, 4, 1}};
Strategies inputs = {{4, 4, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
reduce_sum->Init(strategy, nullptr);
@ -187,7 +187,7 @@ TEST_F(TestReduceSumInfo, GetMirrorOPs2) {
}
TEST_F(TestReduceSumInfo, CheckStrategy1) {
Strategys inputs = {{2, 2, 8, 16}};
Strategies inputs = {{2, 2, 8, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = reduce_sum->Init(strategy, nullptr);
@ -195,7 +195,7 @@ TEST_F(TestReduceSumInfo, CheckStrategy1) {
}
TEST_F(TestReduceSumInfo, CheckStrategy2) {
Strategys inputs = {{2, 4, 8}, {2, 4, 8}};
Strategies inputs = {{2, 4, 8}, {2, 4, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = reduce_sum->Init(strategy, nullptr);
@ -203,7 +203,7 @@ TEST_F(TestReduceSumInfo, CheckStrategy2) {
}
TEST_F(TestReduceSumInfo, CheckStrategy3) {
Strategys inputs = {{4, 4, 2}};
Strategies inputs = {{4, 4, 2}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = reduce_sum->Init(strategy, nullptr);
@ -211,7 +211,7 @@ TEST_F(TestReduceSumInfo, CheckStrategy3) {
}
TEST_F(TestReduceSumInfo, CheckStrategy4) {
Strategys inputs = {{4, 8, 1}};
Strategies inputs = {{4, 8, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = reduce_sum->Init(strategy, nullptr);

22
tests/ut/cpp/parallel/ops_info/reshape_test.cc
View File

@ -68,7 +68,7 @@ void TestReshapeInfo::SetUp() {
}
TEST_F(TestReshapeInfo, InferDevMatrixShape1) {
Strategys inputs = {{4, 1, 1, 1}};
Strategies inputs = {{4, 1, 1, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
reshape->Init(strategy, nullptr);
@ -79,7 +79,7 @@ TEST_F(TestReshapeInfo, InferDevMatrixShape1) {
}
TEST_F(TestReshapeInfo, InferDevMatrixShape2) {
Strategys inputs = {{32, 1, 1, 1}};
Strategies inputs = {{32, 1, 1, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
reshape->Init(strategy, nullptr);
@ -90,7 +90,7 @@ TEST_F(TestReshapeInfo, InferDevMatrixShape2) {
}
TEST_F(TestReshapeInfo, InferSliceShape1) {
Strategys str = {{4, 1, 1, 1}};
Strategies str = {{4, 1, 1, 1}};
StrategyPtr strategy = NewStrategy(0, str);
reshape->Init(strategy, nullptr);
@ -111,7 +111,7 @@ TEST_F(TestReshapeInfo, InferSliceShape1) {
}
TEST_F(TestReshapeInfo, InferSliceShape2) {
Strategys str = {{32, 1, 1, 1}};
Strategies str = {{32, 1, 1, 1}};
StrategyPtr strategy = NewStrategy(0, str);
reshape->Init(strategy, nullptr);
@ -132,7 +132,7 @@ TEST_F(TestReshapeInfo, InferSliceShape2) {
}
TEST_F(TestReshapeInfo, GetTensorLayout1) {
Strategys str = {{4, 1, 1, 1}};
Strategies str = {{4, 1, 1, 1}};
StrategyPtr strategy = NewStrategy(0, str);
reshape->Init(strategy, nullptr);
@ -153,7 +153,7 @@ TEST_F(TestReshapeInfo, GetTensorLayout1) {
}
TEST_F(TestReshapeInfo, GetTensorLayout2) {
Strategys str = {{32, 1, 1, 1}};
Strategies str = {{32, 1, 1, 1}};
StrategyPtr strategy = NewStrategy(0, str);
reshape->Init(strategy, nullptr);
@ -174,7 +174,7 @@ TEST_F(TestReshapeInfo, GetTensorLayout2) {
}
TEST_F(TestReshapeInfo, GetForwardOp1) {
Strategys inputs = {{4, 1, 1, 1}};
Strategies inputs = {{4, 1, 1, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
reshape->Init(strategy, nullptr);
@ -185,7 +185,7 @@ TEST_F(TestReshapeInfo, GetForwardOp1) {
}
TEST_F(TestReshapeInfo, GetMirrorOPs1) {
Strategys inputs = {{4, 1, 1, 1}};
Strategies inputs = {{4, 1, 1, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
reshape->Init(strategy, nullptr);
@ -197,7 +197,7 @@ TEST_F(TestReshapeInfo, GetMirrorOPs1) {
}
TEST_F(TestReshapeInfo, CheckStrategy1) {
Strategys inputs = {{1, 4, 8}};
Strategies inputs = {{1, 4, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = reshape->Init(strategy, nullptr);
@ -205,7 +205,7 @@ TEST_F(TestReshapeInfo, CheckStrategy1) {
}
TEST_F(TestReshapeInfo, CheckStrategy2) {
Strategys inputs = {{2, 4, 8}, {2, 4, 8}};
Strategies inputs = {{2, 4, 8}, {2, 4, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = reshape->Init(strategy, nullptr);
@ -213,7 +213,7 @@ TEST_F(TestReshapeInfo, CheckStrategy2) {
}
TEST_F(TestReshapeInfo, CheckStrategy3) {
Strategys inputs = {{4, 1, 1, 1}};
Strategies inputs = {{4, 1, 1, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = reshape->Init(strategy, nullptr);

16
tests/ut/cpp/parallel/ops_info/softmax_entropy_loss_info_test.cc
View File

@ -64,7 +64,7 @@ void TestSoftmaxLoss::SetUp() {
}
TEST_F(TestSoftmaxLoss, InferDevMatrixShape1) {
Strategys inputs = {{2, 4, 8, 1}, {2, 4, 8, 1}};
Strategies inputs = {{2, 4, 8, 1}, {2, 4, 8, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
loss->Init(strategy, nullptr);
@ -75,7 +75,7 @@ TEST_F(TestSoftmaxLoss, InferDevMatrixShape1) {
}
TEST_F(TestSoftmaxLoss, InferSliceShape1) {
Strategys str = {{2, 4, 8, 1}, {2, 4, 8, 1}};
Strategies str = {{2, 4, 8, 1}, {2, 4, 8, 1}};
StrategyPtr strategy = NewStrategy(0, str);
loss->Init(strategy, nullptr);
@ -104,7 +104,7 @@ TEST_F(TestSoftmaxLoss, InferSliceShape1) {
}
TEST_F(TestSoftmaxLoss, GetTensorLayout1) {
Strategys str = {{2, 4, 8, 1}, {2, 4, 8, 1}};
Strategies str = {{2, 4, 8, 1}, {2, 4, 8, 1}};
StrategyPtr strategy = NewStrategy(0, str);
loss->Init(strategy, nullptr);
@ -133,7 +133,7 @@ TEST_F(TestSoftmaxLoss, GetTensorLayout1) {
}
TEST_F(TestSoftmaxLoss, GetForwardOp1) {
Strategys inputs = {{2, 4, 8, 1}, {2, 4, 8, 1}};
Strategies inputs = {{2, 4, 8, 1}, {2, 4, 8, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
loss->Init(strategy, nullptr);
@ -144,7 +144,7 @@ TEST_F(TestSoftmaxLoss, GetForwardOp1) {
}
TEST_F(TestSoftmaxLoss, GetMirrorOPs1) {
Strategys inputs = {{2, 4, 8, 1}, {2, 4, 8, 1}};
Strategies inputs = {{2, 4, 8, 1}, {2, 4, 8, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
loss->Init(strategy, nullptr);
@ -156,7 +156,7 @@ TEST_F(TestSoftmaxLoss, GetMirrorOPs1) {
}
TEST_F(TestSoftmaxLoss, GetVirtualDivOPs1) {
Strategys inputs = {{1, 4, 8, 1}, {1, 4, 8, 1}};
Strategies inputs = {{1, 4, 8, 1}, {1, 4, 8, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
loss->Init(strategy, nullptr);
@ -176,7 +176,7 @@ TEST_F(TestSoftmaxLoss, GetVirtualDivOPs1) {
TEST_F(TestSoftmaxLoss, CheckStrategy1) {
// Success: {{2,4,8,16}}
Strategys inputs = {{2, 2, 8, 16}, {2, 4, 16, 1}};
Strategies inputs = {{2, 2, 8, 16}, {2, 4, 16, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = loss->Init(strategy, nullptr);
@ -185,7 +185,7 @@ TEST_F(TestSoftmaxLoss, CheckStrategy1) {
TEST_F(TestSoftmaxLoss, CheckStrategy2) {
// Success: {{2,4,8,16}}
Strategys inputs = {{2, 4, 8}};
Strategies inputs = {{2, 4, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = loss->Init(strategy, nullptr);

20
tests/ut/cpp/parallel/ops_info/softmax_info_test.cc
View File

@ -68,7 +68,7 @@ void TestSoftmaxInfo::SetUp() {
}
TEST_F(TestSoftmaxInfo, InferDevMatrixShape1) {
Strategys inputs = {{2, 4, 1, 16}};
Strategies inputs = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
softmax->Init(strategy, nullptr);
@ -79,7 +79,7 @@ TEST_F(TestSoftmaxInfo, InferDevMatrixShape1) {
}
TEST_F(TestSoftmaxInfo, InferSliceShape1) {
Strategys str = {{2, 4, 1, 16}};
Strategies str = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, str);
softmax->Init(strategy, nullptr);
@ -100,7 +100,7 @@ TEST_F(TestSoftmaxInfo, InferSliceShape1) {
}
TEST_F(TestSoftmaxInfo, GetTensorLayout1) {
Strategys str = {{2, 4, 1, 16}};
Strategies str = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, str);
softmax->Init(strategy, nullptr);
@ -121,7 +121,7 @@ TEST_F(TestSoftmaxInfo, GetTensorLayout1) {
}
TEST_F(TestSoftmaxInfo, GetForwardOp1) {
Strategys inputs = {{2, 4, 1, 16}};
Strategies inputs = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
softmax->Init(strategy, nullptr);
@ -132,7 +132,7 @@ TEST_F(TestSoftmaxInfo, GetForwardOp1) {
}
TEST_F(TestSoftmaxInfo, GetMirrorOPs1) {
Strategys inputs = {{2, 4, 1, 16}};
Strategies inputs = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
softmax->Init(strategy, nullptr);
@ -145,7 +145,7 @@ TEST_F(TestSoftmaxInfo, GetMirrorOPs1) {
TEST_F(TestSoftmaxInfo, CheckStrategy1) {
// Success: {{2,4,1,16}}
Strategys inputs = {{2, 2, 8, 16}, {2, 4, 16, 1}};
Strategies inputs = {{2, 2, 8, 16}, {2, 4, 16, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = softmax->Init(strategy, nullptr);
@ -154,7 +154,7 @@ TEST_F(TestSoftmaxInfo, CheckStrategy1) {
TEST_F(TestSoftmaxInfo, CheckStrategy2) {
// Success: {{2,4,1,16}}
Strategys inputs = {{2, 4, 8}};
Strategies inputs = {{2, 4, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = softmax->Init(strategy, nullptr);
@ -163,7 +163,7 @@ TEST_F(TestSoftmaxInfo, CheckStrategy2) {
TEST_F(TestSoftmaxInfo, CheckStrategy3) {
// Success: {{2,4,1,16}}
Strategys inputs = {{2, 4, 8, 16}};
Strategies inputs = {{2, 4, 8, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = softmax->Init(strategy, nullptr);
@ -172,7 +172,7 @@ TEST_F(TestSoftmaxInfo, CheckStrategy3) {
TEST_F(TestSoftmaxInfo, InitFailed1) {
// softmax2's axis is wrong
Strategys inputs = {{2, 4, 1, 16}};
Strategies inputs = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = softmax2->Init(strategy, nullptr);
@ -181,7 +181,7 @@ TEST_F(TestSoftmaxInfo, InitFailed1) {
TEST_F(TestSoftmaxInfo, InitFailed2) {
// dev num is wrong
Strategys inputs = {{2, 4, 1, 100}};
Strategies inputs = {{2, 4, 1, 100}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = softmax2->Init(strategy, nullptr);

16
tests/ut/cpp/parallel/ops_info/tanh_info_test.cc
View File

@ -63,7 +63,7 @@ void TestTanhInfo::SetUp() {
}
TEST_F(TestTanhInfo, InferDevMatrixShape1) {
Strategys inputs = {{2, 4, 1, 16}};
Strategies inputs = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
tanh->Init(strategy, nullptr);
@ -74,7 +74,7 @@ TEST_F(TestTanhInfo, InferDevMatrixShape1) {
}
TEST_F(TestTanhInfo, InferSliceShape1) {
Strategys str = {{2, 4, 1, 16}};
Strategies str = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, str);
tanh->Init(strategy, nullptr);
@ -95,7 +95,7 @@ TEST_F(TestTanhInfo, InferSliceShape1) {
}
TEST_F(TestTanhInfo, GetTensorLayout1) {
Strategys str = {{2, 4, 1, 16}};
Strategies str = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, str);
tanh->Init(strategy, nullptr);
@ -116,7 +116,7 @@ TEST_F(TestTanhInfo, GetTensorLayout1) {
}
TEST_F(TestTanhInfo, GetForwardOp1) {
Strategys inputs = {{2, 4, 1, 16}};
Strategies inputs = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
tanh->Init(strategy, nullptr);
@ -127,7 +127,7 @@ TEST_F(TestTanhInfo, GetForwardOp1) {
}
TEST_F(TestTanhInfo, GetMirrorOPs1) {
Strategys inputs = {{2, 4, 1, 16}};
Strategies inputs = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
tanh->Init(strategy, nullptr);
@ -140,7 +140,7 @@ TEST_F(TestTanhInfo, GetMirrorOPs1) {
TEST_F(TestTanhInfo, CheckStrategy1) {
// Success: {{2,4,1,16}}
Strategys inputs = {{2, 2, 8, 16}, {2, 4, 16, 1}};
Strategies inputs = {{2, 2, 8, 16}, {2, 4, 16, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = tanh->Init(strategy, nullptr);
@ -149,7 +149,7 @@ TEST_F(TestTanhInfo, CheckStrategy1) {
TEST_F(TestTanhInfo, CheckStrategy2) {
// Success: {{2,4,1,16}}
Strategys inputs = {{2, 4, 8}};
Strategies inputs = {{2, 4, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = tanh->Init(strategy, nullptr);
@ -158,7 +158,7 @@ TEST_F(TestTanhInfo, CheckStrategy2) {
TEST_F(TestTanhInfo, CheckStrategy3) {
// Success: {{2,4,1,16}}
Strategys inputs = {{2, 4, 1, 16}};
Strategies inputs = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = tanh->Init(strategy, nullptr);

20
tests/ut/cpp/parallel/ops_info/tensor_add_info_test.cc
View File

@ -66,7 +66,7 @@ void TestTensorAddInfo::SetUp() {
}
TEST_F(TestTensorAddInfo, InferDevMatrixShape1) {
Strategys inputs = {{2, 4, 4}, {2, 4, 4}};
Strategies inputs = {{2, 4, 4}, {2, 4, 4}};
StrategyPtr strategy = NewStrategy(0, inputs);
tensor_add->Init(strategy, nullptr);
@ -77,7 +77,7 @@ TEST_F(TestTensorAddInfo, InferDevMatrixShape1) {
}
TEST_F(TestTensorAddInfo, InferSliceShape1) {
Strategys str = {{2, 4, 4}, {2, 4, 4}};
Strategies str = {{2, 4, 4}, {2, 4, 4}};
StrategyPtr strategy = NewStrategy(0, str);
tensor_add->Init(strategy, nullptr);
@ -101,7 +101,7 @@ TEST_F(TestTensorAddInfo, InferSliceShape1) {
}
TEST_F(TestTensorAddInfo, GetTensorLayout1) {
Strategys str = {{2, 4, 4}, {2, 4, 4}};
Strategies str = {{2, 4, 4}, {2, 4, 4}};
StrategyPtr strategy = NewStrategy(0, str);
tensor_add->Init(strategy, nullptr);
@ -125,7 +125,7 @@ TEST_F(TestTensorAddInfo, GetTensorLayout1) {
}
TEST_F(TestTensorAddInfo, GetForwardOp1) {
Strategys inputs = {{2, 4, 4}, {2, 4, 4}};
Strategies inputs = {{2, 4, 4}, {2, 4, 4}};
StrategyPtr strategy = NewStrategy(0, inputs);
tensor_add->Init(strategy, nullptr);
@ -136,7 +136,7 @@ TEST_F(TestTensorAddInfo, GetForwardOp1) {
}
TEST_F(TestTensorAddInfo, GetMirrorOPs1) {
Strategys inputs = {{2, 4, 4}, {2, 4, 4}};
Strategies inputs = {{2, 4, 4}, {2, 4, 4}};
StrategyPtr strategy = NewStrategy(0, inputs);
tensor_add->Init(strategy, nullptr);
@ -148,7 +148,7 @@ TEST_F(TestTensorAddInfo, GetMirrorOPs1) {
}
TEST_F(TestTensorAddInfo, CheckStrategy1) {
Strategys inputs = {{2, 4, 4}, {2, 6, 4}};
Strategies inputs = {{2, 4, 4}, {2, 6, 4}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = tensor_add->Init(strategy, nullptr);
@ -156,7 +156,7 @@ TEST_F(TestTensorAddInfo, CheckStrategy1) {
}
TEST_F(TestTensorAddInfo, CheckStrategy2) {
Strategys inputs = {{2, 4, 8}, {2, 4, 8}};
Strategies inputs = {{2, 4, 8}, {2, 4, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = tensor_add->Init(strategy, nullptr);
@ -164,7 +164,7 @@ TEST_F(TestTensorAddInfo, CheckStrategy2) {
}
TEST_F(TestTensorAddInfo, CheckStrategy3) {
Strategys inputs = {{2, 4, 6}};
Strategies inputs = {{2, 4, 6}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = tensor_add->Init(strategy, nullptr);
@ -172,7 +172,7 @@ TEST_F(TestTensorAddInfo, CheckStrategy3) {
}
TEST_F(TestTensorAddInfo, CheckStrategy4) {
Strategys inputs = {{2, 4, 4}, {2, 4, 4}};
Strategies inputs = {{2, 4, 4}, {2, 4, 4}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = tensor_add->Init(strategy, nullptr);
@ -224,7 +224,7 @@ TEST_F(TestTensorAddInfo, GenerateStrategies1) {
}
TEST_F(TestTensorAddInfo, mirror_ops) {
Strategys inputs = {{1, 8}, {4, 1}};
Strategies inputs = {{1, 8}, {4, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
tensor_add1->Init(strategy, nullptr);

10
tests/ut/cpp/parallel/ops_info/tmpidentity_test.cc
View File

@ -65,7 +65,7 @@ void TestTmpIdentityInfo::SetUp() {
}
TEST_F(TestTmpIdentityInfo, InferDevMatrixShape1) {
Strategys inputs = {{2, 4, 8, 16}};
Strategies inputs = {{2, 4, 8, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
identity_ptr->Init(strategy, nullptr);
@ -76,7 +76,7 @@ TEST_F(TestTmpIdentityInfo, InferDevMatrixShape1) {
}
TEST_F(TestTmpIdentityInfo, InferSliceShape1) {
Strategys str = {{2, 4, 8, 16}};
Strategies str = {{2, 4, 8, 16}};
StrategyPtr strategy = NewStrategy(0, str);
identity_ptr->Init(strategy, nullptr);
@ -97,7 +97,7 @@ TEST_F(TestTmpIdentityInfo, InferSliceShape1) {
}
TEST_F(TestTmpIdentityInfo, GetTensorLayout1) {
Strategys str = {{2, 4, 8, 16}};
Strategies str = {{2, 4, 8, 16}};
StrategyPtr strategy = NewStrategy(0, str);
identity_ptr->Init(strategy, nullptr);
@ -119,7 +119,7 @@ TEST_F(TestTmpIdentityInfo, GetTensorLayout1) {
TEST_F(TestTmpIdentityInfo, CheckStrategy1) {
// Success: {{2,4,8,16}}
Strategys inputs = {{2, 2, 8, 16}, {2, 4, 16, 1}};
Strategies inputs = {{2, 2, 8, 16}, {2, 4, 16, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = identity_ptr->Init(strategy, nullptr);
@ -128,7 +128,7 @@ TEST_F(TestTmpIdentityInfo, CheckStrategy1) {
TEST_F(TestTmpIdentityInfo, CheckStrategy2) {
// Success: {{2,4,8,16}}
Strategys inputs = {{2, 4, 8}};
Strategies inputs = {{2, 4, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = identity_ptr->Init(strategy, nullptr);

18
tests/ut/cpp/parallel/ops_info/transpose_test.cc
View File

@ -68,7 +68,7 @@ void TestTransposeInfo::SetUp() {
}
TEST_F(TestTransposeInfo, InferDevMatrixShape1) {
Strategys inputs = {{4, 8}};
Strategies inputs = {{4, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
transpose->Init(strategy, nullptr);
@ -79,7 +79,7 @@ TEST_F(TestTransposeInfo, InferDevMatrixShape1) {
}
TEST_F(TestTransposeInfo, InferDevMatrixShape2) {
Strategys inputs = {{4, 1}};
Strategies inputs = {{4, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
transpose->Init(strategy, nullptr);
@ -90,7 +90,7 @@ TEST_F(TestTransposeInfo, InferDevMatrixShape2) {
}
TEST_F(TestTransposeInfo, InferSliceShape1) {
Strategys str = {{4, 8}};
Strategies str = {{4, 8}};
StrategyPtr strategy = NewStrategy(0, str);
transpose->Init(strategy, nullptr);
@ -111,7 +111,7 @@ TEST_F(TestTransposeInfo, InferSliceShape1) {
}
TEST_F(TestTransposeInfo, GetTensorLayout1) {
Strategys str = {{4, 8}};
Strategies str = {{4, 8}};
StrategyPtr strategy = NewStrategy(0, str);
transpose->Init(strategy, nullptr);
@ -132,7 +132,7 @@ TEST_F(TestTransposeInfo, GetTensorLayout1) {
}
TEST_F(TestTransposeInfo, GetForwardOp1) {
Strategys inputs = {{4, 8}};
Strategies inputs = {{4, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
transpose->Init(strategy, nullptr);
@ -143,7 +143,7 @@ TEST_F(TestTransposeInfo, GetForwardOp1) {
}
TEST_F(TestTransposeInfo, GetMirrorOPs1) {
Strategys inputs = {{4, 8}};
Strategies inputs = {{4, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
transpose->Init(strategy, nullptr);
@ -155,7 +155,7 @@ TEST_F(TestTransposeInfo, GetMirrorOPs1) {
}
TEST_F(TestTransposeInfo, CheckStrategy1) {
Strategys inputs = {{1, 4, 8}};
Strategies inputs = {{1, 4, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = transpose->Init(strategy, nullptr);
@ -163,7 +163,7 @@ TEST_F(TestTransposeInfo, CheckStrategy1) {
}
TEST_F(TestTransposeInfo, CheckStrategy2) {
Strategys inputs = {{2, 4, 8}, {2, 4, 8}};
Strategies inputs = {{2, 4, 8}, {2, 4, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = transpose->Init(strategy, nullptr);
@ -171,7 +171,7 @@ TEST_F(TestTransposeInfo, CheckStrategy2) {
}
TEST_F(TestTransposeInfo, CheckStrategy3) {
Strategys inputs = {{4, 8}};
Strategies inputs = {{4, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = transpose->Init(strategy, nullptr);

8
tests/ut/cpp/parallel/step_parallel_test.cc
View File

@ -237,9 +237,9 @@ TEST_F(TestStepParallel, ExtractStrategy) {
std::vector<ValuePtr> elements = {val1, val2};
ValueTuplePtr strategy_tuple = std::make_shared<ValueTuple>(elements);
attrs["in_strategy"] = strategy_tuple;
Strategys strategy_expect = {v1, v2};
Strategies strategy_expect = {v1, v2};
StrategyPtr strategy = ExtractStrategy(attrs["in_strategy"]);
Strategys strategy_test = strategy->GetInputDim();
Strategies strategy_test = strategy->GetInputDim();
ASSERT_EQ(strategy_expect, strategy_test);
}
@ -380,7 +380,7 @@ TEST_F(TestStepParallel, OperatorInstance) {
prim->set_attr("transpose_b", transpose_b);
auto attrs = prim->attrs();
// create strategy
Strategys strategy = {{2, 2}, {2, 4}};
Strategies strategy = {{2, 2}, {2, 4}};
StrategyPtr strategyPtr = parallel::NewStrategy(0, strategy);
// create shape
Shapes inputs_shape = std::vector<Shape>{{64, 32}, {32, 64}};
@ -557,7 +557,7 @@ TEST_F(TestStepParallel, GetTensorInLayout) {
prim->set_attr("transpose_b", transpose_b);
auto attrs = prim->attrs();
// create strategy
Strategys strategy = {{2, 2}, {2, 4}};
Strategies strategy = {{2, 2}, {2, 4}};
StrategyPtr strategyPtr = parallel::NewStrategy(0, strategy);
// create shape
Shapes inputs_shape = std::vector<Shape>{{64, 32}, {32, 64}};

16
tests/ut/cpp/parallel/strategy_test.cc
View File

@ -35,7 +35,7 @@ TEST_F(TestStrategy, GetInputNumber) {
int32_t stage = 1;
Dimensions dimension1 = {2, 4};
Dimensions dimension2 = {2, 2};
Strategys inputs = {dimension1, dimension2};
Strategies inputs = {dimension1, dimension2};
Strategy strategy(stage, inputs);
int32_t number_test = strategy.GetInputNumber();
@ -46,7 +46,7 @@ TEST_F(TestStrategy, GetInputStage) {
int32_t stage = 1;
Dimensions dimension1 = {2, 4};
Dimensions dimension2 = {2, 2};
Strategys inputs = {dimension1, dimension2};
Strategies inputs = {dimension1, dimension2};
Strategy strategy(stage, inputs);
int32_t stage_test = strategy.GetInputStage();
@ -57,10 +57,10 @@ TEST_F(TestStrategy, GetInputDim) {
int32_t stage = 1;
Dimensions dimension1 = {2, 4};
Dimensions dimension2 = {2, 2};
Strategys inputs = {dimension1, dimension2};
Strategies inputs = {dimension1, dimension2};
Strategy strategy(stage, inputs);
Strategys inputs_test = strategy.GetInputDim();
Strategies inputs_test = strategy.GetInputDim();
ASSERT_EQ(inputs, inputs_test);
}
@ -68,10 +68,10 @@ TEST_F(TestStrategy, IsEqual) {
int32_t stage1 = 0, stage2 = 0, stage3 = 1, stage4 = 0;
Dimensions dimension1 = {8, 1};
Dimensions dimension2 = {1, 8};
Strategys inputs1 = {dimension1};
Strategys inputs2 = {dimension1};
Strategys inputs3 = {dimension2};
Strategys inputs4 = {dimension1, dimension2};
Strategies inputs1 = {dimension1};
Strategies inputs2 = {dimension1};
Strategies inputs3 = {dimension2};
Strategies inputs4 = {dimension1, dimension2};
StrategyPtr stra1 = std::make_shared<Strategy>(stage1, inputs1);
StrategyPtr stra2 = std::make_shared<Strategy>(stage2, inputs2);

2
tests/ut/cpp/parallel/tensor_layout/construct_operator_test.cc
View File

@ -62,7 +62,7 @@ void TestConstructOperator::SetUp() {
MatMulInfoPtr matmul = std::make_shared<MatMulInfo>("matmul_info", inputs_shape_1, outputs_shape_1, attr_1);
Strategys str = {{2, 4, 8, 16}, {2, 4, 16, 1}};
Strategies str = {{2, 4, 8, 16}, {2, 4, 16, 1}};
StrategyPtr strategy = NewStrategy(0, str);
matmul->Init(strategy, nullptr);
Shape tensor_shape = {512, 1024};

6
tests/ut/cpp/parallel/virtual_dataset_test.cc
View File

@ -62,7 +62,7 @@ void TestVirtualDatasetInfo::SetUp() {
}
TEST_F(TestVirtualDatasetInfo, InferDevMatrixShape1) {
Strategys inputs = {{16, 1}, {16, 1}, {16, 1}};
Strategies inputs = {{16, 1}, {16, 1}, {16, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
virtual_dataset->Init(strategy, nullptr);
Shape dev_matrix_shape = virtual_dataset->dev_matrix_shape();
@ -72,7 +72,7 @@ TEST_F(TestVirtualDatasetInfo, InferDevMatrixShape1) {
}
TEST_F(TestVirtualDatasetInfo, GetForwardOp1) {
Strategys inputs = {{8, 1}, {8, 1}, {8, 1}};
Strategies inputs = {{8, 1}, {8, 1}, {8, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
virtual_dataset->Init(strategy, nullptr);
@ -83,7 +83,7 @@ TEST_F(TestVirtualDatasetInfo, GetForwardOp1) {
}
TEST_F(TestVirtualDatasetInfo, GetMirrorOPs1) {
Strategys inputs = {{8, 1}, {8, 1}, {8, 1}};
Strategies inputs = {{8, 1}, {8, 1}, {8, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
virtual_dataset->Init(strategy, nullptr);