p85620714
/
mindspore
forked from mindspore-Ecosystem/mindspore
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

change type of Shape from int32 to int64

This commit is contained in:
Yi Huaijie 2020-07-15 11:39:10 +08:00
parent 2da29bce66
commit 518cb80133
95 changed files with 1163 additions and 1164 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
mindspore/ccsrc/frontend/operator/prim_nn.cc
View File

@ -402,31 +402,36 @@ AbstractBasePtr InferImplDropoutGenMask(const AnalysisEnginePtr &, const Primiti
for (std::size_t i = 0; i < x_shape->size(); ++i) {
auto value_track = x_shape_data[i]->GetValueTrack();
MS_EXCEPTION_IF_NULL(value_track);
if (!value_track->isa<Int32Imm>()) {
MS_LOG(EXCEPTION) << "DropOutGenMask input x_shape elements is not int32, but " << value_track->ToString() << ".";
int64_t e_value = 0;
if (value_track->isa<Int64Imm>()) {
e_value = GetValue<int64_t>(value_track);
} else if (value_track->isa<Int32Imm>()) {
e_value = static_cast<int64_t>(GetValue<int>(value_track));
} else {
MS_LOG(EXCEPTION) << "DropOutGenMask input x_shape elements is not int64 or int32, but "
<< value_track->ToString() << ".";
}
int e_value = GetValue<int>(value_track);
if (e_value <= 0) {
MS_LOG(EXCEPTION) << "DropOutGenMask product of x_shape should be > 0";
}
if (std::numeric_limits<int>::max() / count / e_value < 1) {
if (std::numeric_limits<int64_t>::max() / count / e_value < 1) {
MS_LOG(EXCEPTION) << "integer multiply integer overflow";
}
count = count * e_value;
}
// convert to bytes(8 bits) mask, using round up
int n128s = count / 128;
int64_t n128s = count / 128;
if ((count % 128) != 0) {
n128s++;
}
int bytes_count = n128s * 16;
std::vector<int> shape_y{bytes_count};
int64_t bytes_count = n128s * 16;
std::vector<int64_t> shape_y{bytes_count};
primitive->set_attr("T", kInt32);
return std::make_shared<AbstractTensor>(std::make_shared<AbstractScalar>(kAnyValue, kUInt8),
std::make_shared<Shape>(std::vector<int>{shape_y}));
std::make_shared<Shape>(std::vector<int64_t>{shape_y}));
}
} // namespace abstract
} // namespace mindspore

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

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

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

@ -45,10 +45,9 @@ void GenerateStrategy(const std::shared_ptr<Graph> &graph, const std::vector<std
GenerateRemainingOperatorStrategy(graph, ops, input_tensor_names, index_list, no_stra_op_list);
}
std::vector<std::vector<int32_t>> 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) {
std::vector<std::vector<int32_t>> strategies;
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;
auto attrs = ops[iter_ops]->attrs();
bool transpose_a = attrs[TRANSPOSE_A]->cast<BoolImmPtr>()->value();
bool transpose_b = attrs[TRANSPOSE_B]->cast<BoolImmPtr>()->value();
@ -105,41 +104,40 @@ std::vector<std::vector<int32_t>> PrepareMatMul(const std::shared_ptr<Graph> &gr
}
for (size_t iter_op_inputs = 0; iter_op_inputs < ops[iter_ops]->inputs_tensor_info().size(); iter_op_inputs++) {
std::vector<int32_t> s;
Dimensions s;
if (transpose_a && (iter_op_inputs == 0)) {
s.push_back(
static_cast<int32_t>(1.0 / graph->nodes[iter_graph].apply.arguments[iter_op_inputs].tensor_str.str_w));
static_cast<int64_t>(1.0 / graph->nodes[iter_graph].apply.arguments[iter_op_inputs].tensor_str.str_w));
s.push_back(
static_cast<int32_t>(1.0 / graph->nodes[iter_graph].apply.arguments[iter_op_inputs].tensor_str.str_h));
static_cast<int64_t>(1.0 / graph->nodes[iter_graph].apply.arguments[iter_op_inputs].tensor_str.str_h));
} else if (transpose_b && (iter_op_inputs == 1)) {
s.push_back(
static_cast<int32_t>(1.0 / graph->nodes[iter_graph].apply.arguments[iter_op_inputs].tensor_str.str_w));
static_cast<int64_t>(1.0 / graph->nodes[iter_graph].apply.arguments[iter_op_inputs].tensor_str.str_w));
s.push_back(
static_cast<int32_t>(1.0 / graph->nodes[iter_graph].apply.arguments[iter_op_inputs].tensor_str.str_h));
static_cast<int64_t>(1.0 / graph->nodes[iter_graph].apply.arguments[iter_op_inputs].tensor_str.str_h));
} else {
s.push_back(
static_cast<int32_t>(1.0 / graph->nodes[iter_graph].apply.arguments[iter_op_inputs].tensor_str.str_h));
static_cast<int64_t>(1.0 / graph->nodes[iter_graph].apply.arguments[iter_op_inputs].tensor_str.str_h));
s.push_back(
static_cast<int32_t>(1.0 / graph->nodes[iter_graph].apply.arguments[iter_op_inputs].tensor_str.str_w));
static_cast<int64_t>(1.0 / graph->nodes[iter_graph].apply.arguments[iter_op_inputs].tensor_str.str_w));
}
strategies.push_back(s);
}
return strategies;
}
std::vector<std::vector<int32_t>> PrepareBiasAdd(const std::shared_ptr<std::vector<int32_t>> &s) {
std::vector<std::vector<int32_t>> strategies;
Strategys PrepareBiasAdd(const std::shared_ptr<Dimensions> &s) {
Strategys strategies;
strategies.push_back(*s);
std::vector<int32_t> s_biasadd;
Dimensions s_biasadd;
s_biasadd.push_back(s->at(1));
strategies.push_back(s_biasadd);
return strategies;
}
std::vector<std::vector<int32_t>> PrepareOneHot(const std::shared_ptr<Graph> &graph,
const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const size_t iter_graph, const size_t iter_ops) {
std::vector<std::vector<int32_t>> strategies = MakeRecSearchStrategy(graph, ops, iter_graph, iter_ops);
Strategys PrepareOneHot(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);
int32_t axis = -1;
auto iter = ops[iter_ops]->attrs().find(AXIS);
@ -158,15 +156,14 @@ std::vector<std::vector<int32_t>> PrepareOneHot(const std::shared_ptr<Graph> &gr
graph->nodes[iter_graph].tensor_parm.tensor_str.str_w = 1.0;
}
std::vector<int32_t> s_empty = {};
Dimensions s_empty = {};
strategies.push_back(s_empty);
strategies.push_back(s_empty);
return strategies;
}
std::vector<std::vector<int32_t>> PrepareGatherV2(const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const size_t iter_ops, std::vector<int32_t> s) {
std::vector<std::vector<int32_t>> strategies;
Strategys PrepareGatherV2(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops, Dimensions s) {
Strategys strategies;
auto axis_input = GetValue<int>(ops[iter_ops]->input_value().at(2));
if (axis_input < 0) {
@ -185,7 +182,7 @@ std::vector<std::vector<int32_t>> PrepareGatherV2(const std::vector<std::shared_
return strategies;
}
std::vector<int32_t> s_indices;
Dimensions s_indices;
for (size_t i = 0; i < ops[iter_ops]->inputs_tensor_info()[1].shape().size(); i++) {
s_indices.push_back(1);
}
@ -194,8 +191,8 @@ std::vector<std::vector<int32_t>> PrepareGatherV2(const std::vector<std::shared_
return strategies;
}
std::vector<std::vector<int32_t>> PrepareL2Normalize(const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const size_t iter_ops, std::vector<int32_t> s) {
Strategys PrepareL2Normalize(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops,
Dimensions s) {
int32_t axis = 0;
auto iter = ops[iter_ops]->attrs().find(AXIS);
if (iter != ops[iter_ops]->attrs().end()) {
@ -215,14 +212,14 @@ std::vector<std::vector<int32_t>> PrepareL2Normalize(const std::vector<std::shar
s[IntToSize(axis_index)] = 1;
std::vector<std::vector<int32_t>> strategies;
Strategys strategies;
strategies.push_back(s);
return strategies;
}
std::vector<std::vector<int32_t>> 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 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.";
}
@ -231,31 +228,31 @@ std::vector<std::vector<int32_t>> MakeRecSearchStrategy(const std::shared_ptr<Gr
}
StrategyPtr origin_strategy = ops[iter_ops]->strategy();
std::vector<std::vector<int32_t>> strategies;
Strategys 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.";
}
size_t output_size = origin_strategy->GetInputDim()[iter_op_inputs].size();
std::vector<int32_t> s;
Dimensions s;
if (output_size == 4) {
s.push_back(
static_cast<int32_t>(1.0 / graph->nodes[iter_graph].apply.arguments[iter_op_inputs].tensor_str.str_n));
static_cast<int64_t>(1.0 / graph->nodes[iter_graph].apply.arguments[iter_op_inputs].tensor_str.str_n));
s.push_back(
static_cast<int32_t>(1.0 / graph->nodes[iter_graph].apply.arguments[iter_op_inputs].tensor_str.str_c));
static_cast<int64_t>(1.0 / graph->nodes[iter_graph].apply.arguments[iter_op_inputs].tensor_str.str_c));
s.push_back(
static_cast<int32_t>(1.0 / graph->nodes[iter_graph].apply.arguments[iter_op_inputs].tensor_str.str_h));
static_cast<int64_t>(1.0 / graph->nodes[iter_graph].apply.arguments[iter_op_inputs].tensor_str.str_h));
s.push_back(
static_cast<int32_t>(1.0 / graph->nodes[iter_graph].apply.arguments[iter_op_inputs].tensor_str.str_w));
static_cast<int64_t>(1.0 / graph->nodes[iter_graph].apply.arguments[iter_op_inputs].tensor_str.str_w));
} else if (output_size == 2) {
s.push_back(
static_cast<int32_t>(1.0 / graph->nodes[iter_graph].apply.arguments[iter_op_inputs].tensor_str.str_h));
static_cast<int64_t>(1.0 / graph->nodes[iter_graph].apply.arguments[iter_op_inputs].tensor_str.str_h));
s.push_back(
static_cast<int32_t>(1.0 / graph->nodes[iter_graph].apply.arguments[iter_op_inputs].tensor_str.str_w));
static_cast<int64_t>(1.0 / graph->nodes[iter_graph].apply.arguments[iter_op_inputs].tensor_str.str_w));
} else if (output_size == 1) {
s.push_back(
static_cast<int32_t>(1.0 / graph->nodes[iter_graph].apply.arguments[iter_op_inputs].tensor_str.str_w));
static_cast<int64_t>(1.0 / graph->nodes[iter_graph].apply.arguments[iter_op_inputs].tensor_str.str_w));
} else if (output_size == 0) {
s = {};
} else {
@ -266,9 +263,9 @@ std::vector<std::vector<int32_t>> MakeRecSearchStrategy(const std::shared_ptr<Gr
return strategies;
}
std::vector<std::vector<int32_t>> 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 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.";
}
@ -277,7 +274,7 @@ std::vector<std::vector<int32_t>> MakeDataParallelStrategy(const std::shared_ptr
}
StrategyPtr origin_strategy = ops[iter_ops]->strategy();
std::vector<std::vector<int32_t>> strategies;
Strategys 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++) {
@ -285,7 +282,7 @@ std::vector<std::vector<int32_t>> MakeDataParallelStrategy(const std::shared_ptr
MS_LOG(EXCEPTION) << "Failure: Strategy's InputDim out of range.";
}
std::vector<int32_t> s;
Dimensions s;
size_t input_size = origin_strategy->GetInputDim()[iter_op_inputs].size();
for (size_t dim = 0; dim < input_size; dim++) {
if (input_size == 1 || input_size == 2 || input_size == 4) {
@ -318,9 +315,8 @@ std::vector<std::vector<int32_t>> MakeDataParallelStrategy(const std::shared_ptr
return strategies;
}
std::vector<std::vector<int32_t>> 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) {
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) {
if (ops.empty()) {
MS_LOG(EXCEPTION) << "Failure: Operators is empty.";
}
@ -348,7 +344,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++) {
std::vector<std::vector<int32_t>> strategies;
Strategys 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);
@ -375,10 +371,10 @@ size_t FindIndexOfOperatorIncoming(const std::vector<std::vector<std::string>> &
return incoming_op_index;
}
std::vector<int32_t> CopyIncomingOperatorOutputStrategy(const std::shared_ptr<Graph> &graph,
const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const size_t iter_ops, const size_t iter_graph) {
std::vector<int32_t> s;
Dimensions CopyIncomingOperatorOutputStrategy(const std::shared_ptr<Graph> &graph,
const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const size_t iter_ops, const size_t iter_graph) {
Dimensions s;
for (auto input : ops[iter_ops]->inputs_tensor_info()) {
auto input_stra_dim = input.shape().size();
if (input_stra_dim == 0) {
@ -402,9 +398,9 @@ std::vector<int32_t> CopyIncomingOperatorOutputStrategy(const std::shared_ptr<Gr
return s;
}
std::vector<int32_t> PrepareIncomingOperatorInputStrategy(const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const size_t incoming_op_index) {
std::vector<int32_t> s;
Dimensions PrepareIncomingOperatorInputStrategy(const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const size_t incoming_op_index) {
Dimensions s;
if (ops[incoming_op_index]->type() == RESHAPE || ops[incoming_op_index]->type() == GATHERV2 ||
ops[incoming_op_index]->type() == TRANSPOSE) {
return s;
@ -426,8 +422,8 @@ std::vector<int32_t> PrepareIncomingOperatorInputStrategy(const std::vector<std:
return s;
}
std::vector<int32_t> GetAxisList(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const int iter_ops) {
std::vector<int32_t> axis_list;
Dimensions GetAxisList(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const int iter_ops) {
Dimensions axis_list;
auto axis_param = ops[iter_ops]->attrs().find(AXIS)->second;
std::vector<ValuePtr> elements;
if (axis_param->isa<ValueTuple>()) {
@ -448,10 +444,10 @@ std::vector<int32_t> GetAxisList(const std::vector<std::shared_ptr<OperatorInfo>
return axis_list;
}
std::vector<int32_t> ModifyStrategyIfSqueezeIncoming(const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const size_t incoming_op_index, std::vector<int32_t> s) {
std::vector<int32_t> s_Squeeze;
std::vector<int32_t> stra_dim_list;
Dimensions ModifyStrategyIfSqueezeIncoming(const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const size_t incoming_op_index, Dimensions s) {
Dimensions s_Squeeze;
Dimensions stra_dim_list;
for (size_t i = 0; i < s.size(); i++) {
stra_dim_list.push_back(i);
}
@ -488,8 +484,8 @@ bool GetKeepDims(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const si
return keepdims;
}
std::vector<int32_t> GetDimList(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops) {
std::vector<int32_t> dim_list;
Dimensions GetDimList(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops) {
Dimensions dim_list;
bool keep_dims = GetKeepDims(ops, iter_ops);
if (keep_dims != false) {
return dim_list;
@ -513,10 +509,10 @@ std::vector<int32_t> GetDimList(const std::vector<std::shared_ptr<OperatorInfo>>
return dim_list;
}
std::vector<int32_t> ModifyStrategyIfReduceIncoming(const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const size_t incoming_op_index, std::vector<int32_t> s) {
std::vector<int32_t> s_Reduce;
std::vector<int32_t> axis_list;
Dimensions ModifyStrategyIfReduceIncoming(const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const size_t incoming_op_index, Dimensions s) {
Dimensions s_Reduce;
Dimensions axis_list;
for (size_t i = 0; i < s.size(); i++) {
axis_list.push_back(i);
}
@ -536,8 +532,8 @@ std::vector<int32_t> ModifyStrategyIfReduceIncoming(const std::vector<std::share
return s_Reduce;
}
std::vector<int32_t> GetDimListFromAttrs(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops) {
std::vector<int32_t> dim_list;
Dimensions GetDimListFromAttrs(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops) {
Dimensions dim_list;
auto iter = ops[iter_ops]->attrs().find(AXIS);
if (iter == ops[iter_ops]->attrs().end()) {
MS_LOG(EXCEPTION) << ops[iter_ops]->name() << ": Don't have attr axis.";
@ -564,15 +560,15 @@ std::vector<int32_t> GetDimListFromAttrs(const std::vector<std::shared_ptr<Opera
return dim_list;
}
std::vector<int32_t> ModifyStrategyIfArgIncoming(const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const size_t incoming_op_index, std::vector<int32_t> s) {
Dimensions ModifyStrategyIfArgIncoming(const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const size_t incoming_op_index, Dimensions s) {
bool keepdims = GetKeepDims(ops, incoming_op_index);
if (keepdims) {
return s;
}
std::vector<int32_t> s_Arg;
std::vector<int32_t> axis_list;
Dimensions s_Arg;
Dimensions axis_list;
for (size_t i = 0; i < s.size(); i++) {
axis_list.push_back(i);
}
@ -592,9 +588,9 @@ std::vector<int32_t> ModifyStrategyIfArgIncoming(const std::vector<std::shared_p
return s_Arg;
}
std::vector<int32_t> CopyIncomingOperatorInputStrategy(const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const size_t iter_ops, const size_t incoming_op_index) {
std::vector<int32_t> s;
Dimensions CopyIncomingOperatorInputStrategy(const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const size_t iter_ops, const size_t incoming_op_index) {
Dimensions s;
s = PrepareIncomingOperatorInputStrategy(ops, incoming_op_index);
if (s.size() != 0) {
if (ops[incoming_op_index]->type() == SQUEEZE) {
@ -611,10 +607,9 @@ std::vector<int32_t> CopyIncomingOperatorInputStrategy(const std::vector<std::sh
return s;
}
std::vector<std::vector<int32_t>> GenerateStrategiesFromStrategy(const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const size_t iter_ops,
std::vector<int32_t> basic_stra) {
std::vector<std::vector<int32_t>> stra;
Strategys GenerateStrategiesFromStrategy(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops,
Dimensions basic_stra) {
Strategys stra;
MS_EXCEPTION_IF_NULL(ops[iter_ops]);
if (basic_stra.size() == 0) {
@ -625,7 +620,7 @@ std::vector<std::vector<int32_t>> GenerateStrategiesFromStrategy(const std::vect
return stra;
}
auto s_ptr = std::make_shared<std::vector<int32_t>>(basic_stra);
auto s_ptr = std::make_shared<Dimensions>(basic_stra);
if (ops[iter_ops]->type() == BIAS_ADD) {
return PrepareBiasAdd(s_ptr);
}
@ -644,9 +639,8 @@ std::vector<std::vector<int32_t>> GenerateStrategiesFromStrategy(const std::vect
}
// Function to deal with ops with broadcasting, like TensorAdd/Sub/Mul/Div etc.
std::vector<std::vector<int32_t>> CheckBroadcast(const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const size_t iter_ops, std::vector<int32_t> s) {
std::vector<std::vector<int32_t>> stra;
Strategys CheckBroadcast(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops, Dimensions s) {
Strategys 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();
@ -671,11 +665,10 @@ std::vector<std::vector<int32_t>> CheckBroadcast(const std::vector<std::shared_p
return stra;
}
std::vector<int32_t> ApplyBroadcast(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops,
std::vector<int32_t> s, size_t target_tensor_dim, size_t refer_tensor_dim,
bool braoadcast_first_tensor) {
std::vector<int32_t> s_empty = {};
std::vector<int32_t> s_broadcast;
Dimensions ApplyBroadcast(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops, Dimensions s,
size_t target_tensor_dim, size_t refer_tensor_dim, bool braoadcast_first_tensor) {
Dimensions s_empty = {};
Dimensions s_broadcast;
int target_tensor_index = 0;
int refer_tensor_index = 0;
@ -719,10 +712,10 @@ std::vector<int32_t> ApplyBroadcast(const std::vector<std::shared_ptr<OperatorIn
}
// Check whether the operator can be divided by the current strategy.
std::vector<std::vector<int32_t>> CheckDivisible(const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const size_t iter_ops, std::vector<int32_t> basic_stra) {
std::vector<int32_t> s_empty = {};
std::vector<std::vector<int32_t>> stra;
Strategys CheckDivisible(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops,
Dimensions basic_stra) {
Dimensions s_empty = {};
Strategys 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();
@ -733,7 +726,7 @@ std::vector<std::vector<int32_t>> CheckDivisible(const std::vector<std::shared_p
continue;
}
std::vector<int32_t> tmp_stra = basic_stra;
Dimensions tmp_stra = basic_stra;
bool modified = false;
// Make sure each tensor's dim shape is greater than 1. If not, push back strategy as 1 instead.
@ -765,8 +758,8 @@ 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);
std::vector<std::vector<int32_t>> stra;
std::vector<int32_t> s;
Strategys stra;
Dimensions s;
size_t incoming_op_index = FindIndexOfOperatorIncoming(input_tensor_names, iter_ops);
if (incoming_op_index != SIZE_MAX) {
auto iter_graph = index_list->at(incoming_op_index);
@ -793,9 +786,9 @@ void GenerateEliminatedOperatorStrategyForward(const std::shared_ptr<Graph> &gra
}
}
std::vector<int32_t> ModifyStrategyIfSqueezeOutgoing(const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const size_t iter_ops, std::vector<int32_t> s) {
std::vector<int32_t> s_Squeeze;
Dimensions ModifyStrategyIfSqueezeOutgoing(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops,
Dimensions s) {
Dimensions s_Squeeze;
auto axis_list = GetAxisList(ops, iter_ops);
size_t s_index = 0;
size_t axis_list_index = 0;
@ -820,10 +813,10 @@ std::vector<int32_t> ModifyStrategyIfSqueezeOutgoing(const std::vector<std::shar
return s_Squeeze;
}
std::vector<int32_t> CopyOutgoingOperatorInputStrategy(const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const std::vector<std::vector<std::string>> &input_tensor_names,
const size_t iter_ops) {
std::vector<int32_t> s;
Dimensions CopyOutgoingOperatorInputStrategy(const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const std::vector<std::vector<std::string>> &input_tensor_names,
const size_t iter_ops) {
Dimensions s;
if (ops[iter_ops]->type() == REDUCE_MAX || ops[iter_ops]->type() == REDUCE_MIN ||
ops[iter_ops]->type() == REDUCE_SUM || ops[iter_ops]->type() == REDUCE_MEAN || ops[iter_ops]->type() == RESHAPE ||
ops[iter_ops]->type() == GATHERV2 || ops[iter_ops]->type() == TRANSPOSE ||
@ -867,8 +860,8 @@ 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);
std::vector<std::vector<int32_t>> stra;
std::vector<int32_t> s = CopyOutgoingOperatorInputStrategy(ops, input_tensor_names, iter_ops);
Strategys 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);
@ -907,8 +900,8 @@ 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);
std::vector<std::vector<int32_t>> stra;
std::vector<int32_t> s;
Strategys stra;
Dimensions s;
size_t max_dim_num = 0;
for (size_t iter_op_inputs = 0; iter_op_inputs < ops[iter_ops]->inputs_tensor_info().size(); iter_op_inputs++) {

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

@ -31,68 +31,60 @@ void GenerateStrategy(const std::shared_ptr<Graph> &graph, const std::vector<std
const std::shared_ptr<std::vector<std::vector<size_t>>> &eli_list,
const std::vector<std::vector<std::string>> &input_tensor_names,
const std::shared_ptr<std::vector<size_t>> &index_list);
std::vector<std::vector<int32_t>> 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);
std::vector<std::vector<int32_t>> PrepareBiasAdd(const std::shared_ptr<std::vector<int32_t>> &s);
std::vector<std::vector<int32_t>> PrepareOneHot(const std::shared_ptr<Graph> &graph,
const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const size_t iter_graph, const size_t iter_ops);
std::vector<std::vector<int32_t>> PrepareGatherV2(const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const size_t iter_ops, std::vector<int32_t> s);
std::vector<std::vector<int32_t>> PrepareL2Normalize(const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const size_t iter_ops, std::vector<int32_t> s);
std::vector<std::vector<int32_t>> CheckBroadcast(const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const size_t iter_ops, std::vector<int32_t> s);
std::vector<int32_t> ApplyBroadcast(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops,
std::vector<int32_t> s, size_t target_tensor_dim, size_t refer_tensor_dim,
bool braoadcast_first_tensor);
std::vector<std::vector<int32_t>> CheckDivisible(const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const size_t iter_ops, std::vector<int32_t> s);
std::vector<std::vector<int32_t>> 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);
std::vector<std::vector<int32_t>> 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);
std::vector<std::vector<int32_t>> 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);
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 PrepareOneHot(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);
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);
Dimensions ApplyBroadcast(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops, Dimensions s,
size_t target_tensor_dim, size_t refer_tensor_dim, bool braoadcast_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 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);
size_t FindIndexOfOperatorIncoming(const std::vector<std::vector<std::string>> &input_tensor_names,
const size_t iter_ops);
std::vector<int32_t> CopyIncomingOperatorOutputStrategy(const std::shared_ptr<Graph> &graph,
const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const size_t iter_ops, const size_t iter_graph);
std::vector<int32_t> PrepareIncomingOperatorInputStrategy(const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const size_t incoming_op_index);
std::vector<int32_t> GetAxisList(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const int iter_ops);
std::vector<int32_t> ModifyStrategyIfSqueezeIncoming(const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const size_t incoming_op_index, std::vector<int32_t> s);
Dimensions CopyIncomingOperatorOutputStrategy(const std::shared_ptr<Graph> &graph,
const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const size_t iter_ops, const size_t iter_graph);
Dimensions PrepareIncomingOperatorInputStrategy(const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const size_t incoming_op_index);
Dimensions GetAxisList(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const int iter_ops);
Dimensions ModifyStrategyIfSqueezeIncoming(const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const size_t incoming_op_index, Dimensions s);
bool GetKeepDims(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops);
std::vector<int32_t> GetDimList(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops);
std::vector<int32_t> ModifyStrategyIfReduceIncoming(const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const size_t incoming_op_index, std::vector<int32_t> s);
std::vector<int32_t> GetDimListFromAttrs(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops);
std::vector<int32_t> ModifyStrategyIfArgIncoming(const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const size_t incoming_op_index, std::vector<int32_t> s);
std::vector<int32_t> CopyIncomingOperatorInputStrategy(const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const size_t iter_ops, const size_t incoming_op_index);
std::vector<std::vector<int32_t>> GenerateStrategiesFromStrategy(const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const size_t iter_ops,
std::vector<int32_t> basic_stra);
Dimensions GetDimList(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops);
Dimensions ModifyStrategyIfReduceIncoming(const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const size_t incoming_op_index, Dimensions s);
Dimensions GetDimListFromAttrs(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops);
Dimensions ModifyStrategyIfArgIncoming(const std::vector<std::shared_ptr<OperatorInfo>> &ops,
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);
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,
const std::shared_ptr<std::vector<size_t>> &index_list,
const std::shared_ptr<std::vector<size_t>> &no_stra_op_list);
std::vector<int32_t> ModifyStrategyIfSqueezeOutgoing(const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const size_t iter_ops, std::vector<int32_t> s);
std::vector<int32_t> CopyOutgoingOperatorInputStrategy(const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const std::vector<std::vector<std::string>> &input_tensor_names,
const size_t iter_ops);
Dimensions ModifyStrategyIfSqueezeOutgoing(const std::vector<std::shared_ptr<OperatorInfo>> &ops, const size_t iter_ops,
Dimensions s);
Dimensions CopyOutgoingOperatorInputStrategy(const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const std::vector<std::vector<std::string>> &input_tensor_names,
const size_t iter_ops);
void GenerateEliminatedOperatorStrategyBackward(const std::vector<std::shared_ptr<OperatorInfo>> &ops,
const std::vector<std::vector<std::string>> &input_tensor_names,
const std::shared_ptr<std::vector<size_t>> &no_stra_op_list);

6
mindspore/ccsrc/frontend/parallel/context.cc
View File

@ -29,7 +29,7 @@
namespace mindspore {
namespace parallel {
static std::map<std::string, std::vector<int>> param_shapes;
static std::map<std::string, Shape> param_shapes;
std::vector<std::string> PARALLEL_MODE_LIST = {STAND_ALONE, DATA_PARALLEL, HYBRID_PARALLEL, SEMI_AUTO_PARALLEL,
AUTO_PARALLEL};
@ -173,7 +173,7 @@ void ParallelParameterContextRestoreInNoTraining(const FuncGraphPtr &func_graph,
MS_LOG(WARNING) << "Can not found the shape for parameter " << param_node->name();
return;
}
std::vector<int> shape = iter->second;
Shape shape = iter->second;
std::shared_ptr<abstract::BaseShape> base_shape = std::make_shared<abstract::Shape>(shape);
ptr->set_shape(base_shape);
MS_LOG(DEBUG) << "The parameter name is " << param_node->name() << ", the shape is " << shape;
@ -189,7 +189,7 @@ void ParallelParameterContextCkptInTraining(const FuncGraphPtr &func_graph, cons
return;
}
std::vector<int> shape = dyn_cast<abstract::Shape>(ptr->GetShapeTrack())->shape();
Shape shape = dyn_cast<abstract::Shape>(ptr->GetShapeTrack())->shape();
auto ret = param_shapes.try_emplace(param_node->name(), shape);
if (!ret.second) {
MS_LOG(EXCEPTION) << "The shape for parameter name " << param_node->name() << " is existed";

2
mindspore/ccsrc/frontend/parallel/device_matrix.cc
View File

@ -159,7 +159,7 @@ std::string ShapeToString(const Shape &shape) {
return str + "]";
}
std::string ListToString(const std::vector<int32_t> &list) {
std::string ListToString(const RankList &list) {
std::string str = "[";
for (auto &element : list) {
str += std::to_string(element) + ", ";

4
mindspore/ccsrc/frontend/parallel/device_matrix.h
View File

@ -27,7 +27,7 @@
namespace mindspore {
namespace parallel {
using RankList = std::vector<int32_t>;
using Shape = std::vector<int32_t>;
using Shape = std::vector<int64_t>;
class DeviceMatrix {
public:
@ -48,7 +48,7 @@ class DeviceMatrix {
};
std::string ShapeToString(const Shape &shape);
std::string ListToString(const std::vector<int32_t> &list);
std::string ListToString(const RankList &list);
} // namespace parallel
} // namespace mindspore

4
mindspore/ccsrc/frontend/parallel/graph_util/get_parallel_info.cc
View File

@ -45,13 +45,13 @@ py::dict GetParameterLayout(const FuncGraphPtr &graph) {
auto tensor_map = tensor_layout->tensor_map().array();
auto slice_shape = tensor_layout->slice_shape().array();
int32_t _field_size = tensor_layout->get_field_size();
std::vector<int32_t> field_size;
Shape field_size;
if (_field_size != 0) {
field_size.push_back(_field_size);
} else {
field_size = {0};
}
std::vector<std::vector<int32_t>> layout = {device_arrangement, tensor_map, slice_shape, field_size};
std::vector<Shape> layout = {device_arrangement, tensor_map, slice_shape, field_size};
dict[py::str(name)] = layout;
MS_LOG(INFO) << "GetParameterLayout name = " << name << ", layout " << tensor_layout->ToString();
}

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

@ -130,7 +130,7 @@ Status Softmax::CheckStrategy(const StrategyPtr &strategy) {
return FAILED;
}
std::vector<Dimensions> stra = strategy->GetInputDim();
Strategys stra = strategy->GetInputDim();
Dimensions input_strategy = stra.at(0);
for (auto &element : axis_) {
@ -176,12 +176,12 @@ Status Softmax::GetAttrs() {
}
std::vector<ValuePtr> value_vector = value_tuple->value();
(void)std::transform(value_vector.begin(), value_vector.end(), std::back_inserter(axis_),
[](const ValuePtr &value) { return static_cast<int32_t>(GetValue<int>(value)); });
[](const ValuePtr &value) { return static_cast<int32_t>(GetValue<int64_t>(value)); });
if (axis_.empty()) {
MS_LOG(ERROR) << name_ << " : The axis tuple is empty.";
return FAILED;
}
MS_LOG(INFO) << name_ << " : The axis is tuple, value is " << ShapeToString(axis_);
MS_LOG(INFO) << name_ << " : The axis is tuple, value is " << ListToString(axis_);
} else {
MS_LOG(ERROR) << name_ << " : The value of axis is not int or tuple int.";
return FAILED;
@ -258,7 +258,7 @@ Status Softmax::GenerateStrategies(int32_t stage_id) {
}
Status ActivationBase::InferDevMatrixShape() {
std::vector<Dimensions> stra = strategy_->GetInputDim();
Strategys stra = strategy_->GetInputDim();
Dimensions input_strategy = stra.at(0);
dev_matrix_shape_ = input_strategy;
@ -296,11 +296,11 @@ Status ActivationBase::InferForwardCommunication() {
}
Status ActivationBase::InferTensorMap() {
std::vector<int32_t> tensor_map_index;
Shape tensor_map_index;
size_t size = inputs_shape_.at(0).size();
// such as 4: tensor_map_index [3,2,1,0]
for (size_t i = 0; i < size; ++i) {
tensor_map_index.push_back((int32_t)(size - i - 1));
tensor_map_index.push_back((int64_t)(size - i - 1));
}
inputs_tensor_map_.push_back(tensor_map_index);
@ -425,7 +425,7 @@ Status ExpandDimsInfo::InferTensorMap() {
// for example: if the dimension of input is 3, and the axis is 2,
// then the input_tensor_map is [2, 1, 0], the output_tensor_map is [2, 1, -1, 0]
std::vector<int32_t> input_tensor_map, output_tensor_map;
Shape input_tensor_map, output_tensor_map;
size_t size = inputs_shape_[0].size();
for (size_t i = 0; i < size; ++i) {
input_tensor_map.push_back(SizeToInt(size - i - 1));
@ -607,7 +607,7 @@ Status SqueezeInfo::InferReplaceOps(const StrategyPtr &strategy) {
Status SqueezeInfo::InferTensorMap() {
// for example: if the shape of input is [32, 32, 1], and the axis is (2, ),
// then the input_tensor_map is [2, 1, 0], the output_tensor_map is [2, 1]
std::vector<int32_t> input_tensor_map, output_tensor_map;
Shape input_tensor_map, output_tensor_map;
if (inputs_shape_.empty()) {
MS_LOG(ERROR) << name_ << ": The inputs shape is empty";
return FAILED;

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

@ -54,9 +54,9 @@ Shapes ArithmeticBase::InferExpendShape() {
return input_shapes;
}
std::vector<Dimensions> ExpendStrategy(const StrategyPtr &strategy) {
std::vector<Dimensions> expend_strategy;
std::vector<Dimensions> stra = strategy->GetInputDim();
Strategys ExpendStrategy(const StrategyPtr &strategy) {
Strategys expend_strategy;
Strategys 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();
@ -83,7 +83,7 @@ Status ArithmeticBase::CheckStrategy(const StrategyPtr &strategy) {
return FAILED;
}
Shapes input_shapes = InferExpendShape();
std::vector<Dimensions> expend_strategy = ExpendStrategy(strategy);
Strategys expend_strategy = ExpendStrategy(strategy);
Dimensions sub_a_strategy = expend_strategy.at(0);
Dimensions sub_b_strategy = expend_strategy.at(1);
Shape input_a_shape = input_shapes.at(0);
@ -103,7 +103,7 @@ Status ArithmeticBase::CheckStrategy(const StrategyPtr &strategy) {
}
Status ArithmeticBase::InferDevMatrixShape() {
std::vector<Dimensions> expend_strategy = ExpendStrategy(strategy_);
Strategys expend_strategy = ExpendStrategy(strategy_);
Dimensions sub_a_strategy = expend_strategy.at(0);
Dimensions sub_b_strategy = expend_strategy.at(1);
Shape dev_shape;
@ -123,7 +123,7 @@ TensorMap SetExpendTensorMap(const Shape &strategy, const Shape &dev_matrix_shap
TensorMap tensor_map_index;
for (size_t i = 0; i < strategy.size(); ++i) {
if (strategy[i] == dev_matrix_shape[i]) {
tensor_map_index.push_back((int32_t)(LAST_INDEX(SizeToUint(strategy.size())) - i));
tensor_map_index.push_back((int64_t)(LAST_INDEX(strategy.size()) - i));
} else {
tensor_map_index.push_back(-1);
}
@ -159,15 +159,15 @@ void ArithmeticBase::ReComputeBatchSplitFlagList() {
}
Status ArithmeticBase::InferTensorMap() {
std::vector<int32_t> tensor_map_index;
std::vector<Dimensions> expend_strategy = ExpendStrategy(strategy_);
Shape tensor_map_index;
Strategys expend_strategy = ExpendStrategy(strategy_);
Dimensions sub_a_expend_strategy = expend_strategy.at(0);
Dimensions sub_b_expend_strategy = expend_strategy.at(1);
Strategys 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_expend_strategy.size(); ++i) {
tensor_map_index.push_back((int32_t)(LAST_INDEX(SizeToUint(sub_a_expend_strategy.size())) - i));
tensor_map_index.push_back((int64_t)(LAST_INDEX(sub_a_expend_strategy.size()) - i));
}
Shape dev_shape;
@ -261,7 +261,7 @@ Status ArithmeticBase::InferTensorInfo() {
// infer slice shape
Shapes inputs_slice_shape, outputs_slice_shape;
std::vector<Dimensions> expend_strategy = ExpendStrategy(strategy_);
Strategys expend_strategy = ExpendStrategy(strategy_);
Dimensions sub_a_expend_strategy = expend_strategy.at(0);
Dimensions sub_b_expend_strategy = expend_strategy.at(1);
Strategys inputs_strategy = strategy_->GetInputDim();

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

@ -43,13 +43,13 @@ Status BatchParallelInfo::CheckStrategy(const StrategyPtr &strategy) {
dev_num_ = dev_num;
size_t strategy_size = strategy->GetInputNumber();
std::vector<Dimensions> stra = strategy->GetInputDim();
Strategys 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();
bool flag = false;
for (size_t j = 0; j < strategy_len; ++j) {
int32_t strategy_value = sub_strategy.at(j);
int64_t strategy_value = sub_strategy.at(j);
if (strategy_value > 1) {
if (flag || strategy_value != dev_num_) {
if (is_auto_parallel_) {
@ -95,7 +95,7 @@ Status BatchParallelInfo::InferTensorMap() {
return FAILED;
}
for (size_t i = 0; i < inputs_shape_.size(); i++) {
std::vector<int32_t> tensor_map_index;
Shape tensor_map_index;
for (size_t j = 0; j < inputs_shape_[i].size(); ++j) {
if (strategy_->GetInputDim()[i][j] == dev_num_ && j == 0) {
tensor_map_index.push_back(0);
@ -106,7 +106,7 @@ Status BatchParallelInfo::InferTensorMap() {
inputs_tensor_map_.push_back(tensor_map_index);
}
for (size_t i = 0; i < outputs_shape_.size(); i++) {
std::vector<int32_t> tensor_map_index;
Shape tensor_map_index;
for (size_t j = 0; j < outputs_shape_[i].size(); ++j) {
if (i == 0 && j == 0) {
tensor_map_index.push_back(0);
@ -123,7 +123,7 @@ Strategys BatchParallelInfo::GetOutputsStrategy() {
Strategys outputs_strategy;
for (size_t i = 0; i < outputs_shape_.size(); ++i) {
std::vector<int32_t> strategy;
Dimensions strategy;
for (size_t j = 0; j < outputs_shape_[i].size(); ++j) {
if (i == 0 && j == 0) {
strategy.push_back(dev_num_);
@ -201,7 +201,7 @@ Status BatchParallelInfo::GenerateStrategies(int32_t stage_id) {
is_auto_parallel_ = true;
size_t total_dev_num = g_device_manager->GetDeviceListByStageId(stage_id).size();
StrategyPtr sp;
std::vector<Dimensions> strategy;
Strategys strategy;
for (size_t i = 0; i < inputs_shape_.size(); i++) {
Shape temp(inputs_shape_[i].size(), 1);
if (split_flag_list_[i]) {

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

@ -36,11 +36,11 @@ Status BiasAddInfo::CheckStrategy(const StrategyPtr &strategy) {
}
return FAILED;
}
std::vector<Dimensions> stra = strategy->GetInputDim();
Strategys stra = strategy->GetInputDim();
Dimensions sub_a_strategy = stra.at(0);
Dimensions sub_b_strategy = stra.at(1);
int32_t channel_a_strategy = sub_a_strategy.at(1);
int32_t channel_b_strategy = sub_b_strategy.at(0);
int64_t channel_a_strategy = sub_a_strategy.at(1);
int64_t channel_b_strategy = sub_b_strategy.at(0);
if (channel_a_strategy != channel_b_strategy) {
if (is_auto_parallel_) {
MS_LOG(DEBUG) << name_ << " : Invalid strategy.";
@ -53,7 +53,7 @@ Status BiasAddInfo::CheckStrategy(const StrategyPtr &strategy) {
}
Status BiasAddInfo::InferDevMatrixShape() {
std::vector<Dimensions> stra = strategy_->GetInputDim();
Strategys stra = strategy_->GetInputDim();
Dimensions sub_a_strategy = stra.at(0);
dev_matrix_shape_ = sub_a_strategy;
return SUCCESS;
@ -67,13 +67,13 @@ void BiasAddInfo::ReComputeBatchSplitFlagList() {
Status BiasAddInfo::InferTensorMap() {
TensorMap sub_a_tensor_map;
TensorMap sub_b_tensor_map;
std::vector<Dimensions> stra = strategy_->GetInputDim();
Strategys 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) {
sub_a_tensor_map.push_back((int32_t)(LAST_INDEX(SizeToUint(sub_a_strategy_size)) - i));
sub_a_tensor_map.push_back((int32_t)(LAST_INDEX(sub_a_strategy_size) - i));
}
sub_b_tensor_map.push_back((int32_t)(LAST_INDEX(SizeToUint(sub_a_strategy_size)) - 1));
sub_b_tensor_map.push_back((int32_t)(LAST_INDEX(sub_a_strategy_size) - 1));
inputs_tensor_map_.push_back(sub_a_tensor_map);
inputs_tensor_map_.push_back(sub_b_tensor_map);
@ -213,7 +213,7 @@ Status BiasAddInfo::GenerateStrategies(int32_t stage_id) {
MS_LOG(INFO) << name_ << " : Generate strategies with broadcast success.";
for (auto &sp : sp_vector) {
std::vector<Dimensions> tmp_strategy;
Strategys tmp_strategy;
Dimensions input0_strategy = sp->GetInputDim()[0];
tmp_strategy.push_back(input0_strategy); // input0

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

@ -38,7 +38,7 @@ Status DropoutDoMaskInfo::CheckStrategy(const StrategyPtr &strategy) {
return FAILED;
}
std::vector<Dimensions> stra = strategy->GetInputDim();
Strategys stra = strategy->GetInputDim();
if (stra.size() != 1) {
MS_LOG(ERROR) << name_ << ": Invalid strategy size " << stra.size() << ", it must be 1";
return FAILED;
@ -68,7 +68,7 @@ Status DropoutDoMaskInfo::InferDevMatrixShape() {
return FAILED;
}
std::vector<Dimensions> strategy = strategy_->GetInputDim();
Strategys strategy = strategy_->GetInputDim();
if (strategy.empty()) {
MS_LOG(ERROR) << name_ << ": The strategy is empty";
return FAILED;
@ -84,7 +84,7 @@ Status DropoutDoMaskInfo::InferTensorMap() {
return FAILED;
}
std::vector<int32_t> tensor_map_index;
Shape tensor_map_index;
size_t size = inputs_shape_[0].size();
// if the dimension of input is 4, and tensor_map_index is [3, 2, 1, 0]
for (size_t i = 0; i < size; ++i) {
@ -169,13 +169,13 @@ Status DropoutDoMaskInfo::GenerateStrategies(int32_t stage_id) {
return SUCCESS;
}
std::shared_ptr<std::vector<std::vector<int32_t>>> DropoutDoMaskInfo::GenerateBatchStrategies() {
std::shared_ptr<Strategys> DropoutDoMaskInfo::GenerateBatchStrategies() {
CheckGlobalDeviceManager();
size_t dev_num = g_device_manager->GetDeviceListByStageId(0).size();
Dimensions strategy(inputs_shape_[0].size() - 1, 1);
(void)strategy.insert(strategy.begin(), SizeToInt(dev_num));
std::vector<Dimensions> strategy_v = {strategy};
return std::make_shared<std::vector<std::vector<int32_t>>>(strategy_v);
Strategys strategy_v = {strategy};
return std::make_shared<Strategys>(strategy_v);
}
Status DropoutDoMaskInfo::Init(const StrategyPtr &strategy) {

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

@ -40,7 +40,7 @@ class DropoutDoMaskInfo : public OperatorInfo {
Status GenerateStrategies(int32_t stage_id) override;
Status SetCostUnderStrategy(const StrategyPtr &strategy) override;
Status InitForCostModel(const StrategyPtr &strategy) override;
std::shared_ptr<std::vector<std::vector<int32_t>>> GenerateBatchStrategies() override;
std::shared_ptr<Strategys> GenerateBatchStrategies() override;
std::vector<Operator> GetDropoutGenMaskReplaceOp(const CNodePtr &cnode);
protected:

14
mindspore/ccsrc/frontend/parallel/ops_info/gather_v2_info.cc
View File

@ -109,7 +109,7 @@ Status GatherV2Info::CheckStrategy(const StrategyPtr &strategy) {
}
Status GatherV2Info::InferDevMatrixShape() {
std::vector<Dimensions> stra = strategy_->GetInputDim();
Strategys stra = strategy_->GetInputDim();
dev_matrix_shape_ = stra.at(0);
return SUCCESS;
}
@ -129,8 +129,8 @@ Status GatherV2Info::InferTensorMap() {
<< outputs_shape_.size();
return FAILED;
}
std::vector<int32_t> tensor_map_in;
std::vector<int32_t> tensor_map_out;
Shape tensor_map_in;
Shape tensor_map_out;
size_t size = inputs_shape_.at(0).size();
// such as 4: tensor_map_index [3,2,1,0]
for (size_t i = 0; i < size; ++i) {
@ -149,7 +149,7 @@ Status GatherV2Info::InferTensorMap() {
return FAILED;
}
std::vector<int32_t> tensor_map_in_index;
Shape tensor_map_in_index;
if (index_size_ >= 1) {
tensor_map_in_index.push_back(SizeToInt(size - axis_ - 1));
}
@ -323,7 +323,7 @@ Status GatherV2Info::SetCostUnderStrategy(const StrategyPtr &strategy) {
return SUCCESS;
}
std::shared_ptr<std::vector<std::vector<int32_t>>> GatherV2Info::GenerateBatchStrategies() {
std::shared_ptr<Strategys> GatherV2Info::GenerateBatchStrategies() {
if (inputs_shape_.size() != GATHER_V2_INPUTS_SIZE) {
MS_LOG(EXCEPTION) << name_ << ": inputs shape size must be " << GATHER_V2_INPUTS_SIZE << ", but is "
<< inputs_shape_.size();
@ -343,8 +343,8 @@ std::shared_ptr<std::vector<std::vector<int32_t>>> GatherV2Info::GenerateBatchSt
for (size_t i = 1; i < inputs_shape_[0].size(); i++) {
strategy.push_back(1);
}
std::vector<Dimensions> strategy_v = {strategy};
return std::make_shared<std::vector<std::vector<int32_t>>>(strategy_v);
Strategys strategy_v = {strategy};
return std::make_shared<Strategys>(strategy_v);
}
} // namespace parallel
} // namespace mindspore

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

@ -50,7 +50,7 @@ class GatherV2Info : public OperatorInfo {
Status GenerateStrategies(int32_t stage_id) override;
Status SetCostUnderStrategy(const StrategyPtr &strategy) override;
std::shared_ptr<std::vector<std::vector<int32_t>>> GenerateBatchStrategies() override;
std::shared_ptr<Strategys> GenerateBatchStrategies() override;
protected:
Status CheckStrategy(const StrategyPtr &strategy) override;

28
mindspore/ccsrc/frontend/parallel/ops_info/gather_v2_p_info.cc
View File

@ -73,8 +73,8 @@ Status GatherV2PInfo::GetAttrs() {
MS_LOG(ERROR) << "Failure: Size of manual_split element must be 2.";
return FAILED;
}
param_split_shapes_.push_back(static_cast<int32_t>(GetValue<int>(value_vector[0])));
index_offsets_.push_back(static_cast<int32_t>(GetValue<int>(value_vector[1])));
param_split_shapes_.push_back(static_cast<int64_t>(GetValue<int>(value_vector[0])));
index_offsets_.push_back(static_cast<int64_t>(GetValue<int>(value_vector[1])));
} else {
MS_LOG(ERROR) << "Failure: Manual split strategy's format is wrong! Need ValueSequeue";
return FAILED;
@ -93,14 +93,14 @@ Status GatherV2PInfo::GetAttrs() {
Status GatherV2PInfo::CheckManualSplit() {
auto param_shape = inputs_shape_.at(0);
int32_t split_shape_sum = std::accumulate(param_split_shapes_.begin(), param_split_shapes_.end(), 0,
[](int32_t s, int32_t shape) { return s + shape; });
int64_t split_shape_sum = std::accumulate(param_split_shapes_.begin(), param_split_shapes_.end(), 0,
[](int64_t s, int64_t shape) { return s + shape; });
if (split_shape_sum < param_shape.at(0)) {
MS_LOG(ERROR) << "Failure: Sum of splited shapes should not be smaller than param_shape.";
return FAILED;
}
if (std::any_of(index_offsets_.begin(), index_offsets_.end(), [](const int32_t &offset) { return offset < 0; })) {
if (std::any_of(index_offsets_.begin(), index_offsets_.end(), [](const int64_t &offset) { return offset < 0; })) {
MS_LOG(ERROR) << "Failure: Index offset must not less than 0.";
return FAILED;
}
@ -269,8 +269,8 @@ Status GatherV2PInfo::InferTensorMap() {
size_t param_size = inputs_shape_.at(0).size();
size_t index_size = inputs_shape_.at(1).size();
size_t total_size = param_size + index_size;
std::vector<int32_t> tensor_map_index;
std::vector<int32_t> tensor_map_params;
Shape tensor_map_index;
Shape tensor_map_params;
auto param_strategy = strategy_->GetInputDim().at(0);
if (param_strategy.at(IntToSize(axis_)) != 1) {
tensor_map_index.insert(tensor_map_index.begin(), index_size, -1);
@ -288,7 +288,7 @@ Status GatherV2PInfo::InferTensorMap() {
}
// infer output tensor map
std::vector<int32_t> tensor_map_out;
Shape tensor_map_out;
if (param_strategy.at(IntToSize(axis_)) == 1) {
// param_strategy(axis) == 1
for (size_t i = 0; i < param_size; ++i) {
@ -427,8 +427,8 @@ Status GatherV2PInfo::InferGroup() {
return SUCCESS;
}
std::vector<int32_t> GetRankFromGroup(const Group &group) {
std::vector<int32_t> rank_list;
RankList GetRankFromGroup(const Group &group) {
RankList rank_list;
auto device_list = group.GetDevicesList();
for (auto &device : device_list) {
rank_list.insert(rank_list.end(), device.rank() % 8);
@ -543,7 +543,7 @@ ReplaceGraphPtr GatherV2PInfo::replace_graph(const CNodePtr &cnode) {
}
Status GatherV2PInfo::ComputeReplaceOp() {
int32_t bias = 0;
int64_t bias = 0;
if (manual_split_) {
if (InferOffset() != SUCCESS) {
MS_LOG(ERROR) << name_ << ": Infer offset failed.";
@ -634,7 +634,7 @@ Status GatherV2PInfo::GenerateStrategies(int32_t stage_id) {
return SUCCESS;
}
std::shared_ptr<std::vector<std::vector<int32_t>>> GatherV2PInfo::GenerateBatchStrategies() {
std::shared_ptr<Strategys> GatherV2PInfo::GenerateBatchStrategies() {
CheckGlobalDeviceManager();
size_t dev_num = g_device_manager->GetDeviceListByStageId(0).size();
Dimensions param_strategy(inputs_shape_[0].size(), 1);
@ -643,8 +643,8 @@ std::shared_ptr<std::vector<std::vector<int32_t>>> GatherV2PInfo::GenerateBatchS
for (size_t i = 1; i < inputs_shape_[1].size(); i++) {
index_strategy.push_back(1);
}
std::vector<Dimensions> strategy_v = {param_strategy, index_strategy};
return std::make_shared<std::vector<std::vector<int32_t>>>(strategy_v);
Strategys strategy_v = {param_strategy, index_strategy};
return std::make_shared<Strategys>(strategy_v);
}
} // namespace parallel
} // namespace mindspore

12
mindspore/ccsrc/frontend/parallel/ops_info/gather_v2_p_info.h
View File

@ -45,7 +45,7 @@ class GatherV2PInfo : public OperatorInfo {
Status GenerateStrategies(int32_t stage_id) override;
Status SetCostUnderStrategy(const StrategyPtr &strategy) override;
ReplaceGraphPtr replace_graph(const CNodePtr &cnode) override;
std::shared_ptr<std::vector<std::vector<int32_t>>> GenerateBatchStrategies() override;
std::shared_ptr<Strategys> GenerateBatchStrategies() override;
protected:
Status CheckStrategy(const StrategyPtr &strategy) override;
@ -66,14 +66,14 @@ class GatherV2PInfo : public OperatorInfo {
int32_t axis_;
std::string target_ = DEVICE;
std::string replace_op_name_ = GATHERV2;
int32_t bias_;
int32_t index_offset_;
int32_t slice_size_;
int64_t bias_;
int64_t index_offset_;
int64_t slice_size_;
Shape out_dev_matrix_shape_;
Group group_;
bool manual_split_ = false;
std::vector<int32_t> param_split_shapes_;
std::vector<int32_t> index_offsets_;
std::vector<int64_t> param_split_shapes_;
std::vector<int64_t> index_offsets_;
};
class SparseGatherV2Info : public GatherV2PInfo {

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

@ -118,7 +118,7 @@ Status GetNextInfo::Init(const StrategyPtr &strategy) {
}
Status GetNextInfo::CheckStrategy(const StrategyPtr &strategy) {
std::vector<Dimensions> stras = strategy->GetInputDim();
Strategys stras = strategy->GetInputDim();
for (Dimensions stra : stras) {
if (stra.size() != 0) {
if (is_auto_parallel_) {
@ -254,7 +254,7 @@ Status GetNextInfo::SetCostUnderStrategy(const StrategyPtr &strategy) {
Status GetNextInfo::GenerateStrategies(int32_t stage_id) {
is_auto_parallel_ = true;
std::vector<Dimensions> stra;
Strategys stra;
StrategyPtr sp = std::make_shared<Strategy>(stage_id, stra);
if (SetCostUnderStrategy(sp) == SUCCESS) {
MS_LOG(INFO) << name_ << " : Successfully generated strategy.";

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

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

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

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

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

@ -38,7 +38,7 @@ Status SoftmaxCrossEntropyWithLogitsInfo::CheckStrategy(const mindspore::paralle
return FAILED;
}
std::vector<Dimensions> stra = strategy->GetInputDim();
Strategys stra = strategy->GetInputDim();
Dimensions input_strategy = stra.at(0);
Dimensions label_strategy = stra.at(1);
if (input_strategy != label_strategy) {
@ -52,8 +52,8 @@ Status SoftmaxCrossEntropyWithLogitsInfo::CheckStrategy(const mindspore::paralle
axis_index = static_cast<int32_t>(input_dim) + axis_;
}
int32_t input_axis_strategy = input_strategy.at(IntToSize(axis_index));
int32_t label_axis_strategy = label_strategy.at(IntToSize(axis_index));
int64_t input_axis_strategy = input_strategy.at(IntToSize(axis_index));
int64_t label_axis_strategy = label_strategy.at(IntToSize(axis_index));
// Dimension corresponding to axis is un-splittable
if ((input_axis_strategy != MIN_SLICE_NUM) && (label_axis_strategy != MIN_SLICE_NUM)) {
if (is_auto_parallel_) {
@ -82,21 +82,21 @@ Status SoftmaxCrossEntropyWithLogitsInfo::GetAttrs() {
}
Status SoftmaxCrossEntropyWithLogitsInfo::InferDevMatrixShape() {
std::vector<Dimensions> stra = strategy_->GetInputDim();
Strategys stra = strategy_->GetInputDim();
Dimensions input_strategy = stra.at(0);
dev_matrix_shape_ = input_strategy;
return SUCCESS;
}
Status SoftmaxCrossEntropyWithLogitsInfo::InferTensorMap() {
std::vector<int32_t> tensor_map_index;
Shape tensor_map_index;
size_t size = inputs_shape_[0].size();
// such as 4: tensor_map_index [3,2,1,0]
for (size_t i = 0; i < size; ++i) {
tensor_map_index.push_back((int32_t)(size - i - 1));
tensor_map_index.push_back((int64_t)(size - i - 1));
}
std::vector<int32_t> first_output_tensor_map = {tensor_map_index[0]};
Shape first_output_tensor_map = {tensor_map_index[0]};
inputs_tensor_map_.push_back(tensor_map_index); // input
inputs_tensor_map_.push_back(tensor_map_index); // label
outputs_tensor_map_.push_back(first_output_tensor_map); // output-0

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

@ -158,7 +158,7 @@ Status MatMul::CheckStrategy(const StrategyPtr &strategy) {
return FAILED;
}
std::vector<Dimensions> stra = strategy->GetInputDim();
Strategys stra = strategy->GetInputDim();
Dimensions mat_a_strategy = stra.at(0);
Dimensions mat_b_strategy = stra.at(1);
@ -207,7 +207,7 @@ Status MatMul::CheckStrategy(const StrategyPtr &strategy) {
}
Status MatMulBase::InferDevMatrixShape() {
std::vector<Dimensions> stra = strategy_->GetInputDim();
Strategys stra = strategy_->GetInputDim();
Dimensions mat_a_strategy = stra.at(0);
Dimensions mat_b_strategy = stra.at(1);
@ -279,10 +279,10 @@ Status MatMulBase::InferTensorMap() {
size = dev_matrix_shape_.size() - 1;
}
std::vector<int32_t> tensor_map_index;
Shape tensor_map_index;
// such as 5: tensor_map_index [4,3,2,1,0]
for (size_t i = 0; i < size; ++i) {
tensor_map_index.push_back((int32_t)(LAST_INDEX(size) - i));
tensor_map_index.push_back((int64_t)(LAST_INDEX(size) - i));
}
// infer output tensor map: [4,3,2,0], delete the second-from-end element
@ -309,7 +309,7 @@ Status MatMulBase::InferTensorMap() {
mat_b_tensor_map.begin() + static_cast<different_type>(LAST_INDEX(size) - mat_b_dimension_));
if (transpose_b_) {
// swap the last two elements
int32_t last_value = mat_b_tensor_map.back();
int64_t last_value = mat_b_tensor_map.back();
mat_b_tensor_map.pop_back();
(void)mat_b_tensor_map.insert(
mat_b_tensor_map.begin() + static_cast<different_type>(LAST_INDEX(mat_b_tensor_map.size())), last_value);
@ -436,7 +436,7 @@ Status MatMulBase::GenerateStrategies(int32_t stage_id) {
return FAILED;
}
CheckGlobalDeviceManager();
std::vector<int32_t> dev_list = g_device_manager->GetDeviceListByStageId(stage_id);
RankList dev_list = g_device_manager->GetDeviceListByStageId(stage_id);
size_t dev_num = dev_list.size();
Shape input0_shape = inputs_shape_[0], input1_shape = inputs_shape_[1];
if (transpose_a_) {
@ -503,13 +503,14 @@ Status MatMulBase::GenerateStrategies(int32_t stage_id) {
Status MatMulBase::PrepareStrategy(int32_t stage_id, size_t dev_num,
mindspore::parallel::Dimensions combined_partitions, size_t input0_shape_size,
size_t input1_shape_size, mindspore::parallel::StrategyPtr *const sp) {
int32_t product = std::accumulate(combined_partitions.begin(), combined_partitions.end(), 1, std::multiplies<int>());
int64_t product =
std::accumulate(combined_partitions.begin(), combined_partitions.end(), 1, std::multiplies<int64_t>());
if (!FULLY_USE_DEVICES) {
if (IntToSize(product) > dev_num) {
if (LongToSize(product) > dev_num) {
return FAILED;
}
} else {
if (IntToSize(product) != dev_num) {
if (LongToSize(product) != dev_num) {
return FAILED;
}
}
@ -550,7 +551,7 @@ Status MatMulBase::PrepareStrategy(int32_t stage_id, size_t dev_num,
MS_LOG(ERROR) << name_ << " : Swap last two elements failed.";
}
}
std::vector<Dimensions> stras;
Strategys stras;
stras.push_back(input0_partitions);
stras.push_back(input1_partitions);
(*sp) = std::make_shared<Strategy>(stage_id, stras);

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

@ -77,7 +77,7 @@ Status OneHotInfo::CheckStrategy(const StrategyPtr &strategy) {
}
Status OneHotInfo::InferDevMatrixShape() {
std::vector<Dimensions> stra = strategy_->GetInputDim();
Strategys stra = strategy_->GetInputDim();
Dimensions input_strategy = stra.at(0);
// Now input only support 1-D tensor, so the output is a 2-D tensor
@ -96,16 +96,16 @@ Status OneHotInfo::InferDevMatrixShape() {
}
Status OneHotInfo::InferTensorMap() {
std::vector<int32_t> input_tensor_map_index, output_tensor_map_index;
Shape input_tensor_map_index, output_tensor_map_index;
size_t size = outputs_shape_[0].size();
// such as 2: tensor_map_index [1,0]
if (axis_ == 0) {
for (size_t i = 0; i < size; ++i) {
output_tensor_map_index.push_back((int32_t)(i));
output_tensor_map_index.push_back((int64_t)(i));
}
} else {
for (size_t i = 0; i < size; ++i) {
output_tensor_map_index.push_back((int32_t)(LAST_INDEX(size) - i));
output_tensor_map_index.push_back((int64_t)(LAST_INDEX(size) - i));
}
}
outputs_tensor_map_.push_back(output_tensor_map_index);
@ -299,13 +299,13 @@ Status OneHotInfo::SetCostUnderStrategy(const StrategyPtr &strategy) {
return SUCCESS;
}
std::shared_ptr<std::vector<std::vector<int32_t>>> OneHotInfo::GenerateBatchStrategies() {
std::shared_ptr<Strategys> OneHotInfo::GenerateBatchStrategies() {
CheckGlobalDeviceManager();
size_t dev_num = g_device_manager->GetDeviceListByStageId(0).size();
Dimensions strategy = {SizeToInt(dev_num), 1};
Dimensions empty_strategy;
std::vector<Dimensions> strategy_v = {strategy, empty_strategy, empty_strategy};
return std::make_shared<std::vector<std::vector<int32_t>>>(strategy_v);
Strategys strategy_v = {strategy, empty_strategy, empty_strategy};
return std::make_shared<Strategys>(strategy_v);
}
} // namespace parallel
} // namespace mindspore

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

@ -41,7 +41,7 @@ class OneHotInfo : public OperatorInfo {
Status GenerateStrategies(int32_t stage_id) override;
Status SetCostUnderStrategy(const StrategyPtr &strategy) override;
ReplaceGraphPtr replace_graph(const CNodePtr &cnode) override;
std::shared_ptr<std::vector<std::vector<int32_t>>> GenerateBatchStrategies() override;
std::shared_ptr<Strategys> GenerateBatchStrategies() override;
protected:
Status CheckStrategy(const StrategyPtr &strategy) override;

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

@ -52,7 +52,7 @@ Status CheckStrategyValue(const StrategyPtr &strategy, const Shapes &inputs_shap
return FAILED;
}
std::vector<Dimensions> stra = strategy->GetInputDim();
Strategys stra = strategy->GetInputDim();
for (size_t i = 0; i < strategy_size; ++i) {
Shape sub_strategy = stra.at(i);
Shape sub_input_shape = inputs_shape.at(i);
@ -70,7 +70,7 @@ Status CheckStrategyValue(const StrategyPtr &strategy, const Shapes &inputs_shap
}
for (size_t j = 0; j < strategy_len; ++j) {
int32_t strategy_value = sub_strategy.at(j);
int64_t strategy_value = sub_strategy.at(j);
if (strategy_value < MIN_SLICE_NUM) {
if (is_auto_parallel) {
MS_LOG(DEBUG) << "Invalid strategy value: " << strategy_value;
@ -89,7 +89,7 @@ Status CheckStrategyValue(const StrategyPtr &strategy, const Shapes &inputs_shap
return FAILED;
}
int32_t shape_value = sub_input_shape.at(j);
int64_t shape_value = sub_input_shape.at(j);
if ((shape_value % strategy_value) != 0) {
if (is_auto_parallel) {
MS_LOG(DEBUG) << "Shape " << shape_value << " cannot be divisible by strategy " << strategy_value;
@ -138,9 +138,9 @@ void OperatorInfo::SetDeviceListByStrategy() {
}
Status OperatorInfo::InferRepeatedCalcInfo() {
int32_t g_dev_list_size = SizeToInt(global_device_list_.size());
int32_t dev_matrix_size =
std::accumulate(dev_matrix_shape_.begin(), dev_matrix_shape_.end(), 1, std::multiplies<int>());
int64_t g_dev_list_size = SizeToLong(global_device_list_.size());
int64_t dev_matrix_size =
std::accumulate(dev_matrix_shape_.begin(), dev_matrix_shape_.end(), 1, std::multiplies<int64_t>());
if (dev_matrix_size == 0) {
MS_LOG(ERROR) << name_ << ": The dev matrix size is 0";
return FAILED;
@ -149,7 +149,7 @@ Status OperatorInfo::InferRepeatedCalcInfo() {
if (g_dev_list_size == dev_matrix_size) {
repeated_calc_num_ = 1;
} else if (g_dev_list_size % dev_matrix_size == 0) {
repeated_calc_num_ = g_dev_list_size / dev_matrix_size;
repeated_calc_num_ = ((int32_t)(g_dev_list_size / dev_matrix_size));
} else {
MS_LOG(ERROR) << name_ << ": Dev list size " << g_dev_list_size << " can not be divisible by dev matrix size "
<< dev_matrix_size;
@ -326,7 +326,7 @@ Status OperatorInfo::CreateGroupByDim(size_t axis, std::vector<Group> *group) {
Shape GetSliceShape(const Shape &tensor_shape, const Dimensions &strategy) {
Shape slice_shape;
if (std::any_of(strategy.begin(), strategy.end(), [](int32_t value) { return value <= 0; })) {
if (std::any_of(strategy.begin(), strategy.end(), [](int64_t value) { return value <= 0; })) {
MS_LOG(ERROR) << "Invalid strategy: " << ShapeToString(strategy) << ", the element is less than or equal to 0";
return slice_shape;
}
@ -430,7 +430,8 @@ Status OperatorInfo::InitForCostModelWithAutoRepeatCalc(const StrategyPtr &strat
return FAILED;
}
used_devices_ = std::accumulate(dev_matrix_shape_.begin(), dev_matrix_shape_.end(), 1, std::multiplies<int32_t>());
used_devices_ =
((int32_t)(std::accumulate(dev_matrix_shape_.begin(), dev_matrix_shape_.end(), 1, std::multiplies<int64_t>())));
// must be after InferDevMatrixShape
if (InferRepeatedCalcInfo() != SUCCESS) {
@ -646,8 +647,8 @@ void OperatorInfo::ReplaceSuccEdges(const std::shared_ptr<OperatorInfo> &op, con
succ_edges_ = new_succ_edges;
}
std::shared_ptr<std::vector<std::vector<int32_t>>> GenerateBatchStrategiesBySplitFlag(
const Shapes &shapes, const std::vector<bool> &split_flag_list) {
std::shared_ptr<Strategys> 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();
@ -655,21 +656,21 @@ std::shared_ptr<std::vector<std::vector<int32_t>>> GenerateBatchStrategiesBySpli
}
CheckGlobalDeviceManager();
int32_t dev_num = SizeToInt(g_device_manager->GetDeviceListByStageId(0).size());
std::vector<std::vector<int32_t>> strategy_v;
Strategys strategy_v;
for (size_t i = 0; i != shapes.size(); i++) {
if (shapes[i].empty()) {
MS_LOG(INFO) << "Elements of shapes is empty.";
std::vector<int32_t> empty_element;
Dimensions empty_element;
strategy_v.push_back(empty_element);
} else {
std::vector<int32_t> element(shapes[i].size(), 1);
Dimensions element(shapes[i].size(), 1);
if (split_flag_list[i]) {
element[0] = dev_num;
}
strategy_v.push_back(element);
}
}
return std::make_shared<std::vector<std::vector<int32_t>>>(strategy_v);
return std::make_shared<Strategys>(strategy_v);
}
void OperatorInfo::ReComputeBatchSplitFlagList() {
@ -692,26 +693,26 @@ Status PrepareStrategyBase(int32_t stage_id, size_t dev_num, const Shapes &input
MS_LOG(ERROR) << "The strategy is null.";
return FAILED;
}
int32_t product = 1;
int64_t product = 1;
for (auto &input_partition : inputs_partitions) {
product *= std::accumulate(input_partition.begin(), input_partition.end(), 1, std::multiplies<int>());
product *= std::accumulate(input_partition.begin(), input_partition.end(), 1, std::multiplies<int64_t>());
}
if (!FULLY_USE_DEVICES) {
if (IntToSize(product) > dev_num) {
if (LongToSize(product) > dev_num) {
return FAILED;
}
} else {
if ((product != 1) && (IntToSize(product) != dev_num)) {
if ((product != 1) && (LongToSize(product) != dev_num)) {
return FAILED;
}
}
std::vector<Dimensions> stras(inputs_partitions);
Strategys stras(inputs_partitions);
(*sp) = std::make_shared<Strategy>(stage_id, stras);
return SUCCESS;
}
std::shared_ptr<std::vector<std::vector<int32_t>>> OperatorInfo::GenerateBatchStrategies() {
std::shared_ptr<Strategys> OperatorInfo::GenerateBatchStrategies() {
ComputeBatchSplitFlagList();
return GenerateBatchStrategiesBySplitFlag(inputs_shape_, split_flag_list_);
}
@ -793,7 +794,7 @@ Status GenerateStrategiesForBroadcastLeft(int32_t stage_id, const Shapes &inputs
// second, get the correct strategy for input0
for (auto &sp : *sp_vector) {
std::vector<Dimensions> tmp_strategy;
Strategys tmp_strategy;
Dimensions input0_strategy = sp->GetInputDim()[0];
size_t size_diff = inputs_shape[1].size() - inputs_shape[0].size();
@ -842,7 +843,7 @@ Status GenerateStrategiesForBroadcastRight(int32_t stage_id, const Shapes &input
// second, get the correct strategy for input1
for (auto &sp : *sp_vector) {
std::vector<Dimensions> tmp_strategy;
Strategys tmp_strategy;
tmp_strategy.push_back(sp->GetInputDim()[0]); // input0
Dimensions input1_strategy = sp->GetInputDim()[1];
@ -1175,7 +1176,7 @@ int32_t ComputeRepeatDeviceNumByTensorMap(const Shape &dev_matrix_shape, const S
// The number of repetitions is equal to the number of all devices divided by the number of devices use for
// tensor map.
int32_t device_num = std::accumulate(dev_matrix_shape.begin(), dev_matrix_shape.end(), 1, std::multiplies<int>());
int64_t device_num = std::accumulate(dev_matrix_shape.begin(), dev_matrix_shape.end(), 1, std::multiplies<int64_t>());
for (auto &element : tensor_map) {
// -1 means the corresponding dimension is not split.
if (element == MAP_NONE) {
@ -1194,7 +1195,7 @@ int32_t ComputeRepeatDeviceNumByTensorMap(const Shape &dev_matrix_shape, const S
}
}
return device_num;
return (int32_t)device_num;
}
Status OperatorInfo::InferAsLossDivisor() {

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

@ -43,11 +43,10 @@ using ForwardOp = OperatorVector;
using MirrorOps = std::vector<OperatorVector>;
using Ops = std::vector<OperatorVector>;
using VirtualDivOp = OperatorVector;
using TensorMaps = std::vector<std::vector<int32_t>>;
using TensorMaps = std::vector<Shape>;
using TensorLayouts = std::vector<TensorLayout>;
using different_type = std::vector<int32_t>::difference_type;
using PrimitiveAttrs = std::unordered_map<std::string, ValuePtr>;
using Strategys = std::vector<Dimensions>;
using ReplaceGraphPtr = std::shared_ptr<std::pair<std::vector<std::pair<AnfNodePtr, int>>, AnfNodePtr>>;
class Edge;
@ -88,7 +87,7 @@ class OperatorInfo {
void set_cost(const OperatorCostPtr &cost) { operator_cost_ = cost; }
virtual Status SetCostUnderStrategy(const StrategyPtr &strategy) = 0;
virtual std::shared_ptr<std::vector<std::vector<int32_t>>> GenerateBatchStrategies();
virtual std::shared_ptr<Strategys> GenerateBatchStrategies();
virtual void ReComputeBatchSplitFlagList();
void ComputeBatchSplitFlagList();
@ -271,8 +270,8 @@ Operator CreateReduceScatterOp(const std::string &reduce_op, const std::string &
Operator CreateGetTensorSliceOp(const TensorLayout &tensor_layout);
OperatorVector CreateMirrorOps(const std::string &group_name, size_t dev_num);
int32_t ComputeRepeatDeviceNumByTensorMap(const Shape &dev_matrix_shape, const Shape &tensor_map);
std::shared_ptr<std::vector<std::vector<int32_t>>> GenerateBatchStrategiesBySplitFlag(
const Shapes &shapes, const std::vector<bool> &split_flag_list);
std::shared_ptr<Strategys> GenerateBatchStrategiesBySplitFlag(const Shapes &shapes,
const std::vector<bool> &split_flag_list);
void PrintStrategy(const StrategyPtr &strategy);
// generate strategies for that all inputs' dimensions are independent, such as: ([a, b, c, d])

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

@ -43,7 +43,7 @@ Status PReLUInfo::CheckStrategy(const StrategyPtr &strategy) {
}
return FAILED;
}
std::vector<Dimensions> stra = strategy->GetInputDim();
Strategys stra = strategy->GetInputDim();
if (stra[1].size() != PRELU_SECOND_INPUT_SIZE) {
if (is_auto_parallel_) {
MS_LOG(DEBUG) << name_ << ": Invalid strategy size.";
@ -67,7 +67,7 @@ Status PReLUInfo::CheckStrategy(const StrategyPtr &strategy) {
* device matrix is same with the strategy matrix
*/
Status PReLUInfo::InferDevMatrixShape() {
std::vector<Dimensions> stra = strategy_->GetInputDim();
Strategys stra = strategy_->GetInputDim();
Dimensions input_strategy = stra.at(0);
input_strategy_ = input_strategy;
dev_matrix_shape_ = input_strategy;
@ -103,7 +103,7 @@ Status PReLUInfo::InferTensorMap() {
TensorMap input_tensor_map;
// such as 4: input_tensor_map [3,2,1,0]
for (size_t i = 0; i < inputs_shape_[0].size(); ++i) {
input_tensor_map.push_back((int32_t)(inputs_shape_[0].size() - i - 1));
input_tensor_map.push_back((int64_t)(inputs_shape_[0].size() - i - 1));
}
TensorMap param_tensor_map;

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

@ -43,7 +43,7 @@ Status ReduceMethod::CheckStrategy(const StrategyPtr &strategy) {
}
Status ReduceMethod::InferDevMatrixShape() {
std::vector<Dimensions> stra = strategy_->GetInputDim();
Strategys stra = strategy_->GetInputDim();
Dimensions input_strategy = stra.at(0);
dev_matrix_shape_ = input_strategy;
@ -119,11 +119,12 @@ Status ReduceMethod::GetAttrs() {
}
Status ReduceMethod::InferTensorMap() {
std::vector<int32_t> tensor_map_index, dim_list, output_tensor_map;
Shape tensor_map_index, output_tensor_map;
std::vector<int32_t> dim_list;
size_t size = inputs_shape_.at(0).size();
// such as 4: tensor_map_index [3,2,1,0]
for (size_t i = 0; i < size; ++i) {
tensor_map_index.push_back((int32_t)(size - 1 - i));
tensor_map_index.push_back((int64_t)(size - 1 - i));
}
dim_list = reduce_dim();
for (size_t i = 0; i < size; ++i) {
@ -462,7 +463,7 @@ Status ArgMaxWithValueInfo::CheckStrategy(const StrategyPtr &strategy) {
std::vector<int32_t> dim_list = reduce_dim();
MS_ASSERT(dim_list.size() == 1);
std::vector<Dimensions> stra = strategy->GetInputDim();
Strategys stra = strategy->GetInputDim();
MS_ASSERT(stra.size() == 1);
Shape input_strategy = stra.at(0);
MS_ASSERT(dim_list.at(0) < input_strategy.size());

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

@ -57,7 +57,7 @@ Status ReshapeInfo::CheckStrategy(const StrategyPtr &strategy) {
* only support batch parallel reshape operator in ReID (batch parallel degree can be smaller than device number)
*/
Status ReshapeInfo::InferDevMatrixShape() {
std::vector<Dimensions> stra = strategy_->GetInputDim();
Strategys stra = strategy_->GetInputDim();
input_strategy_ = stra.at(0);
dev_matrix_shape_.push_back(input_strategy_[0]);
return SUCCESS;
@ -181,7 +181,7 @@ Status ReshapeInfo::InferTensorMap() {
return FAILED;
}
std::vector<int32_t> tensor_map_index_input;
Shape tensor_map_index_input;
tensor_map_index_input.push_back(0);
for (size_t j = 1; j < inputs_shape_[0].size(); ++j) {
@ -189,7 +189,7 @@ Status ReshapeInfo::InferTensorMap() {
}
inputs_tensor_map_.push_back(tensor_map_index_input);
std::vector<int32_t> tensor_map_index_output;
Shape tensor_map_index_output;
tensor_map_index_output.push_back(0);
for (size_t j = 1; j < outputs_shape_[0].size(); ++j) {
@ -205,7 +205,7 @@ Status ReshapeInfo::InferTensorMap() {
*/
Strategys ReshapeInfo::GetOutputsStrategy() {
Strategys outputs_strategy;
std::vector<int32_t> strategy;
Dimensions strategy;
strategy.push_back(input_strategy_[0]);
for (size_t j = 1; j < outputs_shape_[0].size(); ++j) {
strategy.push_back(1);
@ -325,7 +325,7 @@ void ReshapeInfo::device_number(const StrategyPtr &strategy) {
}
Status ReshapeInfo::InferDefaultLayout(const Shape &shape, TensorLayout *const layout) {
std::vector<int32_t> tensor_map_index;
Shape tensor_map_index;
for (size_t i = 0; i < shape.size(); i++) {
tensor_map_index.push_back(MAP_NONE);
}
@ -504,7 +504,7 @@ Status ReshapeInfo::GenetateStrategyCosts(const std::vector<std::shared_ptr<Stra
MS_LOG(ERROR) << "Infer strategy by tensor_info failed";
return FAILED;
}
std::vector<Dimensions> stra_inputs = {stra};
Strategys stra_inputs = {stra};
StrategyPtr reshape_stra = std::make_shared<Strategy>(pre_stra_cost->strategy_ptr->GetInputStage(), stra_inputs);
if (next_stra_costs.empty()) {
if (Init(nullptr) == FAILED) {

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

@ -227,7 +227,7 @@ Status StridedSliceInfo::InferTensorInfo() {
}
// Note: if the batch dimension is not fully fetched, the batch strategy may not work.
std::shared_ptr<std::vector<std::vector<int32_t>>> StridedSliceInfo::GenerateBatchStrategies() {
std::shared_ptr<Strategys> 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

@ -41,7 +41,7 @@ class StridedSliceInfo : public OperatorInfo {
Status InitForCostModel(const StrategyPtr &strategy) override;
Status GenerateStrategies(int32_t) override;
Status SetCostUnderStrategy(const StrategyPtr &) override;
std::shared_ptr<std::vector<std::vector<int32_t>>> GenerateBatchStrategies() override;
std::shared_ptr<Strategys> GenerateBatchStrategies() override;
protected:
Status GetAttrs() override;

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

@ -54,7 +54,7 @@ Status TileInfo::GetAttrs() {
for (auto &element : elements) {
MS_EXCEPTION_IF_NULL(element);
if (element->isa<Int32Imm>()) {
int32_t axis = element->cast<Int32ImmPtr>()->value();
int64_t axis = static_cast<int64_t>(element->cast<Int32ImmPtr>()->value());
full_multiples_.push_back(axis);
} else {
MS_LOG(ERROR) << name_ << ": The value of axis must be int32.";
@ -185,7 +185,7 @@ void TileInfo::UpdateMultiples(const CNodePtr &cnode) {
(void)manager->Replace(cnode->input(2), val);
}
std::shared_ptr<std::vector<std::vector<int32_t>>> TileInfo::GenerateBatchStrategies() {
std::shared_ptr<Strategys> TileInfo::GenerateBatchStrategies() {
if (InferAttrs() != SUCCESS) {
MS_LOG(EXCEPTION) << name_ << ": Infer attrs failed";
}

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

@ -41,7 +41,7 @@ class TileInfo : public OperatorInfo {
Status InitForCostModel(const StrategyPtr &strategy) override;
Status GenerateStrategies(int32_t) override;
Status SetCostUnderStrategy(const StrategyPtr &) override;
std::shared_ptr<std::vector<std::vector<int32_t>>> GenerateBatchStrategies() override;
std::shared_ptr<Strategys> GenerateBatchStrategies() override;
void UpdateMultiples(const CNodePtr &cnode);
protected:
@ -54,8 +54,8 @@ class TileInfo : public OperatorInfo {
Status InferTensorMap() override;
private:
std::vector<int32_t> full_multiples_;
std::vector<int32_t> slice_multiples_;
std::vector<int64_t> full_multiples_;
std::vector<int64_t> slice_multiples_;
};
using TileInfoPtr = std::shared_ptr<TileInfo>;

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

@ -37,18 +37,18 @@ Status TmpIdentityInfo::CheckStrategy(const mindspore::parallel::StrategyPtr &st
}
Status TmpIdentityInfo::InferDevMatrixShape() {
std::vector<Dimensions> stra = strategy_->GetInputDim();
Strategys stra = strategy_->GetInputDim();
Dimensions input_strategy = stra.at(0);
dev_matrix_shape_ = input_strategy;
return SUCCESS;
}
Status TmpIdentityInfo::InferTensorMap() {
std::vector<int32_t> tensor_map_index;
Shape tensor_map_index;
size_t size = inputs_shape_[0].size();
// such as 4: tensor_map_index [3,2,1,0]
for (size_t i = 0; i < size; ++i) {
tensor_map_index.push_back((int32_t)(size - 1 - i));
tensor_map_index.push_back((int64_t)(size - 1 - i));
}
inputs_tensor_map_.push_back(tensor_map_index);

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

@ -41,7 +41,7 @@ Status TransposeInfo::CheckStrategy(const StrategyPtr &strategy) {
}
Status TransposeInfo::InferDevMatrixShape() {
std::vector<Dimensions> stra = strategy_->GetInputDim();
Strategys stra = strategy_->GetInputDim();
input_strategy_ = stra.at(0);
for (auto &iter : input_strategy_) {
dev_matrix_shape_.push_back(iter);
@ -105,13 +105,13 @@ Status TransposeInfo::InferTensorMap() {
return FAILED;
}
std::vector<int32_t> tensor_map_index_input;
Shape tensor_map_index_input;
for (size_t j = 0; j < inputs_shape_[0].size(); ++j) {
tensor_map_index_input.push_back(SizeToInt(inputs_shape_[0].size() - j - 1));
}
inputs_tensor_map_.push_back(tensor_map_index_input);
std::vector<int32_t> tensor_map_index_output = tensor_map_index_input;
Shape tensor_map_index_output = tensor_map_index_input;
for (uint32_t i = 0; i < tensor_map_index_output.size(); i++) {
tensor_map_index_output[i] = tensor_map_index_input[IntToUint(axis_v_[i])];
}
@ -122,7 +122,7 @@ Status TransposeInfo::InferTensorMap() {
// the output tensor strategy is the permutation of input tensor strategy, the permutation is axis_v
Strategys TransposeInfo::GetOutputsStrategy() {
Strategys outputs_strategy;
std::vector<int32_t> strategy = input_strategy_;
Dimensions strategy = input_strategy_;
for (uint32_t i = 0; i < strategy.size(); i++) {
strategy[i] = input_strategy_[IntToUint(axis_v_[i])];
}

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

@ -38,7 +38,7 @@ Status VirtualDatasetInfo::CheckStrategy(const StrategyPtr &strategy) {
return FAILED;
}
std::vector<Dimensions> stra = strategy->GetInputDim();
Strategys stra = strategy->GetInputDim();
if (stra.size() < 1) {
if (is_auto_parallel_) {
MS_LOG(DEBUG) << name_ << ": Strategy size must be larger than 1.";
@ -80,12 +80,12 @@ Status VirtualDatasetInfo::CheckStrategy(const StrategyPtr &strategy) {
}
Status VirtualDatasetInfo::InferDevMatrixShape() {
std::vector<Dimensions> stra = strategy_->GetInputDim();
Strategys stra = strategy_->GetInputDim();
Dimensions strategy_first = stra.at(0);
int32_t stage = strategy_->GetInputStage();
CheckGlobalDeviceManager();
int32_t dev_num = SizeToInt(g_device_manager->GetDeviceListByStageId(stage).size());
int32_t batch_split_num = strategy_first.at(0);
int32_t batch_split_num = ((int32_t)(strategy_first.at(0)));
dev_matrix_shape_.push_back(batch_split_num);
if (dev_num > batch_split_num) {
dev_matrix_shape_.push_back(dev_num / batch_split_num);
@ -103,11 +103,11 @@ Status VirtualDatasetInfo::InferTensorMap() {
bool full_batch = ParallelContext::GetInstance()->full_batch();
for (size_t i = 0; i < strategy_->GetInputNumber(); i++) {
std::vector<int32_t> tensor_map_index;
Shape tensor_map_index;
if (full_batch) {
tensor_map_index.push_back(MAP_NONE);
} else {
tensor_map_index.push_back((int32_t)(LAST_INDEX(SizeToUint(dev_matrix_shape_.size()))));
tensor_map_index.push_back((int64_t)(LAST_INDEX(dev_matrix_shape_.size())));
}
for (size_t j = 1; j < strategy_->GetInputDim()[i].size(); ++j) {
tensor_map_index.push_back(MAP_NONE);
@ -193,7 +193,7 @@ Status VirtualDatasetInfo::GenerateStrategies(int32_t stage_id) {
total_dev_num = g_device_manager->GetDeviceListByStageId(stage_id).size();
}
StrategyPtr sp;
std::vector<Dimensions> strategy;
Strategys strategy;
for (auto &shape : inputs_shape_) {
Shape temp;
temp.emplace_back(SizeToInt(total_dev_num));

5
mindspore/ccsrc/frontend/parallel/step_auto_parallel.cc
View File

@ -776,10 +776,7 @@ void AugmentCostGraph(const std::vector<AnfNodePtr> &all_nodes) {
if (input_shape == nullptr) {
MS_LOG(EXCEPTION) << "Failure: input_shape is nullptr";
}
std::vector<int> shape_int = input_shape->shape();
Shape shape;
(void)std::transform(shape_int.begin(), shape_int.end(), std::back_inserter(shape),
[](int sub_shape) { return static_cast<int32_t>(sub_shape); });
Shape shape = input_shape->shape();
Shapes inputs_shape = {shape};
Shapes outputs_shape = {shape};
// 2) init the attr

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

@ -1019,14 +1019,16 @@ StrategyPtr ExtractStrategy(std::unordered_map<std::string, ValuePtr> attrs) {
}
if (var->size() > 0) {
std::vector<ValuePtr> elements = var->value();
std::vector<Dimensions> strategy;
Strategys strategy;
for (uint32_t index = 0; index < elements.size(); ++index) {
Dimensions dim;
if (elements[index]->isa<ValueSequeue>()) {
ValueTuplePtr value_tuple = elements[index]->cast<ValueTuplePtr>();
std::vector<ValuePtr> value_vector = value_tuple->value();
(void)std::transform(value_vector.begin(), value_vector.end(), std::back_inserter(dim),
[](const ValuePtr &value) { return static_cast<int32_t>(GetValue<int>(value)); });
(void)std::transform(
value_vector.begin(), value_vector.end(), std::back_inserter(dim), [](const ValuePtr &value) {
return GetValue<int64_t>(value);
});
strategy.push_back(dim);
} else {
MS_LOG(EXCEPTION) << "Failure:Strategy's format is wrong! Need ValueSequeue";
@ -1075,12 +1077,14 @@ Shapes GetNodeShape(const AnfNodePtr &node) {
for (auto &shape : tuple_shape) {
auto each_shape = dyn_cast<abstract::Shape>(shape);
MS_EXCEPTION_IF_NULL(each_shape);
shapes.push_back(each_shape->shape());
Shape new_shape = each_shape->shape();
shapes.push_back(new_shape);
}
} else {
auto shape_ptr = dyn_cast<abstract::Shape>(base_shape_ptr);
MS_EXCEPTION_IF_NULL(shape_ptr);
shapes.push_back(shape_ptr->shape());
Shape new_shape = shape_ptr->shape();
shapes.push_back(new_shape);
}
return shapes;
}
@ -1412,7 +1416,7 @@ void SetVirtualDatasetStrategy(const CNodePtr &node) {
if (shape_list[0][i].empty()) {
MS_LOG(EXCEPTION) << "shape_list[ " << i << " ].size() is zero";
}
std::vector<int32_t> input_strategy = {dev_num};
Dimensions input_strategy = {dev_num};
for (size_t j = 1; j < shape_list[0][i].size(); j++) {
input_strategy.push_back(1);
}
@ -1476,7 +1480,7 @@ void ExtractInformation(const std::vector<AnfNodePtr> &all_nodes) {
if (!StrategyFound(attrs) && !load_strategy_from_ckpt) {
MS_LOG(INFO) << "ExtractInformation: the strategy of node " << node->ToString() << " prim " << prim->name()
<< " is empty, using batch parallel";
std::shared_ptr<std::vector<Dimensions>> strategy_v_ptr = operator_->GenerateBatchStrategies();
std::shared_ptr<Strategys> strategy_v_ptr = operator_->GenerateBatchStrategies();
if (strategy_v_ptr == nullptr) {
MS_LOG(EXCEPTION) << "Failure:Generate batch parallel strategy failed";
}

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

@ -24,19 +24,20 @@
#include <vector>
#include "frontend/parallel/status.h"
#include "frontend/parallel/device_matrix.h"
namespace mindspore {
namespace parallel {
#define MIN_SLICE_NUM 1
using Dimensions = std::vector<int32_t>;
using Dimensions = Shape;
using Strategys = std::vector<Dimensions>;
class Strategy;
using StrategyPtr = std::shared_ptr<Strategy>;
class Strategy {
public:
Strategy(int32_t stage, std::vector<Dimensions> inputs)
Strategy(int32_t stage, Strategys inputs)
: stage_(stage), inputs_(std::move(inputs)), internal_size_(0), internal_stragies_() {}
Strategy(const Strategy &another_stra) : stage_(another_stra.GetInputStage()) {
@ -51,14 +52,14 @@ class Strategy {
~Strategy() = default;
size_t GetInputNumber() const { return inputs_.size(); }
std::vector<Dimensions> GetInputDim() const { return inputs_; }
Strategys GetInputDim() const { return inputs_; }
int32_t GetInputStage() const { return stage_; }
void ExpandInputDimFromOneToTwo() {
if (inputs_.size() == 1) {
inputs_.push_back(inputs_[0]);
}
}
void ResetInputs(const std::vector<Dimensions> &input) { inputs_ = input; }
void ResetInputs(const Strategys &input) { inputs_ = input; }
std::vector<StrategyPtr> GetInternalStrategies() const { return internal_stragies_; }
size_t GetInternalSize() const { return internal_size_; }
@ -83,12 +84,12 @@ class Strategy {
const int32_t stage_;
// The size of Dimensions must equal to inputs_ tensor dimension.
std::vector<Dimensions> inputs_;
Strategys inputs_;
size_t internal_size_ = 0;
std::vector<StrategyPtr> internal_stragies_;
};
inline StrategyPtr NewStrategy(const int32_t stage, const std::vector<Dimensions> &inputs) {
inline StrategyPtr NewStrategy(const int32_t stage, const Strategys &inputs) {
return std::make_shared<Strategy>(stage, inputs);
}
} // namespace parallel

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

@ -66,10 +66,10 @@ Status StrategyCheckpoint::Load(StrategyMap *strategy_map) {
straspb::ParallelStrategys parallel_strategys = parallel_strategy_item.parallel_strategys();
auto stage = (int32_t)parallel_strategys.stage();
size_t strategys_num = IntToSize(parallel_strategys.parallel_strategy_size());
std::vector<std::vector<int32_t>> strategy_inputs;
Strategys strategy_inputs;
for (size_t j = 0; j < strategys_num; j++) {
straspb::ParallelStrategy parallel_strategy = parallel_strategys.parallel_strategy(SizeToInt(j));
std::vector<int32_t> dimension;
Dimensions dimension;
size_t dim_num = IntToSize(parallel_strategy.dim_size());
for (size_t k = 0; k < dim_num; k++) {
dimension.push_back(parallel_strategy.dim(SizeToInt(k)));

50
mindspore/ccsrc/frontend/parallel/tensor_layout/arrangement.cc
View File

@ -26,7 +26,7 @@
namespace mindspore {
namespace parallel {
Status Arrangement::Init(const std::vector<int32_t> &array) {
Status Arrangement::Init(const Shape &array) {
Status status = Array::Init(array);
if (status != Status::SUCCESS) {
return Status::FAILED;
@ -40,7 +40,7 @@ Status Arrangement::Init(const std::vector<int32_t> &array) {
}
bool Arrangement::IsValidArrangement() {
return !std::any_of(array_.begin(), array_.end(), [](int32_t value) { return value <= 0; });
return !std::any_of(array_.begin(), array_.end(), [](int64_t value) { return value <= 0; });
}
void Arrangement::ComputeSize() {
@ -57,14 +57,14 @@ void Arrangement::ComputeSize() {
* where size_[i-1] = shape[0] * shape[1] * ... * shape[i-1],
* if value > size_, return []
*/
std::vector<int32_t> Arrangement::GetFrontElementByValue(int32_t value) const {
std::vector<int32_t> out;
Shape Arrangement::GetFrontElementByValue(int64_t value) const {
Shape out;
if (GetDimSize() == 0) {
return out;
}
if (value <= size_) {
int32_t size = 1;
uint32_t shape_list_idx = 0;
int64_t size = 1;
size_t shape_list_idx = 0;
while (size < value) {
size *= array_[shape_list_idx];
if (size <= value) {
@ -88,9 +88,9 @@ std::shared_ptr<Arrangement> Arrangement::GetExpandedShapeByExpandListRemoveLeft
if (expand_list.size() != GetDimSize()) {
return nullptr;
}
std::vector<int32_t> new_shape;
for (uint32_t i = 0; i < expand_list.size(); i++) {
std::vector<int32_t> expand_shape = expand_list[i].GetFrontElementByValue(GetDimByIdx(i));
Shape new_shape;
for (size_t i = 0; i < expand_list.size(); i++) {
Shape expand_shape = expand_list[i].GetFrontElementByValue(GetDimByIdx(i));
if (expand_shape.empty()) {
new_shape.push_back(GetDimByIdx(i));
} else {
@ -109,11 +109,11 @@ std::shared_ptr<Arrangement> Arrangement::GetExpandedShapeByExpandListRemoveLeft
* arrangement_list = [[4, 2], [2, 2]]
*/
std::shared_ptr<std::vector<Arrangement>> Arrangement::GetExpandShapeList(const Arrangement &expand_shape) const {
int32_t size = 1;
uint32_t ind = 0;
int64_t size = 1;
size_t ind = 0;
std::vector<Arrangement> arrangement_list;
std::vector<int32_t> shape;
for (uint32_t i = 0; i < expand_shape.GetDimSize(); i++) {
Shape shape;
for (size_t i = 0; i < expand_shape.GetDimSize(); i++) {
size *= expand_shape.GetDimByIdx(i);
if (size > GetDimByIdx(ind)) {
MS_LOG(ERROR) << "invalid expand_shape";
@ -145,10 +145,10 @@ std::shared_ptr<std::pair<std::vector<Arrangement>, Arrangement>> Arrangement::G
if (expand_shape_list_ptr == nullptr) {
return nullptr;
}
std::vector<int32_t> expand_num_list_shape;
Shape expand_num_list_shape;
(void)std::transform(expand_shape_list_ptr->begin(), expand_shape_list_ptr->end(),
std::back_inserter(expand_num_list_shape),
[](const Arrangement &arr) { return SizeToInt(arr.GetDimSize()); });
[](const Arrangement &arr) { return SizeToLong(arr.GetDimSize()); });
Arrangement expand_num_list;
Status status = expand_num_list.Init(expand_num_list_shape);
if (status != Status::SUCCESS) {
@ -158,9 +158,9 @@ std::shared_ptr<std::pair<std::vector<Arrangement>, Arrangement>> Arrangement::G
return std::make_shared<std::pair<std::vector<Arrangement>, Arrangement>>(out_value);
}
std::vector<int32_t> Arrangement::ComputeReverseAccumulateSumInReverseOrder() const {
std::vector<int32_t> shape_accum;
int32_t size = 0;
Shape Arrangement::ComputeReverseAccumulateSumInReverseOrder() const {
Shape shape_accum;
int64_t size = 0;
for (auto iter = array_.end() - 1; iter >= array_.begin(); --iter) {
shape_accum.push_back(size);
size += *iter;
@ -173,11 +173,11 @@ std::shared_ptr<Arrangement> Arrangement::GetExpandedShapeByExpandListReserveLef
if (expand_list.size() != GetDimSize()) {
return nullptr;
}
std::vector<int32_t> new_shape;
for (uint32_t i = 0; i < expand_list.size(); i++) {
Shape new_shape;
for (size_t i = 0; i < expand_list.size(); i++) {
if (expand_list[i].GetDimSize() >= 1) {
int32_t size = 1;
for (uint32_t k = 0; k < expand_list[i].GetDimSize() - 1; k++) {
int64_t size = 1;
for (size_t k = 0; k < expand_list[i].GetDimSize() - 1; k++) {
new_shape.push_back(expand_list[i].GetDimByIdx(k));
size *= expand_list[i].GetDimByIdx(k);
}
@ -207,7 +207,7 @@ std::shared_ptr<Arrangement> Arrangement::GetUnifiedShape(const Arrangement &in2
if (status != Status::SUCCESS) {
return nullptr;
}
std::vector<int32_t> out_shape;
Shape out_shape;
status = AccumulateProductToShape(out_accum, &out_shape);
if (status != Status::SUCCESS) {
return nullptr;
@ -231,8 +231,8 @@ std::vector<size_t> Arrangement::GetSqueezeIdx() const {
}
Arrangement Arrangement::GetSqueezeArrangement() const {
std::vector<int32_t> out_shape(array_.size());
auto it = std::copy_if(array_.begin(), array_.end(), out_shape.begin(), [](int32_t value) { return value != 1; });
Shape out_shape(array_.size());
auto it = std::copy_if(array_.begin(), array_.end(), out_shape.begin(), [](int64_t value) { return value != 1; });
out_shape.resize(LongToSize(std::distance(out_shape.begin(), it)));
// if all elements are 1, out_shape = {1}

10
mindspore/ccsrc/frontend/parallel/tensor_layout/arrangement.h
View File

@ -32,11 +32,11 @@ class Arrangement : public Array {
public:
Arrangement() : size_(1) {}
~Arrangement() override = default;
Status Init(const std::vector<int32_t> &array) override;
int32_t size() const { return size_; }
std::vector<int32_t> GetFrontElementByValue(int32_t value) const;
Status Init(const Shape &array) override;
int64_t size() const { return size_; }
Shape GetFrontElementByValue(int64_t value) const;
std::shared_ptr<std::vector<Arrangement>> GetExpandShapeList(const Arrangement &expand_shape) const;
std::vector<int32_t> ComputeReverseAccumulateSumInReverseOrder() const;
Shape ComputeReverseAccumulateSumInReverseOrder() const;
std::shared_ptr<Arrangement> GetExpandedShapeByExpandListReserveLeft(
const std::vector<Arrangement> &expand_list) const;
std::shared_ptr<Arrangement> GetExpandedShapeByExpandListRemoveLeft(
@ -50,7 +50,7 @@ class Arrangement : public Array {
private:
bool IsValidArrangement();
void ComputeSize();
int32_t size_;
int64_t size_;
};
} // namespace parallel
} // namespace mindspore

6
mindspore/ccsrc/frontend/parallel/tensor_layout/array.cc
View File

@ -31,14 +31,14 @@ std::string Array::ToString() const {
return buffer.str();
}
Status Array::Init(const std::vector<int32_t> &array) {
Status Array::Init(const Shape &array) {
array_ = array;
return IsvalidArray() ? Status::SUCCESS : Status::FAILED;
}
bool Array::IsvalidArray() const { return true; }
int32_t Array::GetDimByIdx(uint32_t idx) const {
int64_t Array::GetDimByIdx(size_t idx) const {
size_t mod_idx = idx;
if (idx >= GetDimSize()) {
MS_LOG(EXCEPTION) << "idx is " << idx << ", but array size is " << GetDimSize();
@ -46,7 +46,7 @@ int32_t Array::GetDimByIdx(uint32_t idx) const {
return array_[mod_idx];
}
int32_t Array::GetDimByReverseIdx(uint32_t idx) const {
int64_t Array::GetDimByReverseIdx(size_t idx) const {
size_t mod_idx = idx;
if (idx >= GetDimSize()) {
MS_LOG(EXCEPTION) << "idx is " << idx << " but array size is " << GetDimSize();

11
mindspore/ccsrc/frontend/parallel/tensor_layout/array.h
View File

@ -23,6 +23,7 @@
#include <string>
#include <vector>
#include "frontend/parallel/status.h"
#include "frontend/parallel/device_matrix.h"
namespace mindspore {
namespace parallel {
@ -31,16 +32,16 @@ class Array {
Array() = default;
virtual ~Array() = default;
std::string ToString() const;
virtual Status Init(const std::vector<int32_t> &array);
virtual Status Init(const Shape &array);
bool IsvalidArray() const;
std::vector<int32_t> array() const { return array_; }
Shape array() const { return array_; }
size_t GetDimSize() const { return array_.size(); }
int32_t GetDimByIdx(uint32_t idx) const;
int32_t GetDimByReverseIdx(uint32_t idx) const;
int64_t GetDimByIdx(size_t idx) const;
int64_t GetDimByReverseIdx(size_t idx) const;
bool operator==(const Array &a1) const;
protected:
std::vector<int32_t> array_;
Shape array_;
};
} // namespace parallel
} // namespace mindspore

43
mindspore/ccsrc/frontend/parallel/tensor_layout/construct_operator.cc
View File

@ -18,6 +18,7 @@
#include <functional>
#include <numeric>
#include <algorithm>
namespace mindspore {
namespace parallel {
@ -42,8 +43,8 @@ OperatorVector ConstructOperator::SkipRedisReshapeOP(Shape shape) {
}
Status ConstructOperator::ReshapeOP(Shape shape) {
int32_t prod = std::accumulate(shape.begin(), shape.end(), 1, std::multiplies<int>());
int32_t prod_expect = std::accumulate(tensor_shape_.begin(), tensor_shape_.end(), 1, std::multiplies<int>());
int64_t prod = std::accumulate(shape.begin(), shape.end(), 1, std::multiplies<int64_t>());
int64_t prod_expect = std::accumulate(tensor_shape_.begin(), tensor_shape_.end(), 1, std::multiplies<int64_t>());
if (prod != prod_expect) {
ValuePtr ptr = MakeValue(shape);
MS_EXCEPTION_IF_NULL(ptr);
@ -86,16 +87,16 @@ Status ConstructOperator::StridedSliceOP(Args args) {
MS_LOG(ERROR) << "args size should not be less than 3!";
return Status::FAILED;
}
int32_t split_count = args[0];
int64_t split_count = args[0];
if (split_count <= 0) {
MS_LOG(ERROR) << "split_count should not be less than 0!";
return Status::FAILED;
}
int32_t split_dim = args[1];
int32_t dev_dim = args[2];
int64_t split_dim = args[1];
int64_t dev_dim = args[2];
std::vector<Group> group_list;
if (CreateGroupByDim(dev_size_ - IntToSize(dev_dim) - 1, &group_list) != SUCCESS) {
if (CreateGroupByDim(dev_size_ - LongToSize(dev_dim) - 1, &group_list) != SUCCESS) {
MS_LOG(ERROR) << "stride slice op: create group failed";
return FAILED;
} else if (group_list.empty()) { // this group only has one device, don't need do StridedSlice
@ -114,7 +115,7 @@ Status ConstructOperator::StridedSliceOP(Args args) {
Shape strides(size, 1);
size_t index = 0;
for (auto num : tensor_shape_) {
if (index != IntToSize(split_dim)) {
if (index != LongToSize(split_dim)) {
begin[index] = 0;
end[index] = num;
} else {
@ -123,9 +124,9 @@ Status ConstructOperator::StridedSliceOP(Args args) {
<< "! when construct StridedSlice operator";
return Status::INVALID_ARGUMENT;
}
int32_t count = num / split_count;
begin[index] = SizeToInt(rank) * count;
end[index] = (SizeToInt(rank) + 1) * count;
int64_t count = num / split_count;
begin[index] = SizeToLong(rank) * count;
end[index] = (SizeToLong(rank) + 1) * count;
}
index++;
}
@ -135,7 +136,7 @@ Status ConstructOperator::StridedSliceOP(Args args) {
return Status::SUCCESS;
}
Status ConstructOperator::AllGatherOP(int32_t dev_dim) {
Status ConstructOperator::AllGatherOP(int64_t dev_dim) {
if ((IntToSize(dev_dim) >= dev_size_) || (dev_dim < 0)) {
MS_LOG(ERROR) << "Invalid device dimension " << dev_dim << " when construct AllGather operator!";
return Status::INVALID_ARGUMENT;
@ -160,7 +161,7 @@ Status ConstructOperator::AllGatherOP(int32_t dev_dim) {
return Status::SUCCESS;
}
Status ConstructOperator::ConcatOP(int32_t concat_dim) {
Status ConstructOperator::ConcatOP(int64_t concat_dim) {
if (IntToSize(concat_dim) >= tensor_shape_.size()) {
MS_LOG(ERROR) << "Invalid tensor dimension " << concat_dim << " when construct Concat operator!";
return Status::INVALID_ARGUMENT;
@ -174,7 +175,7 @@ Status ConstructOperator::ConcatOP(int32_t concat_dim) {
return Status::SUCCESS;
}
Status ConstructOperator::SplitOP(int32_t split_count) {
Status ConstructOperator::SplitOP(int64_t split_count) {
if (split_count <= 0) {
MS_LOG(ERROR) << "Invalid split count when construct Split operator!";
return Status::FAILED;
@ -196,30 +197,30 @@ Status ConstructOperator::AlltoAllOP(Args args) {
MS_LOG(ERROR) << "args size should not be less than 4!";
return Status::FAILED;
}
int32_t split_count = args[0];
int32_t split_dim = args[1];
int32_t concat_dim = args[2];
int32_t dev_dim = args[3];
int64_t split_count = args[0];
int64_t split_dim = args[1];
int64_t concat_dim = args[2];
int64_t dev_dim = args[3];
if (split_count <= 0) {
MS_LOG(ERROR) << "Invalid split count when construct AlltoAll operator!";
return Status::FAILED;
}
if (tensor_shape_[IntToSize(split_dim)] % split_count != 0) {
if (tensor_shape_[LongToSize(split_dim)] % split_count != 0) {
MS_LOG(ERROR) << "Tensor can not be split into " << split_count << " slices in the dimension " << split_dim
<< "when construct AlltoAll operator!";
return Status::INVALID_ARGUMENT;
}
if (IntToSize(concat_dim) >= tensor_shape_.size()) {
if (LongToSize(concat_dim) >= tensor_shape_.size()) {
MS_LOG(ERROR) << "Invalid split count " << split_count << " when construct AlltoAll operator!";
return Status::INVALID_ARGUMENT;
}
if ((IntToSize(dev_dim) >= dev_size_) || (dev_dim < 0)) {
if ((LongToSize(dev_dim) >= dev_size_) || (dev_dim < 0)) {
MS_LOG(ERROR) << "Invalid device dimension " << dev_dim << " when construct AlltoAll operator!";
return Status::INVALID_ARGUMENT;
}
std::vector<Group> group_list;
if (CreateGroupByDim(dev_size_ - IntToSize(dev_dim) - 1, &group_list) != SUCCESS) {
if (CreateGroupByDim(dev_size_ - LongToSize(dev_dim) - 1, &group_list) != SUCCESS) {
MS_LOG(ERROR) << "AlltoAll op: create group failed";
return FAILED;
} else if (group_list.empty()) { // this group only has one device, don't need do alltoall

8
mindspore/ccsrc/frontend/parallel/tensor_layout/construct_operator.h
View File

@ -27,7 +27,7 @@
namespace mindspore {
namespace parallel {
using Args = std::vector<std::int32_t>;
using Args = std::vector<std::int64_t>;
class ConstructOperator {
public:
@ -38,9 +38,9 @@ class ConstructOperator {
OperatorVector SkipRedisReshapeOP(Shape shape);
Status ReshapeOP(Shape shape);
Status StridedSliceOP(Args args);
Status AllGatherOP(int32_t dev_dim);
Status SplitOP(int32_t split_count);
Status ConcatOP(int32_t concat_dim);
Status AllGatherOP(int64_t dev_dim);
Status SplitOP(int64_t split_count);
Status ConcatOP(int64_t concat_dim);
Status AlltoAllOP(Args args);
Operator GetOperator() const { return op_; }
void UpdateTensorShape(const Shape &tensor_shape) { tensor_shape_ = tensor_shape; }

42
mindspore/ccsrc/frontend/parallel/tensor_layout/map.cc
View File

@ -26,7 +26,7 @@
namespace mindspore {
namespace parallel {
Status Map::Init(const std::vector<int32_t> &array) {
Status Map::Init(const Shape &array) {
Status status = Array::Init(array);
if (status != Status::SUCCESS) {
return Status::FAILED;
@ -39,11 +39,11 @@ Status Map::Init(const std::vector<int32_t> &array) {
}
bool Map::IsValidMap() {
if (std::any_of(array_.begin(), array_.end(), [](int32_t value) { return ((value < 0) && (value != MAP_NONE)); })) {
if (std::any_of(array_.begin(), array_.end(), [](int64_t value) { return ((value < 0) && (value != MAP_NONE)); })) {
return false;
}
// check that all none -1 value in array_ is different
std::vector<int32_t> sorted_array = array_;
Shape sorted_array = array_;
std::sort(sorted_array.begin(), sorted_array.end());
int32_t value = MAP_NONE;
for (auto &element : sorted_array) {
@ -58,7 +58,7 @@ bool Map::IsValidMap() {
return true;
}
int32_t Map::GetMaxItem() const {
int64_t Map::GetMaxItem() const {
if (!array_.empty()) {
return *std::max_element(array_.begin(), array_.end());
} else {
@ -66,7 +66,7 @@ int32_t Map::GetMaxItem() const {
}
}
int32_t Map::GetIndexByValue(int32_t value) const {
int32_t Map::GetIndexByValue(int64_t value) const {
auto iter = find(array_.begin(), array_.end(), value);
if (iter != array_.end()) {
return static_cast<int32_t>(std::distance(array_.begin(), iter));
@ -82,15 +82,15 @@ std::shared_ptr<Map> Map::ExpandMapByNone(const Arrangement &expand_num_list) co
if (expand_num_list.GetDimSize() != GetDimSize()) {
return nullptr;
}
std::vector<int32_t> new_shape;
for (uint32_t i = 0; i != GetDimSize(); i++) {
Shape new_shape;
for (size_t i = 0; i != GetDimSize(); i++) {
if (GetDimByIdx(i) == MAP_NONE) {
for (int32_t j = 0; j < expand_num_list.GetDimByIdx(i); j++) {
for (int64_t j = 0; j < expand_num_list.GetDimByIdx(i); j++) {
new_shape.push_back(MAP_NONE);
}
} else {
new_shape.push_back(GetDimByIdx(i));
int32_t j = 1;
int64_t j = 1;
while (j < expand_num_list.GetDimByIdx(i)) {
new_shape.push_back(MAP_NONE);
j++;
@ -106,17 +106,17 @@ std::shared_ptr<Map> Map::ExpandMapByNone(const Arrangement &expand_num_list) co
* expand.size() should be equal to array_.size()
*/
std::shared_ptr<Map> Map::ExpandMapByDecreaseNumber(const Arrangement &expand_num_list) const {
if (GetMaxItem() >= static_cast<int32_t>(expand_num_list.GetDimSize())) {
if (GetMaxItem() >= static_cast<int64_t>(expand_num_list.GetDimSize())) {
return nullptr;
}
std::vector<int32_t> new_shape;
for (uint32_t i = 0; i < GetDimSize(); i++) {
Shape new_shape;
for (size_t i = 0; i < GetDimSize(); i++) {
if (GetDimByIdx(i) == MAP_NONE) {
new_shape.push_back(MAP_NONE);
} else {
int32_t start_map =
expand_num_list.ComputeReverseAccumulateSumInReverseOrder()[static_cast<uint32_t>(GetDimByIdx(i))];
for (int32_t k = expand_num_list.GetDimByReverseIdx(static_cast<uint32_t>(GetDimByIdx(i))) - 1; k >= 0; k--) {
int64_t start_map =
expand_num_list.ComputeReverseAccumulateSumInReverseOrder()[static_cast<size_t>(GetDimByIdx(i))];
for (int32_t k = expand_num_list.GetDimByReverseIdx(static_cast<size_t>(GetDimByIdx(i))) - 1; k >= 0; k--) {
new_shape.push_back(k + start_map);
}
}
@ -127,16 +127,16 @@ std::shared_ptr<Map> Map::ExpandMapByDecreaseNumber(const Arrangement &expand_nu
}
std::shared_ptr<std::vector<Arrangement>> Map::ReMapVector(const std::vector<Arrangement> &input_vector) const {
if (GetMaxItem() >= static_cast<int32_t>(input_vector.size())) {
if (GetMaxItem() >= static_cast<int64_t>(input_vector.size())) {
return nullptr;
}
std::vector<Arrangement> out;
Arrangement empty_arrangement;
for (uint32_t i = 0; i < GetDimSize(); i++) {
for (size_t i = 0; i < GetDimSize(); i++) {
if (GetDimByIdx(i) == MAP_NONE) {
out.push_back(empty_arrangement);
} else {
out.push_back(input_vector[IntToUint(SizeToInt(input_vector.size()) - 1 - GetDimByIdx(i))]);
out.push_back(input_vector[input_vector.size() - 1 - LongToSize(GetDimByIdx(i))]);
}
}
return std::make_shared<std::vector<Arrangement>>(out);
@ -144,7 +144,7 @@ std::shared_ptr<std::vector<Arrangement>> Map::ReMapVector(const std::vector<Arr
bool Map::CheckNoneByIdxList(std::vector<size_t> idx_list) const {
for (auto &value : idx_list) {
if (GetDimByIdx(SizeToUint(value)) != MAP_NONE) {
if (GetDimByIdx(value) != MAP_NONE) {
return false;
}
}
@ -152,11 +152,11 @@ bool Map::CheckNoneByIdxList(std::vector<size_t> idx_list) const {
}
Map Map::SqueezeMapByIdxList(std::vector<size_t> idx_list) const {
std::vector<int32_t> out_shape;
Shape out_shape;
for (size_t i = 0; i < GetDimSize(); i++) {
auto it = std::find(idx_list.begin(), idx_list.end(), i);
if (it == idx_list.end()) {
out_shape.push_back(GetDimByIdx(SizeToUint(i)));
out_shape.push_back(GetDimByIdx(i));
}
}
if (out_shape.empty()) {

6
mindspore/ccsrc/frontend/parallel/tensor_layout/map.h
View File

@ -34,9 +34,9 @@ class Map : public Array {
public:
Map() = default;
~Map() override = default;
Status Init(const std::vector<int32_t> &array) override;
int32_t GetMaxItem() const;
int32_t GetIndexByValue(int32_t value) const;
Status Init(const Shape &array) override;
int64_t GetMaxItem() const;
int32_t GetIndexByValue(int64_t value) const;
std::shared_ptr<Map> ExpandMapByNone(const Arrangement &expand_num_list) const;
std::shared_ptr<Map> ExpandMapByDecreaseNumber(const Arrangement &expand_num_list) const;
std::shared_ptr<std::vector<Arrangement>> ReMapVector(const std::vector<Arrangement> &input_vector) const;

44
mindspore/ccsrc/frontend/parallel/tensor_layout/redistribution_operator_infer.cc
View File

@ -47,8 +47,8 @@ Status RedistributionOperatorInfer::Init(const TensorLayout &tensor_layout, cons
constructor_.UpdateTensorShape(cur_tensor_layout_.slice_shape().array());
size_t key = 0;
std::vector<int32_t> map = in_tensor_map_.array();
for (int32_t item : map) {
Shape map = in_tensor_map_.array();
for (int64_t item : map) {
map_[key++] = item;
}
@ -83,9 +83,9 @@ Status RedistributionOperatorInfer::InferRedistributionOperator() {
// break loop structure with concat_by_axis
if (len_global == operator_list_.size() && !map_.empty()) {
size_t index = map_.begin()->first;
int32_t in_dim = map_[index];
int64_t in_dim = map_[index];
map_[index] = NONE;
Args args = {SizeToInt(index), in_dim, dev_mat_.GetDimByReverseIdx(IntToUint(in_dim))};
Args args = {SizeToInt(index), in_dim, dev_mat_.GetDimByReverseIdx(LongToSize(in_dim))};
if (InsertOperator(CONCAT_BY_AXIS, args) == Status::FAILED) {
return Status::FAILED;
}
@ -97,8 +97,8 @@ Status RedistributionOperatorInfer::InferRedistributionOperator() {
Status RedistributionOperatorInfer::InferSplitByAxis() {
for (auto iter = map_.begin(); iter != map_.end();) {
uint32_t index = iter->first;
int32_t in_dim = iter->second;
int32_t out_dim = out_tensor_map_.GetDimByIdx(index);
int64_t in_dim = iter->second;
int64_t out_dim = out_tensor_map_.GetDimByIdx(index);
if (in_dim == out_dim) {
(void)map_.erase(iter++);
continue;
@ -122,8 +122,8 @@ Status RedistributionOperatorInfer::InferSplitByAxis() {
Status RedistributionOperatorInfer::InferPermuteByAxis() {
for (auto iter = map_.begin(); iter != map_.end();) {
uint32_t index = iter->first;
int32_t in_dim = map_[index];
int32_t out_dim = out_tensor_map_.GetDimByIdx(index);
int64_t in_dim = map_[index];
int64_t out_dim = out_tensor_map_.GetDimByIdx(index);
if (in_dim == out_dim) {
(void)map_.erase(iter++);
continue;
@ -132,9 +132,9 @@ Status RedistributionOperatorInfer::InferPermuteByAxis() {
std::any_of(map_.begin(), map_.end(),
[out_dim](const RedistributionOperatorMap::value_type &a) { return a.second == out_dim; })) {
int32_t cat_dim = in_tensor_map_.GetIndexByValue(out_dim);
int32_t dev_num = dev_mat_.GetDimByReverseIdx(IntToUint(out_dim));
int64_t dev_num = dev_mat_.GetDimByReverseIdx(LongToSize(out_dim));
if (is_cost_model_) {
int32_t dev_dim = in_tensor_map_.GetDimByIdx(IntToUint(cat_dim));
int64_t dev_dim = in_tensor_map_.GetDimByIdx(IntToUint(cat_dim));
Args args_alltoall = {dev_mat_.GetDimByReverseIdx(IntToUint(dev_dim)), UintToInt(index), cat_dim, dev_dim,
dev_num};
if (InsertOperator(PERMUTE_BY_AXIS, args_alltoall) == Status::FAILED) {
@ -165,10 +165,10 @@ Status RedistributionOperatorInfer::InferPermuteByAxis() {
Status RedistributionOperatorInfer::InferConcatByAxis() {
for (auto iter = map_.begin(); iter != map_.end();) {
uint32_t index = iter->first;
int32_t in_dim = map_[index];
int32_t out_dim = out_tensor_map_.GetDimByIdx(index);
int64_t in_dim = map_[index];
int64_t out_dim = out_tensor_map_.GetDimByIdx(index);
if (in_dim != NONE && out_tensor_map_.GetIndexByValue(in_dim) == NONE) {
Args args = {SizeToInt(index), in_dim, dev_mat_.GetDimByReverseIdx(IntToUint(in_dim))};
Args args = {SizeToInt(index), in_dim, dev_mat_.GetDimByReverseIdx(LongToSize(in_dim))};
if (InsertOperator(CONCAT_BY_AXIS, args) == Status::FAILED) {
MS_LOG(ERROR) << "Insert ConcatByAxis Error!";
return Status::FAILED;
@ -215,7 +215,7 @@ Status RedistributionOperatorInfer::TransferSplitByAxis(Args args) {
MS_LOG(ERROR) << "args size should not be less than 3!";
return Status::FAILED;
}
uint32_t index = IntToUint(args[1]);
size_t index = LongToSize(args[1]);
if (constructor_.StridedSliceOP(args) != Status::SUCCESS) {
return Status::FAILED;
} else {
@ -239,11 +239,11 @@ Status RedistributionOperatorInfer::TransferPermuteByAxis(Args args) {
operator_vector_.push_back(constructor_.GetOperator());
output_info_vector_.push_back(std::make_pair(false, 0));
}
uint32_t index = IntToUint(args[1]);
int32_t val = args[2];
int32_t out_dim = out_tensor_map_.GetDimByIdx(index);
size_t index = LongToSize(args[1]);
int64_t val = args[2];
int64_t out_dim = out_tensor_map_.GetDimByIdx(index);
if (cur_tensor_layout_.UpdateTensorMap(IntToUint(val), NONE) == Status::FAILED) {
if (cur_tensor_layout_.UpdateTensorMap(LongToSize(val), NONE) == Status::FAILED) {
return Status::FAILED;
}
if (cur_tensor_layout_.UpdateTensorMap(index, out_dim) == Status::FAILED) {
@ -257,9 +257,9 @@ Status RedistributionOperatorInfer::TransferConcatByAxis(Args args) {
MS_LOG(ERROR) << "args size should not be less than 3!";
return Status::FAILED;
}
int32_t tensor_dim = args[0];
int32_t dev_dim = args[1];
int32_t split_count = args[2];
int64_t tensor_dim = args[0];
int64_t dev_dim = args[1];
int64_t split_count = args[2];
if (constructor_.AllGatherOP(dev_dim) != Status::SUCCESS) {
return Status::FAILED;
} else {
@ -280,7 +280,7 @@ Status RedistributionOperatorInfer::TransferConcatByAxis(Args args) {
output_info_vector_.push_back(std::make_pair(false, 0));
}
}
if (cur_tensor_layout_.UpdateTensorMap(IntToUint(tensor_dim), NONE) == Status::FAILED) {
if (cur_tensor_layout_.UpdateTensorMap(LongToSize(tensor_dim), NONE) == Status::FAILED) {
return Status::FAILED;
}
return Status::SUCCESS;

8
mindspore/ccsrc/frontend/parallel/tensor_layout/redistribution_operator_infer.h
View File

@ -28,10 +28,10 @@
#include "utils/convert_utils.h"
namespace mindspore {
namespace parallel {
using DeviceArrangement = std::vector<int32_t>;
using TensorMap = std::vector<int32_t>;
using TensorShape = std::vector<int32_t>;
using RedistributionOperatorMap = std::unordered_map<uint32_t, int32_t>;
using DeviceArrangement = Shape;
using TensorMap = Shape;
using TensorShape = Shape;
using RedistributionOperatorMap = std::unordered_map<uint32_t, int64_t>;
using OperatorR = std::pair<OperatorName, Args>;
using OperatorC = std::pair<OperatorR, Shape>;
using OperatorList = std::vector<OperatorC>;

36
mindspore/ccsrc/frontend/parallel/tensor_layout/shape_util.cc
View File

@ -26,7 +26,7 @@ namespace parallel {
* shape = [2, 8, 32]
* shape_accum = [2, 2 * 8, 2 * 8 * 32]
*/
Status ShapeToAccumulateProduct(const std::vector<int32_t> &shape, std::vector<int64_t> *shape_accum) {
Status ShapeToAccumulateProduct(const Shape &shape, Shape *shape_accum) {
MS_EXCEPTION_IF_NULL(shape_accum);
shape_accum->clear();
int64_t size = 1;
@ -47,7 +47,7 @@ Status ShapeToAccumulateProduct(const std::vector<int32_t> &shape, std::vector<i
* shape_accum = [2 * 8 * 32, 8 * 32, 32]
*
*/
Status ShapeToAccumulateProductReverse(const std::vector<int32_t> &shape, std::vector<int64_t> *shape_accum) {
Status ShapeToAccumulateProductReverse(const Shape &shape, Shape *shape_accum) {
MS_EXCEPTION_IF_NULL(shape_accum);
shape_accum->clear();
int64_t size = 1;
@ -68,7 +68,7 @@ Status ShapeToAccumulateProductReverse(const std::vector<int32_t> &shape, std::v
* shape = [2, 8, 32]
*
*/
Status AccumulateProductToShape(const std::vector<int64_t> &shape_accum, std::vector<int32_t> *shape) {
Status AccumulateProductToShape(const Shape &shape_accum, Shape *shape) {
MS_EXCEPTION_IF_NULL(shape);
shape->clear();
int64_t value = 1;
@ -81,7 +81,7 @@ Status AccumulateProductToShape(const std::vector<int64_t> &shape_accum, std::ve
MS_LOG(ERROR) << "shape_accum is not a accumulate product in ascending order";
return Status::FAILED;
}
shape->push_back(static_cast<int32_t>((*iter) / value));
shape->push_back(static_cast<int64_t>((*iter) / value));
value = (*iter);
}
return Status::SUCCESS;
@ -92,7 +92,7 @@ Status AccumulateProductToShape(const std::vector<int64_t> &shape_accum, std::ve
* shape_accum_reverse = [2 * 8 * 32, 8 * 32, 32]
* shape = [2, 8, 32]
*/
Status AccumulateProductReverseToShape(const std::vector<int64_t> &shape_accum_reverse, std::vector<int32_t> *shape) {
Status AccumulateProductReverseToShape(const Shape &shape_accum_reverse, Shape *shape) {
MS_EXCEPTION_IF_NULL(shape);
shape->clear();
int64_t value = 1;
@ -105,7 +105,7 @@ Status AccumulateProductReverseToShape(const std::vector<int64_t> &shape_accum_r
MS_LOG(ERROR) << "shape_accum is not a accumulate product in ascending order";
return Status::FAILED;
}
(void)shape->insert(shape->begin(), static_cast<int32_t>((*iter) / value));
(void)shape->insert(shape->begin(), static_cast<int64_t>((*iter) / value));
value = *iter;
}
return Status::SUCCESS;
@ -122,8 +122,7 @@ Status AccumulateProductReverseToShape(const std::vector<int64_t> &shape_accum_r
* in2 = [8, 16]
* *out = [2, 4, 8, 16]
*/
Status UnifyAccumulateProduct(const std::vector<int64_t> &in1_accum, const std::vector<int64_t> &in2_accum,
std::vector<int64_t> *out_accum) {
Status UnifyAccumulateProduct(const Shape &in1_accum, const Shape &in2_accum, Shape *out_accum) {
MS_EXCEPTION_IF_NULL(out_accum);
out_accum->clear();
auto in1_iter = in1_accum.begin();
@ -159,19 +158,19 @@ Status UnifyAccumulateProduct(const std::vector<int64_t> &in1_accum, const std::
* in2 = [2, 16]
* out = [2, 4, 4]
*/
Status UnifyShape(const std::vector<int32_t> &in1, const std::vector<int32_t> &in2, std::vector<int32_t> *out) {
Status UnifyShape(const Shape &in1, const Shape &in2, Shape *out) {
MS_EXCEPTION_IF_NULL(out);
std::vector<int64_t> in1_accum;
Shape in1_accum;
Status status = ShapeToAccumulateProduct(in1, &in1_accum);
if (status != Status::SUCCESS) {
return status;
}
std::vector<int64_t> in2_accum;
Shape in2_accum;
status = ShapeToAccumulateProduct(in2, &in2_accum);
if (status != Status::SUCCESS) {
return status;
}
std::vector<int64_t> out_accum;
Shape out_accum;
status = UnifyAccumulateProduct(in1_accum, in2_accum, &out_accum);
if (status != Status::SUCCESS) {
return status;
@ -194,9 +193,8 @@ Status UnifyShape(const std::vector<int32_t> &in1, const std::vector<int32_t> &i
* expand_accum_reverse = [2 * 4 * 8, 4 * 8, 8]
* out_accum_reverse = [2 * 4 * 2 * 4 * 8, 4 * 2 * 4 * 8, 2 * 4 * 8, 4 * 8, 8]
*/
Status ExpandAccumulateProduct(const std::vector<int64_t> &in_accum_reverse,
const std::vector<int64_t> &expand_accum_reverse,
std::vector<int64_t> *out_accum_reverse) {
Status ExpandAccumulateProduct(const Shape &in_accum_reverse, const Shape &expand_accum_reverse,
Shape *out_accum_reverse) {
MS_EXCEPTION_IF_NULL(out_accum_reverse);
out_accum_reverse->clear();
auto in_riter = in_accum_reverse.rbegin();
@ -236,19 +234,19 @@ Status ExpandAccumulateProduct(const std::vector<int64_t> &in_accum_reverse,
* expand = [2, 4, 8]
* out = [2, 4, 2, 4, 8]
*/
Status ExpandShape(const std::vector<int32_t> &in, const std::vector<int32_t> &expand, std::vector<int32_t> *out) {
Status ExpandShape(const Shape &in, const Shape &expand, Shape *out) {
MS_EXCEPTION_IF_NULL(out);
std::vector<int64_t> in_accum_reverse;
Shape in_accum_reverse;
Status status = ShapeToAccumulateProductReverse(in, &in_accum_reverse);
if (status != Status::SUCCESS) {
return status;
}
std::vector<int64_t> expand_accum_reverse;
Shape expand_accum_reverse;
status = ShapeToAccumulateProductReverse(expand, &expand_accum_reverse);
if (status != Status::SUCCESS) {
return status;
}
std::vector<int64_t> out_accum_reverse;
Shape out_accum_reverse;
status = ExpandAccumulateProduct(in_accum_reverse, expand_accum_reverse, &out_accum_reverse);
if (status != Status::SUCCESS) {
return status;

21
mindspore/ccsrc/frontend/parallel/tensor_layout/shape_util.h
View File

@ -24,6 +24,7 @@
#include <vector>
#include "frontend/parallel/status.h"
#include "frontend/parallel/device_matrix.h"
namespace mindspore {
namespace parallel {
@ -39,7 +40,7 @@ namespace parallel {
* shape_accum = [2, 2 * 8, 2 * 8 * 32]
*
*/
Status ShapeToAccumulateProduct(const std::vector<int32_t> &shape, std::vector<int64_t> *shape_accum);
Status ShapeToAccumulateProduct(const Shape &shape, Shape *shape_accum);
/*
* compute the accumulating product of all the values in shape from right to left,
@ -53,7 +54,7 @@ Status ShapeToAccumulateProduct(const std::vector<int32_t> &shape, std::vector<i
* shape_accum = [2 * 8 * 32, 8 * 32, 32]
*
*/
Status ShapeToAccumulateProductReverse(const std::vector<int32_t> &shape, std::vector<int64_t> *shape_accum);
Status ShapeToAccumulateProductReverse(const Shape &shape, Shape *shape_accum);
/*
* compute the original shape from the accumulating product shape_accum,
@ -68,7 +69,7 @@ Status ShapeToAccumulateProductReverse(const std::vector<int32_t> &shape, std::v
* shape = [2, 8, 32]
*
*/
Status AccumulateProductToShape(const std::vector<int64_t> &shape_accum, std::vector<int32_t> *shape);
Status AccumulateProductToShape(const Shape &shape_accum, Shape *shape);
/*
* compute the original shape from the accumulating product shape_accum,
@ -83,7 +84,7 @@ Status AccumulateProductToShape(const std::vector<int64_t> &shape_accum, std::ve
* shape = [2, 8, 32]
*
*/
Status AccumulateProductReverseToShape(const std::vector<int64_t> &shape_accum_reverse, std::vector<int32_t> *shape);
Status AccumulateProductReverseToShape(const Shape &shape_accum_reverse, Shape *shape);
/*
* given two accumulate product in1_accum and in2_accum, compute the union of in1_accum and in2_accum,
@ -101,8 +102,7 @@ Status AccumulateProductReverseToShape(const std::vector<int64_t> &shape_accum_r
* in2_accum = [8, 16]
* out_accum = [2, 4, 8, 16]
*/
Status UnifyAccumulateProduct(const std::vector<int64_t> &in1_accum, const std::vector<int64_t> &in2_accum,
std::vector<int64_t> *out_accum);
Status UnifyAccumulateProduct(const Shape &in1_accum, const Shape &in2_accum, Shape *out_accum);
/*
* given two shape in1 = [din1_n-1, din1_n-2, ..., din1_0] and in2 = [din2_m-1, din2_m-2, ..., din2_m]
@ -117,7 +117,7 @@ Status UnifyAccumulateProduct(const std::vector<int64_t> &in1_accum, const std::
* in2 = [2, 16]
* out = [2, 4, 4]
*/
Status UnifyShape(const std::vector<int32_t> &in1, const std::vector<int32_t> &in2, std::vector<int32_t> *out);
Status UnifyShape(const Shape &in1, const Shape &in2, Shape *out);
/*
* given two accumulate product in reverse order of in and expand,
@ -141,9 +141,8 @@ Status UnifyShape(const std::vector<int32_t> &in1, const std::vector<int32_t> &i
* expand_accum_reverse = [2 * 4 * 8, 4 * 8, 8]
* out_accum_reverse = [2 * 4 * 2 * 4 * 8, 4 * 2 * 4 * 8, 2 * 4 * 8, 4 * 8, 8]
*/
Status ExpandAccumulateProduct(const std::vector<int64_t> &in_accum_reverse,
const std::vector<int64_t> &expand_accum_reverse,
std::vector<int64_t> *out_accum_reverse);
Status ExpandAccumulateProduct(const Shape &in_accum_reverse, const Shape &expand_accum_reverse,
Shape *out_accum_reverse);
/*
* given a shape in = [din_n-1, din_n-2, ..., d_0], and the expand shape expand= [dexp_m-1, dexp_m-2, ..., dexp_0],
@ -165,7 +164,7 @@ Status ExpandAccumulateProduct(const std::vector<int64_t> &in_accum_reverse,
* expand = [2, 4, 8]
* out = [2, 4, 2, 4, 8]
*/
Status ExpandShape(const std::vector<int32_t> &in, const std::vector<int32_t> &expand, std::vector<int32_t> *out);
Status ExpandShape(const Shape &in, const Shape &expand, Shape *out);
} // namespace parallel
} // namespace mindspore

38
mindspore/ccsrc/frontend/parallel/tensor_layout/tensor_layout.cc
View File

@ -64,8 +64,8 @@ Status TensorLayout::Init(const Arrangement &device_arrangement, const Map &tens
}
}
Status TensorLayout::InitFromVector(const std::vector<int32_t> &device_arrangement,
const std::vector<int32_t> &tensor_map, const std::vector<int32_t> &tensor_shape) {
Status TensorLayout::InitFromVector(const Shape &device_arrangement, const Shape &tensor_map,
const Shape &tensor_shape) {
if (device_arrangement_origin_.Init(device_arrangement) != SUCCESS) {
return FAILED;
}
@ -82,7 +82,7 @@ Status TensorLayout::InitFromVector(const std::vector<int32_t> &device_arrangeme
}
bool TensorLayout::IsValidTensorLayout() const {
if (tensor_map_origin_.GetMaxItem() >= static_cast<int32_t>(device_arrangement_origin_.GetDimSize())) {
if (tensor_map_origin_.GetMaxItem() >= static_cast<int64_t>(device_arrangement_origin_.GetDimSize())) {
MS_LOG(ERROR) << "the max element in tensor_map_origin_ must be smaller than device_arrangement_origin_ size!";
return false;
}
@ -114,18 +114,18 @@ bool TensorLayout::TensorShapeDimensionIsDividedBySplitDeviceDimension() const {
}
void TensorLayout::RemoveElementEqualToOneInDeviceArrangement() {
std::vector<int32_t> device_arrangement_shape;
std::vector<int32_t> tensor_map_shape = tensor_map_origin_.array();
uint32_t dev_num = SizeToUint(device_arrangement_origin_.GetDimSize());
int32_t dev_num_left = SizeToInt(device_arrangement_origin_.GetDimSize());
for (uint32_t i = 0; i < dev_num; i++) {
Shape device_arrangement_shape;
Shape tensor_map_shape = tensor_map_origin_.array();
size_t dev_num = device_arrangement_origin_.GetDimSize();
size_t dev_num_left = device_arrangement_origin_.GetDimSize();
for (size_t i = 0; i < dev_num; i++) {
if (device_arrangement_origin_.GetDimByIdx(i) == 1) {
int32_t idx = GetTensorDimensionIndexByDeviceDimensionIndex(static_cast<int32_t>(dev_num - 1 - i));
int32_t idx = GetTensorDimensionIndexByDeviceDimensionIndex(static_cast<int64_t>(dev_num - 1 - i));
if (idx != -1) {
tensor_map_shape[static_cast<uint32_t>(idx)] = -1;
}
for (auto &value : tensor_map_shape) {
if (value >= dev_num_left - 1 - static_cast<int32_t>(i)) {
if (value >= SizeToLong(dev_num_left) - 1 - static_cast<int64_t>(i)) {
value--;
}
}
@ -139,7 +139,7 @@ void TensorLayout::RemoveElementEqualToOneInDeviceArrangement() {
}
// if idx is not in tensor_map, return -1
int32_t TensorLayout::GetTensorDimensionIndexByDeviceDimensionIndex(int32_t idx) const {
int32_t TensorLayout::GetTensorDimensionIndexByDeviceDimensionIndex(int64_t idx) const {
return tensor_map_.GetIndexByValue(idx);
}
@ -288,7 +288,7 @@ std::shared_ptr<TensorLayout> TensorLayout::ExpandDeviceArrangement(const Arrang
}
bool TensorLayout::TensorShapeCanBeExpanded(const Arrangement &expand_shape) const {
std::vector<int32_t> in_expand_shape_shape;
Shape in_expand_shape_shape;
Status status = ExpandShape(tensor_shape_.array(), expand_shape.array(), &in_expand_shape_shape);
if (status != Status::SUCCESS) {
return false;
@ -297,7 +297,7 @@ bool TensorLayout::TensorShapeCanBeExpanded(const Arrangement &expand_shape) con
}
std::shared_ptr<Arrangement> TensorLayout::ComputeExpandedTensorShape(const Arrangement &expand_shape) const {
std::vector<int32_t> in_expand_shape_shape;
Shape in_expand_shape_shape;
Status status = ExpandShape(tensor_shape_.array(), expand_shape.array(), &in_expand_shape_shape);
if (status != Status::SUCCESS) {
return nullptr;
@ -311,14 +311,14 @@ std::shared_ptr<Arrangement> TensorLayout::ComputeExpandedTensorShape(const Arra
}
Arrangement TensorLayout::slice_shape() const {
std::vector<int32_t> shape;
for (uint32_t index = 0; index < tensor_map_.GetDimSize(); index++) {
int32_t dim = tensor_map_.GetDimByIdx(index);
int32_t num = tensor_shape_.GetDimByIdx(index);
Shape shape;
for (size_t index = 0; index < tensor_map_.GetDimSize(); index++) {
int64_t dim = tensor_map_.GetDimByIdx(index);
int64_t num = tensor_shape_.GetDimByIdx(index);
if (dim == -1) {
shape.push_back(num);
} else {
int32_t divisor = device_arrangement_.GetDimByReverseIdx(IntToUint(dim));
int64_t divisor = device_arrangement_.GetDimByReverseIdx(IntToUint(dim));
shape.push_back(num / divisor);
}
}
@ -331,7 +331,7 @@ Arrangement TensorLayout::slice_shape() const {
}
}
Status TensorLayout::UpdateTensorMap(uint32_t index, int32_t value) {
Status TensorLayout::UpdateTensorMap(size_t index, int64_t value) {
if (index >= tensor_map_.GetDimSize()) {
MS_LOG(ERROR) << "Index is out of the size of the tensor map!";
return Status::FAILED;

7
mindspore/ccsrc/frontend/parallel/tensor_layout/tensor_layout.h
View File

@ -38,8 +38,7 @@ class TensorLayout {
std::string StandardToString() const;
std::string OriginToString() const;
Status Init(const Arrangement &device_arrangement, const Map &tensor_map, const Arrangement &tensor_shape);
Status InitFromVector(const std::vector<int32_t> &device_arrangement, const std::vector<int32_t> &tensor_map,
const std::vector<int32_t> &tensor_shape);
Status InitFromVector(const Shape &device_arrangement, const Shape &tensor_map, const Shape &tensor_shape);
bool skip_redistribution() const { return skip_redistribution_; }
@ -79,7 +78,7 @@ class TensorLayout {
Arrangement slice_shape() const;
Status UpdateTensorMap(uint32_t index, int32_t value);
Status UpdateTensorMap(size_t index, int64_t value);
TensorLayout SqueezeShape() const;
@ -95,7 +94,7 @@ class TensorLayout {
int32_t GetSliceDeviceDimensionByTensorDimensionIndex(uint32_t idx) const;
int32_t GetSliceNumByTensorDimensionIndex(uint32_t idx) const;
bool TensorShapeDimensionIsDividedBySplitDeviceDimension() const;
int32_t GetTensorDimensionIndexByDeviceDimensionIndex(int32_t idx) const;
int32_t GetTensorDimensionIndexByDeviceDimensionIndex(int64_t idx) const;
Arrangement device_arrangement_origin_;
Map tensor_map_origin_;

4
mindspore/ccsrc/utils/convert_utils.cc
View File

@ -48,6 +48,10 @@ py::object ValuePtrToPyData(const ValuePtr &value) {
MS_LOG(DEBUG) << "int";
py::int_ v = value->cast<Int32ImmPtr>()->value();
ret = v;
} else if (value->isa<Int64Imm>()) {
MS_LOG(DEBUG) << "int64";
py::int_ v = value->cast<Int64ImmPtr>()->value();
ret = v;
} else if (value->isa<UInt64Imm>()) {
MS_LOG(DEBUG) << "uint64";
py::int_ v = value->cast<UInt64ImmPtr>()->value();

10
mindspore/core/abstract/dshape.h
View File

@ -25,6 +25,7 @@
#include <unordered_map>
#include <typeindex>
#include <memory>
#include <algorithm>
#include "utils/log_adapter.h"
#include "base/base.h"
@ -63,7 +64,16 @@ class Shape : public BaseShape {
static const int SHP_ANY = -1;
Shape() : shape_() {}
Shape(const std::initializer_list<int> &list) : shape_(list) {}
Shape(const std::initializer_list<int64_t> &list) {
std::vector<int64_t> list_in(list);
(void)std::transform(list_in.begin(), list_in.end(), std::back_inserter(shape_),
[](const int64_t &value) { return static_cast<int>(value); });
}
explicit Shape(const std::vector<int> &list) : shape_(list) {}
explicit Shape(const std::vector<int64_t> &list) {
(void)std::transform(list.begin(), list.end(), std::back_inserter(shape_),
[](const int64_t &value) { return static_cast<int>(value); });
}
~Shape() override = default;
MS_DECLARE_PARENT(Shape, BaseShape)
std::string ToString() const override;

8
tests/ut/cpp/parallel/auto_parallel/dp_algo_test.cc
View File

@ -154,13 +154,13 @@ class TestDPAlgo : public UT::Common {
void TestDPAlgo::SetUp() {
cost_graph = std::make_shared<CostGraph>();
cost_graph->SetDeviceMemoryAndCostParameter();
std::vector<int32_t> dev_list;
RankList dev_list;
for (int32_t i = 0; i < 10; i++) {
dev_list.push_back(i);
}
std::vector<int32_t> stage_map;
RankList stage_map;
stage_map.push_back(8);
stage_map.push_back(2);
@ -1327,8 +1327,8 @@ TEST_F(TestDPAlgo, test_GetStrategy_for_DoubleStarGraph) {
for (auto &op : cost_graph->GetOperators()) {
StrategyPtr s_strategy = op->selected_strategy();
std::vector<int32_t> strategy_0 = s_strategy->GetInputDim()[0];
std::vector<int32_t> strategy_1 = s_strategy->GetInputDim()[1];
Dimensions strategy_0 = s_strategy->GetInputDim()[0];
Dimensions strategy_1 = s_strategy->GetInputDim()[1];
std::string string_strategy_0 = "[";
for (size_t i = 0; i < strategy_0.size(); ++i) {

4
tests/ut/cpp/parallel/auto_parallel/edge_costmodel_test.cc
View File

@ -43,13 +43,13 @@ class TestEdgeCostModel : public UT::Common {
};
void TestEdgeCostModel::SetUp() {
std::vector<int32_t> dev_list;
RankList dev_list;
for (int32_t i = 0; i < 10; i++) {
dev_list.push_back(i);
}
std::vector<int32_t> stage_map;
RankList stage_map;
stage_map.push_back(8);
stage_map.push_back(2);

4
tests/ut/cpp/parallel/auto_parallel/graph_costmodel_test.cc
View File

@ -53,13 +53,13 @@ class TestCostGraph : public UT::Common {
void TestCostGraph::SetUp() {
cost_graph.SetDeviceMemoryAndCostParameter();
std::vector<int32_t> dev_list;
RankList dev_list;
for (int32_t i = 0; i < 10; i++) {
dev_list.push_back(i);
}
std::vector<int32_t> stage_map;
RankList stage_map;
stage_map.push_back(8);
stage_map.push_back(2);

12
tests/ut/cpp/parallel/auto_parallel/operator_costmodel_test.cc
View File

@ -33,13 +33,13 @@ class TestMatMulCost : public UT::Common {
void TestMatMulCost::SetUp() {
mmcost_ = MatMulCost();
std::vector<int32_t> dev_list;
RankList dev_list;
for (int32_t i = 0; i < 1050; i++) {
dev_list.push_back(i);
}
std::vector<int32_t> stage_map;
RankList stage_map;
stage_map.push_back(1024);
stage_map.push_back(26);
@ -90,13 +90,13 @@ class TestActivationCost : public UT::Common {
void TestActivationCost::SetUp() {
ac_cost_ = ActivationCost();
std::vector<int32_t> dev_list;
RankList dev_list;
for (int32_t i = 0; i < 1050; i++) {
dev_list.push_back(i);
}
std::vector<int32_t> stage_map;
RankList stage_map;
stage_map.push_back(1024);
stage_map.push_back(26);
@ -142,13 +142,13 @@ class TestPReLUCost : public UT::Common {
void TestPReLUCost::SetUp() {
prelu_cost_ = PReLUCost();
std::vector<int32_t> dev_list;
RankList dev_list;
for (int32_t i = 0; i < 1050; i++) {
dev_list.push_back(i);
}
std::vector<int32_t> stage_map;
RankList stage_map;
stage_map.push_back(1024);
stage_map.push_back(26);

12
tests/ut/cpp/parallel/device_manager_test.cc
View File

@ -69,8 +69,8 @@ void TestDeviceManager::TearDown() {
}
TEST_F(TestDeviceManager, test_dm_init_AND_get_device_list) {
std::vector<int32_t> dev_list;
std::vector<int32_t> stage_map;
RankList dev_list;
RankList stage_map;
int32_t local_dev = 0;
dev_list.push_back(5);
@ -85,12 +85,12 @@ TEST_F(TestDeviceManager, test_dm_init_AND_get_device_list) {
ASSERT_EQ(dm_.DeviceNum(), 4);
ASSERT_EQ(dm_.GetStageNum(), (int32_t)(2));
std::vector<int32_t> dev_list_0 = dm_.GetDeviceListByStageId(0);
std::vector<int32_t> dev_list_1 = dm_.GetDeviceListByStageId(1);
RankList dev_list_0 = dm_.GetDeviceListByStageId(0);
RankList dev_list_1 = dm_.GetDeviceListByStageId(1);
ASSERT_EQ(dev_list_0.size(), 2);
ASSERT_EQ(dev_list_1.size(), 2);
std::vector<int32_t>::iterator it = dev_list_0.begin();
RankList::iterator it = dev_list_0.begin();
ASSERT_EQ((*it), int32_t(5));
it++;
ASSERT_EQ((*it), int32_t(3));
@ -112,7 +112,7 @@ TEST_F(TestDeviceManager, test_CreateNewDeviceByRank) {
TEST_F(TestDeviceManager, test_CreateDeviceListByRankList) {
std::vector<Device> dev_list;
std::vector<int32_t> rlist;
RankList rlist;
rlist.push_back(int32_t(2));
rlist.push_back(int32_t(1));
dev_list = dm_.CreateDeviceListByRankList(rlist);

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

@ -38,13 +38,13 @@ class TestActivationInfo : public UT::Common {
};
void TestActivationInfo::SetUp() {
std::vector<int32_t> dev_list;
RankList dev_list;
for (int32_t i = 0; i < 1050; i++) {
dev_list.push_back(i);
}
std::vector<int32_t> stage_map;
RankList stage_map;
stage_map.push_back(1024);
stage_map.push_back(26);
@ -64,18 +64,18 @@ void TestActivationInfo::SetUp() {
}
TEST_F(TestActivationInfo, InferDevMatrixShape1) {
std::vector<Dimensions> inputs = {{2, 4, 8, 16}};
Strategys inputs = {{2, 4, 8, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
activation->Init(strategy);
std::vector<int32_t> dev_matrix_shape = activation->dev_matrix_shape();
Shape dev_matrix_shape = activation->dev_matrix_shape();
std::vector<int32_t> expect = {2, 4, 8, 16};
Shape expect = {2, 4, 8, 16};
ASSERT_EQ(dev_matrix_shape, expect);
}
TEST_F(TestActivationInfo, InferSliceShape1) {
std::vector<Dimensions> str = {{2, 4, 8, 16}};
Strategys str = {{2, 4, 8, 16}};
StrategyPtr strategy = NewStrategy(0, str);
activation->Init(strategy);
@ -96,7 +96,7 @@ TEST_F(TestActivationInfo, InferSliceShape1) {
}
TEST_F(TestActivationInfo, GetTensorLayout1) {
std::vector<Dimensions> str = {{2, 4, 8, 16}};
Strategys str = {{2, 4, 8, 16}};
StrategyPtr strategy = NewStrategy(0, str);
activation->Init(strategy);
@ -117,7 +117,7 @@ TEST_F(TestActivationInfo, GetTensorLayout1) {
}
TEST_F(TestActivationInfo, GetForwardOp1) {
std::vector<Dimensions> inputs = {{2, 4, 8, 16}};
Strategys inputs = {{2, 4, 8, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
activation->Init(strategy);
@ -128,7 +128,7 @@ TEST_F(TestActivationInfo, GetForwardOp1) {
}
TEST_F(TestActivationInfo, GetMirrorOPs1) {
std::vector<Dimensions> inputs = {{1, 4, 8, 16}};
Strategys inputs = {{1, 4, 8, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
activation->Init(strategy);
@ -148,7 +148,7 @@ TEST_F(TestActivationInfo, GetMirrorOPs1) {
}
TEST_F(TestActivationInfo, GetMirrorOPs2) {
std::vector<Dimensions> inputs = {{2, 4, 8, 16}};
Strategys inputs = {{2, 4, 8, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
activation->Init(strategy);
@ -161,7 +161,7 @@ TEST_F(TestActivationInfo, GetMirrorOPs2) {
TEST_F(TestActivationInfo, CheckStrategy1) {
// Success: {{2,4,8,16}}
std::vector<Dimensions> inputs = {{2, 2, 8, 16}, {2, 4, 16, 1}};
Strategys inputs = {{2, 2, 8, 16}, {2, 4, 16, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = activation->Init(strategy);
@ -170,7 +170,7 @@ TEST_F(TestActivationInfo, CheckStrategy1) {
TEST_F(TestActivationInfo, CheckStrategy2) {
// Success: {{2,4,8,16}}
std::vector<Dimensions> inputs = {{2, 4, 8}};
Strategys inputs = {{2, 4, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = activation->Init(strategy);

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

@ -40,13 +40,13 @@ class TestActivation : public UT::Common {
};
void TestActivation::SetUp() {
std::vector<int32_t> dev_list;
RankList dev_list;
for (int32_t i = 0; i < 1050; i++) {
dev_list.push_back(i);
}
std::vector<int32_t> stage_map;
RankList stage_map;
stage_map.push_back(1024);
stage_map.push_back(26);
@ -101,7 +101,7 @@ TEST_F(TestActivation, test_softmax_strategies) {
ASSERT_NE(sp, nullptr);
Cost cost = *(swc->cost_list[0]);
std::vector<Dimensions> stra = sp->GetInputDim();
Strategys stra = sp->GetInputDim();
ASSERT_GT(stra.size(), 0);
Dimensions input0_stra = stra[0];
ASSERT_GT(input0_stra.size(), 2);

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

@ -38,13 +38,13 @@ class TestGeluInfo : public UT::Common {
};
void TestGeluInfo::SetUp() {
std::vector<int32_t> dev_list;
RankList dev_list;
for (int32_t i = 0; i < 130; i++) {
dev_list.push_back(i);
}
std::vector<int32_t> stage_map;
RankList stage_map;
stage_map.push_back(128);
stage_map.push_back(2);
@ -63,18 +63,18 @@ void TestGeluInfo::SetUp() {
}
TEST_F(TestGeluInfo, InferDevMatrixShape1) {
std::vector<Dimensions> inputs = {{2, 4, 1, 16}};
Strategys inputs = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
gelu->Init(strategy);
std::vector<int32_t> dev_matrix_shape = gelu->dev_matrix_shape();
Shape dev_matrix_shape = gelu->dev_matrix_shape();
std::vector<int32_t> expect = {2, 4, 1, 16};
Shape expect = {2, 4, 1, 16};
ASSERT_EQ(dev_matrix_shape, expect);
}
TEST_F(TestGeluInfo, InferSliceShape1) {
std::vector<Dimensions> str = {{2, 4, 1, 16}};
Strategys str = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, str);
gelu->Init(strategy);
@ -95,7 +95,7 @@ TEST_F(TestGeluInfo, InferSliceShape1) {
}
TEST_F(TestGeluInfo, GetTensorLayout1) {
std::vector<Dimensions> str = {{2, 4, 1, 16}};
Strategys str = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, str);
gelu->Init(strategy);
@ -116,7 +116,7 @@ TEST_F(TestGeluInfo, GetTensorLayout1) {
}
TEST_F(TestGeluInfo, GetForwardOp1) {
std::vector<Dimensions> inputs = {{2, 4, 1, 16}};
Strategys inputs = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
gelu->Init(strategy);
@ -127,7 +127,7 @@ TEST_F(TestGeluInfo, GetForwardOp1) {
}
TEST_F(TestGeluInfo, GetMirrorOPs1) {
std::vector<Dimensions> inputs = {{2, 4, 1, 16}};
Strategys inputs = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
gelu->Init(strategy);
@ -140,7 +140,7 @@ TEST_F(TestGeluInfo, GetMirrorOPs1) {
TEST_F(TestGeluInfo, CheckStrategy1) {
// Success: {{2,4,1,16}}
std::vector<Dimensions> inputs = {{2, 2, 8, 16}, {2, 4, 16, 1}};
Strategys inputs = {{2, 2, 8, 16}, {2, 4, 16, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = gelu->Init(strategy);
@ -149,7 +149,7 @@ TEST_F(TestGeluInfo, CheckStrategy1) {
TEST_F(TestGeluInfo, CheckStrategy2) {
// Success: {{2,4,1,16}}
std::vector<Dimensions> inputs = {{2, 4, 8}};
Strategys inputs = {{2, 4, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = gelu->Init(strategy);
@ -158,7 +158,7 @@ TEST_F(TestGeluInfo, CheckStrategy2) {
TEST_F(TestGeluInfo, CheckStrategy3) {
// Success: {{2,4,1,16}}
std::vector<Dimensions> inputs = {{2, 4, 1, 16}};
Strategys inputs = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = gelu->Init(strategy);

4
tests/ut/cpp/parallel/ops_info/generate_strategy_test.cc
View File

@ -34,13 +34,13 @@ class TestGenerateStrategy : public UT::Common {
};
void TestGenerateStrategy::SetUp() {
std::vector<int32_t> dev_list;
RankList dev_list;
for (int32_t i = 0; i < 10; i++) {
dev_list.push_back(i);
}
std::vector<int32_t> stage_map;
RankList stage_map;
stage_map.push_back(8);
stage_map.push_back(2);

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

@ -38,13 +38,13 @@ class TestGetNextInfo : public UT::Common {
};
void TestGetNextInfo::SetUp() {
std::vector<int32_t> dev_list;
RankList dev_list;
for (int32_t i = 0; i < 8; i++) {
dev_list.push_back(i);
}
std::vector<int32_t> stage_map;
RankList stage_map;
stage_map.push_back(8);
int32_t local_dev = 0;
// create a new g_device_manager
@ -65,16 +65,16 @@ void TestGetNextInfo::SetUp() {
}
TEST_F(TestGetNextInfo, InferDevMatrixShape1) {
std::vector<Dimensions> inputs = {{}, {}};
Strategys inputs = {{}, {}};
StrategyPtr strategy = NewStrategy(0, inputs);
get_next->Init(strategy);
std::vector<int32_t> dev_matrix_shape = get_next->dev_matrix_shape();
std::vector<int32_t> expect = {8, 1};
Shape dev_matrix_shape = get_next->dev_matrix_shape();
Shape expect = {8, 1};
ASSERT_EQ(dev_matrix_shape, expect);
}
TEST_F(TestGetNextInfo, InferSliceShape1) {
std::vector<Dimensions> str = {{}, {}};
Strategys str = {{}, {}};
StrategyPtr strategy = NewStrategy(0, str);
get_next->Init(strategy);
@ -90,7 +90,7 @@ TEST_F(TestGetNextInfo, InferSliceShape1) {
}
TEST_F(TestGetNextInfo, GetTensorLayout1) {
std::vector<Dimensions> str = {{}, {}};
Strategys str = {{}, {}};
StrategyPtr strategy = NewStrategy(0, str);
get_next->Init(strategy);
std::vector<TensorInfo> outputs = get_next->outputs_tensor_info();
@ -106,14 +106,14 @@ TEST_F(TestGetNextInfo, GetTensorLayout1) {
}
TEST_F(TestGetNextInfo, CheckStrategy1) {
std::vector<Dimensions> inputs = {};
Strategys inputs = {};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = get_next->Init(strategy);
ASSERT_EQ(ret, SUCCESS);
}
TEST_F(TestGetNextInfo, CheckStrategy2) {
std::vector<Dimensions> inputs = {{8, 1}, {8}};
Strategys inputs = {{8, 1}, {8}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = get_next->Init(strategy);
ASSERT_EQ(ret, FAILED);

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

@ -38,13 +38,13 @@ class TestL2NormalizeInfo : public UT::Common {
};
void TestL2NormalizeInfo::SetUp() {
std::vector<int32_t> dev_list;
RankList dev_list;
for (int32_t i = 0; i < 34; i++) {
dev_list.push_back(i);
}
std::vector<int32_t> stage_map;
RankList stage_map;
stage_map.push_back(32);
stage_map.push_back(2);
@ -64,18 +64,18 @@ void TestL2NormalizeInfo::SetUp() {
}
TEST_F(TestL2NormalizeInfo, InferDevMatrixShape1) {
std::vector<Dimensions> inputs = {{4, 1, 8}};
Strategys inputs = {{4, 1, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
norm->Init(strategy);
std::vector<int32_t> dev_matrix_shape = norm->dev_matrix_shape();
Shape dev_matrix_shape = norm->dev_matrix_shape();
std::vector<int32_t> expect = {4, 1, 8};
Shape expect = {4, 1, 8};
ASSERT_EQ(dev_matrix_shape, expect);
}
TEST_F(TestL2NormalizeInfo, InferSliceShape1) {
std::vector<Dimensions> str = {{4, 1, 8}};
Strategys str = {{4, 1, 8}};
StrategyPtr strategy = NewStrategy(0, str);
norm->Init(strategy);
@ -96,7 +96,7 @@ TEST_F(TestL2NormalizeInfo, InferSliceShape1) {
}
TEST_F(TestL2NormalizeInfo, GetTensorLayout1) {
std::vector<Dimensions> str = {{4, 1, 8}};
Strategys str = {{4, 1, 8}};
StrategyPtr strategy = NewStrategy(0, str);
norm->Init(strategy);
@ -117,7 +117,7 @@ TEST_F(TestL2NormalizeInfo, GetTensorLayout1) {
}
TEST_F(TestL2NormalizeInfo, GetForwardOp1) {
std::vector<Dimensions> inputs = {{4, 1, 8}};
Strategys inputs = {{4, 1, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
norm->Init(strategy);
@ -128,7 +128,7 @@ TEST_F(TestL2NormalizeInfo, GetForwardOp1) {
}
TEST_F(TestL2NormalizeInfo, GetMirrorOPs1) {
std::vector<Dimensions> inputs = {{4, 1, 8}};
Strategys inputs = {{4, 1, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
norm->Init(strategy);
@ -140,7 +140,7 @@ TEST_F(TestL2NormalizeInfo, GetMirrorOPs1) {
}
TEST_F(TestL2NormalizeInfo, CheckStrategy1) {
std::vector<Dimensions> inputs = {{4, 1, 8}, {4, 1, 8}};
Strategys inputs = {{4, 1, 8}, {4, 1, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = norm->Init(strategy);
@ -148,7 +148,7 @@ TEST_F(TestL2NormalizeInfo, CheckStrategy1) {
}
TEST_F(TestL2NormalizeInfo, CheckStrategy2) {
std::vector<Dimensions> inputs = {{4, 2, 3}};
Strategys inputs = {{4, 2, 3}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = norm->Init(strategy);
@ -156,7 +156,7 @@ TEST_F(TestL2NormalizeInfo, CheckStrategy2) {
}
TEST_F(TestL2NormalizeInfo, CheckStrategy3) {
std::vector<Dimensions> inputs = {{4, 2, 3, 4}};
Strategys inputs = {{4, 2, 3, 4}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = norm->Init(strategy);
@ -164,7 +164,7 @@ TEST_F(TestL2NormalizeInfo, CheckStrategy3) {
}
TEST_F(TestL2NormalizeInfo, CheckStrategy4) {
std::vector<Dimensions> inputs = {{4, 1, 8}};
Strategys inputs = {{4, 1, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = norm->Init(strategy);
@ -172,7 +172,7 @@ TEST_F(TestL2NormalizeInfo, CheckStrategy4) {
}
TEST_F(TestL2NormalizeInfo, mirror_ops) {
std::vector<Dimensions> inputs = {{2, 1, 8}};
Strategys inputs = {{2, 1, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
norm->Init(strategy);

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

@ -38,13 +38,13 @@ class TestLogSoftmaxInfo : public UT::Common {
};
void TestLogSoftmaxInfo::SetUp() {
std::vector<int32_t> dev_list;
RankList dev_list;
for (int32_t i = 0; i < 130; i++) {
dev_list.push_back(i);
}
std::vector<int32_t> stage_map;
RankList stage_map;
stage_map.push_back(128);
stage_map.push_back(2);
@ -64,18 +64,18 @@ void TestLogSoftmaxInfo::SetUp() {
}
TEST_F(TestLogSoftmaxInfo, InferDevMatrixShape1) {
std::vector<Dimensions> inputs = {{2, 4, 1, 16}};
Strategys inputs = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
log_softmax->Init(strategy);
std::vector<int32_t> dev_matrix_shape = log_softmax->dev_matrix_shape();
Shape dev_matrix_shape = log_softmax->dev_matrix_shape();
std::vector<int32_t> expect = {2, 4, 1, 16};
Shape expect = {2, 4, 1, 16};
ASSERT_EQ(dev_matrix_shape, expect);
}
TEST_F(TestLogSoftmaxInfo, InferSliceShape1) {
std::vector<Dimensions> str = {{2, 4, 1, 16}};
Strategys str = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, str);
log_softmax->Init(strategy);
@ -96,7 +96,7 @@ TEST_F(TestLogSoftmaxInfo, InferSliceShape1) {
}
TEST_F(TestLogSoftmaxInfo, GetTensorLayout1) {
std::vector<Dimensions> str = {{2, 4, 1, 16}};
Strategys str = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, str);
log_softmax->Init(strategy);
@ -117,7 +117,7 @@ TEST_F(TestLogSoftmaxInfo, GetTensorLayout1) {
}
TEST_F(TestLogSoftmaxInfo, GetForwardOp1) {
std::vector<Dimensions> inputs = {{2, 4, 1, 16}};
Strategys inputs = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
log_softmax->Init(strategy);
@ -128,7 +128,7 @@ TEST_F(TestLogSoftmaxInfo, GetForwardOp1) {
}
TEST_F(TestLogSoftmaxInfo, GetMirrorOPs1) {
std::vector<Dimensions> inputs = {{2, 4, 1, 16}};
Strategys inputs = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
log_softmax->Init(strategy);
@ -141,7 +141,7 @@ TEST_F(TestLogSoftmaxInfo, GetMirrorOPs1) {
TEST_F(TestLogSoftmaxInfo, CheckStrategy1) {
// Success: {{2,4,1,16}}
std::vector<Dimensions> inputs = {{2, 2, 8, 16}, {2, 4, 16, 1}};
Strategys inputs = {{2, 2, 8, 16}, {2, 4, 16, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = log_softmax->Init(strategy);
@ -150,7 +150,7 @@ TEST_F(TestLogSoftmaxInfo, CheckStrategy1) {
TEST_F(TestLogSoftmaxInfo, CheckStrategy2) {
// Success: {{2,4,1,16}}
std::vector<Dimensions> inputs = {{2, 4, 8}};
Strategys inputs = {{2, 4, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = log_softmax->Init(strategy);
@ -159,7 +159,7 @@ TEST_F(TestLogSoftmaxInfo, CheckStrategy2) {
TEST_F(TestLogSoftmaxInfo, CheckStrategy3) {
// Success: {{2,4,1,16}}
std::vector<Dimensions> inputs = {{2, 4, 8, 16}};
Strategys inputs = {{2, 4, 8, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = log_softmax->Init(strategy);
@ -167,7 +167,7 @@ TEST_F(TestLogSoftmaxInfo, CheckStrategy3) {
}
TEST_F(TestLogSoftmaxInfo, GetDeviceList1) {
std::vector<Dimensions> inputs = {{2, 4, 1, 16}};
Strategys inputs = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
log_softmax->Init(strategy);

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

@ -42,13 +42,13 @@ class TestMatmulInfo : public UT::Common {
};
void TestMatmulInfo::SetUp() {
std::vector<int32_t> dev_list;
RankList dev_list;
for (int32_t i = 0; i < 1050; i++) {
dev_list.push_back(i);
}
std::vector<int32_t> stage_map;
RankList stage_map;
stage_map.push_back(1024);
stage_map.push_back(26);
@ -94,77 +94,77 @@ void TestMatmulInfo::SetUp() {
}
TEST_F(TestMatmulInfo, InferDevMatrixShape1) {
std::vector<Dimensions> inputs = {{2, 4, 8, 16}, {2, 4, 16, 1}};
Strategys inputs = {{2, 4, 8, 16}, {2, 4, 16, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
matmul1->Init(strategy);
std::vector<int32_t> dev_matrix_shape = matmul1->dev_matrix_shape();
Shape dev_matrix_shape = matmul1->dev_matrix_shape();
std::vector<int32_t> expect = {2, 4, 8, 16, 1};
Shape expect = {2, 4, 8, 16, 1};
ASSERT_EQ(dev_matrix_shape, expect);
}
TEST_F(TestMatmulInfo, InferDevMatrixShape2) {
std::vector<Dimensions> inputs = {{2, 4, 8, 8}, {2, 4, 8, 2}};
Strategys inputs = {{2, 4, 8, 8}, {2, 4, 8, 2}};
StrategyPtr strategy = NewStrategy(0, inputs);
matmul1->Init(strategy);
std::vector<int32_t> dev_matrix_shape = matmul1->dev_matrix_shape();
Shape dev_matrix_shape = matmul1->dev_matrix_shape();
std::vector<int32_t> expect = {2, 4, 8, 8, 2};
Shape expect = {2, 4, 8, 8, 2};
ASSERT_EQ(dev_matrix_shape, expect);
}
// matmul2
TEST_F(TestMatmulInfo, InferDevMatrixShape3) {
std::vector<Dimensions> inputs = {{2, 4, 8, 16}, {1, 16}};
Strategys inputs = {{2, 4, 8, 16}, {1, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
matmul2->Init(strategy);
std::vector<int32_t> dev_matrix_shape = matmul2->dev_matrix_shape();
Shape dev_matrix_shape = matmul2->dev_matrix_shape();
std::vector<int32_t> expect = {2, 4, 8, 16, 1};
Shape expect = {2, 4, 8, 16, 1};
ASSERT_EQ(dev_matrix_shape, expect);
}
// matmul2
TEST_F(TestMatmulInfo, InferDevMatrixShape4) {
std::vector<Dimensions> inputs = {{2, 4, 8, 8}, {2, 8}};
Strategys inputs = {{2, 4, 8, 8}, {2, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
matmul2->Init(strategy);
std::vector<int32_t> dev_matrix_shape = matmul2->dev_matrix_shape();
Shape dev_matrix_shape = matmul2->dev_matrix_shape();
std::vector<int32_t> expect = {2, 4, 8, 8, 2};
Shape expect = {2, 4, 8, 8, 2};
ASSERT_EQ(dev_matrix_shape, expect);
}
// matmul3
TEST_F(TestMatmulInfo, InferDevMatrixShape5) {
std::vector<Dimensions> inputs = {{8, 16}, {2, 4, 1, 16}};
Strategys inputs = {{8, 16}, {2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
matmul3->Init(strategy);
std::vector<int32_t> dev_matrix_shape = matmul3->dev_matrix_shape();
Shape dev_matrix_shape = matmul3->dev_matrix_shape();
std::vector<int32_t> expect = {2, 4, 8, 16, 1};
Shape expect = {2, 4, 8, 16, 1};
ASSERT_EQ(dev_matrix_shape, expect);
}
// matmul3
TEST_F(TestMatmulInfo, InferDevMatrixShape6) {
std::vector<Dimensions> inputs = {{8, 8}, {2, 4, 2, 8}};
Strategys inputs = {{8, 8}, {2, 4, 2, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
matmul3->Init(strategy);
std::vector<int32_t> dev_matrix_shape = matmul3->dev_matrix_shape();
Shape dev_matrix_shape = matmul3->dev_matrix_shape();
std::vector<int32_t> expect = {2, 4, 8, 8, 2};
Shape expect = {2, 4, 8, 8, 2};
ASSERT_EQ(dev_matrix_shape, expect);
}
TEST_F(TestMatmulInfo, InferTensorMap1) {
std::vector<Dimensions> str = {{2, 4, 8, 16}, {2, 4, 16, 1}};
Strategys str = {{2, 4, 8, 16}, {2, 4, 16, 1}};
StrategyPtr strategy = NewStrategy(0, str);
matmul1->Init(strategy);
@ -190,7 +190,7 @@ TEST_F(TestMatmulInfo, InferTensorMap1) {
// matmul2
TEST_F(TestMatmulInfo, InferTensorMap2) {
std::vector<Dimensions> str = {{2, 4, 8, 16}, {1, 16}};
Strategys str = {{2, 4, 8, 16}, {1, 16}};
StrategyPtr strategy = NewStrategy(0, str);
matmul2->Init(strategy);
@ -216,7 +216,7 @@ TEST_F(TestMatmulInfo, InferTensorMap2) {
// matmul3
TEST_F(TestMatmulInfo, InferTensorMap3) {
std::vector<Dimensions> str = {{8, 16}, {2, 4, 1, 16}};
Strategys str = {{8, 16}, {2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, str);
matmul3->Init(strategy);
@ -241,7 +241,7 @@ TEST_F(TestMatmulInfo, InferTensorMap3) {
}
TEST_F(TestMatmulInfo, InferSliceShape1) {
std::vector<Dimensions> str = {{2, 4, 8, 16}, {2, 4, 16, 1}};
Strategys str = {{2, 4, 8, 16}, {2, 4, 16, 1}};
StrategyPtr strategy = NewStrategy(0, str);
matmul1->Init(strategy);
@ -267,7 +267,7 @@ TEST_F(TestMatmulInfo, InferSliceShape1) {
// matmul2
TEST_F(TestMatmulInfo, InferSliceShape2) {
std::vector<Dimensions> str = {{2, 4, 8, 16}, {1, 16}};
Strategys str = {{2, 4, 8, 16}, {1, 16}};
StrategyPtr strategy = NewStrategy(0, str);
matmul2->Init(strategy);
@ -293,7 +293,7 @@ TEST_F(TestMatmulInfo, InferSliceShape2) {
// matmul3
TEST_F(TestMatmulInfo, InferSliceShape3) {
std::vector<Dimensions> str = {{8, 16}, {2, 4, 1, 16}};
Strategys str = {{8, 16}, {2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, str);
matmul3->Init(strategy);
@ -319,7 +319,7 @@ TEST_F(TestMatmulInfo, InferSliceShape3) {
// matmul3
TEST_F(TestMatmulInfo, GetTensorLayout3) {
std::vector<Dimensions> str = {{8, 16}, {2, 4, 1, 16}};
Strategys str = {{8, 16}, {2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, str);
matmul3->Init(strategy);
@ -344,7 +344,7 @@ TEST_F(TestMatmulInfo, GetTensorLayout3) {
}
TEST_F(TestMatmulInfo, GetForwardOp1) {
std::vector<Dimensions> inputs = {{2, 4, 8, 16}, {2, 4, 16, 1}};
Strategys inputs = {{2, 4, 8, 16}, {2, 4, 16, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
matmul1->Init(strategy);
@ -370,7 +370,7 @@ TEST_F(TestMatmulInfo, GetForwardOp1) {
}
TEST_F(TestMatmulInfo, GetForwardOp2) {
std::vector<Dimensions> inputs = {{2, 4, 8, 1}, {2, 4, 1, 16}};
Strategys inputs = {{2, 4, 8, 1}, {2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
matmul1->Init(strategy);
@ -380,7 +380,7 @@ TEST_F(TestMatmulInfo, GetForwardOp2) {
}
TEST_F(TestMatmulInfo, GetVirtualDivOp1) {
std::vector<Dimensions> inputs = {{2, 4, 8, 16}, {2, 4, 16, 1}};
Strategys inputs = {{2, 4, 8, 16}, {2, 4, 16, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
matmul1->Init(strategy);
@ -399,7 +399,7 @@ TEST_F(TestMatmulInfo, GetVirtualDivOp1) {
}
TEST_F(TestMatmulInfo, GetMirrorOPs1) {
std::vector<Dimensions> inputs = {{2, 4, 8, 16}, {2, 4, 16, 1}};
Strategys inputs = {{2, 4, 8, 16}, {2, 4, 16, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
matmul1->Init(strategy);
@ -419,7 +419,7 @@ TEST_F(TestMatmulInfo, GetMirrorOPs1) {
// matmul2
TEST_F(TestMatmulInfo, GetMirrorOPs2) {
std::vector<Dimensions> inputs = {{2, 4, 1, 16}, {8, 16}};
Strategys inputs = {{2, 4, 1, 16}, {8, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
matmul2->Init(strategy);
@ -439,7 +439,7 @@ TEST_F(TestMatmulInfo, GetMirrorOPs2) {
// matmul3
TEST_F(TestMatmulInfo, GetMirrorOPs3) {
std::vector<Dimensions> inputs = {{8, 16}, {2, 4, 1, 16}};
Strategys inputs = {{8, 16}, {2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
matmul3->Init(strategy);
@ -457,7 +457,7 @@ TEST_F(TestMatmulInfo, GetMirrorOPs3) {
}
TEST_F(TestMatmulInfo, GetMirrorOPs4) {
std::vector<Dimensions> inputs = {{2, 4, 1, 16}, {2, 4, 16, 8}};
Strategys inputs = {{2, 4, 1, 16}, {2, 4, 16, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
matmul1->Init(strategy);
@ -467,7 +467,7 @@ TEST_F(TestMatmulInfo, GetMirrorOPs4) {
}
TEST_F(TestMatmulInfo, InitTwice) {
std::vector<Dimensions> inputs = {{2, 4, 8, 16}, {2, 4, 16, 1}};
Strategys inputs = {{2, 4, 8, 16}, {2, 4, 16, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
// init twice
@ -489,7 +489,7 @@ TEST_F(TestMatmulInfo, InitTwice) {
TEST_F(TestMatmulInfo, CheckStrategy1) {
// Success: {{2,4,8,16}, {2,4,16,1}}
std::vector<Dimensions> inputs = {{2, 2, 8, 16}, {2, 4, 16, 1}};
Strategys inputs = {{2, 2, 8, 16}, {2, 4, 16, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = matmul1->Init(strategy);
@ -498,7 +498,7 @@ TEST_F(TestMatmulInfo, CheckStrategy1) {
TEST_F(TestMatmulInfo, CheckStrategy2) {
// Success: {{2,4,8,16}, {2,4,16,1}}
std::vector<Dimensions> inputs = {{2, 4, 8, 16}, {4, 16, 1}};
Strategys inputs = {{2, 4, 8, 16}, {4, 16, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = matmul1->Init(strategy);
@ -507,7 +507,7 @@ TEST_F(TestMatmulInfo, CheckStrategy2) {
TEST_F(TestMatmulInfo, CheckStrategy3) {
// Success: {{2,4,8,16}, {2,4,16,1}}
std::vector<Dimensions> inputs = {{2, 4, 8, 16}, {2, 4, 8, 1}};
Strategys inputs = {{2, 4, 8, 16}, {2, 4, 8, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = matmul1->Init(strategy);
@ -516,7 +516,7 @@ TEST_F(TestMatmulInfo, CheckStrategy3) {
TEST_F(TestMatmulInfo, CheckStrategy4) {
// Success: {{2,4,8,16}, {2,4,16,1}}
std::vector<Dimensions> inputs = {{2, 4, 8, 16}, {2, 3, 16, 1}};
Strategys inputs = {{2, 4, 8, 16}, {2, 3, 16, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = matmul1->Init(strategy);
@ -525,7 +525,7 @@ TEST_F(TestMatmulInfo, CheckStrategy4) {
TEST_F(TestMatmulInfo, CheckStrategy5) {
// Success: {{2,4,8,16}, {2,4,16,1}}
std::vector<Dimensions> inputs = {{0, 4, 8, 16}, {2, 4, 16, 1}};
Strategys inputs = {{0, 4, 8, 16}, {2, 4, 16, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = matmul1->Init(strategy);
@ -534,7 +534,7 @@ TEST_F(TestMatmulInfo, CheckStrategy5) {
TEST_F(TestMatmulInfo, CheckStrategy6) {
// Success: {{2,4,8,16}, {2,4,16,1}}
std::vector<Dimensions> inputs = {{-1, 4, 8, 16}, {2, 4, 16, 1}};
Strategys inputs = {{-1, 4, 8, 16}, {2, 4, 16, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = matmul1->Init(strategy);
@ -543,7 +543,7 @@ TEST_F(TestMatmulInfo, CheckStrategy6) {
TEST_F(TestMatmulInfo, CheckStrategy7) {
// Success: {{2,4,8,16}, {2,4,16,1}}
std::vector<Dimensions> inputs = {{4, 4, 8, 16}, {2, 4, 16, 1}};
Strategys inputs = {{4, 4, 8, 16}, {2, 4, 16, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = matmul1->Init(strategy);
@ -552,7 +552,7 @@ TEST_F(TestMatmulInfo, CheckStrategy7) {
TEST_F(TestMatmulInfo, InitFailed) {
// matmul4 attr is wrong
std::vector<Dimensions> inputs = {{4, 4, 8, 16}, {2, 4, 16, 1}};
Strategys inputs = {{4, 4, 8, 16}, {2, 4, 16, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = matmul4->Init(strategy);

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

@ -38,13 +38,13 @@ class TestOneHotInfo : public UT::Common {
};
void TestOneHotInfo::SetUp() {
std::vector<int32_t> dev_list;
RankList dev_list;
for (int32_t i = 0; i < 10; i++) {
dev_list.push_back(i);
}
std::vector<int32_t> stage_map;
RankList stage_map;
stage_map.push_back(8);
stage_map.push_back(2);
@ -64,43 +64,43 @@ void TestOneHotInfo::SetUp() {
}
TEST_F(TestOneHotInfo, InferDevMatrixShape1) {
std::vector<Dimensions> inputs = {{8, 1}, {}, {}};
Strategys inputs = {{8, 1}, {}, {}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status status = onehot_info->Init(strategy);
ASSERT_EQ(status, SUCCESS);
std::vector<int32_t> dev_matrix_shape = onehot_info->dev_matrix_shape();
Shape dev_matrix_shape = onehot_info->dev_matrix_shape();
std::vector<int32_t> expect = {8, 1};
Shape expect = {8, 1};
ASSERT_EQ(dev_matrix_shape, expect);
}
TEST_F(TestOneHotInfo, InferDevMatrixShape2) {
std::vector<Dimensions> inputs = {{4, 1}, {}, {}};
Strategys inputs = {{4, 1}, {}, {}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status status = onehot_info->Init(strategy);
ASSERT_EQ(status, SUCCESS);
std::vector<int32_t> dev_matrix_shape = onehot_info->dev_matrix_shape();
Shape dev_matrix_shape = onehot_info->dev_matrix_shape();
std::vector<int32_t> expect = {2, 4, 1};
Shape expect = {2, 4, 1};
ASSERT_EQ(dev_matrix_shape, expect);
}
TEST_F(TestOneHotInfo, InferDevMatrixShape3) {
std::vector<Dimensions> inputs = {{4, 2}, {}, {}};
Strategys inputs = {{4, 2}, {}, {}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status status = onehot_info->Init(strategy);
ASSERT_EQ(status, FAILED);
std::vector<int32_t> dev_matrix_shape = onehot_info->dev_matrix_shape();
Shape dev_matrix_shape = onehot_info->dev_matrix_shape();
std::vector<int32_t> expect = {4, 2};
Shape expect = {4, 2};
ASSERT_EQ(dev_matrix_shape, expect);
}
TEST_F(TestOneHotInfo, InferTensorMap2) {
std::vector<Dimensions> str = {{8, 1}, {}, {}};
Strategys str = {{8, 1}, {}, {}};
StrategyPtr strategy = NewStrategy(0, str);
Status status = onehot_info->Init(strategy);
@ -122,7 +122,7 @@ TEST_F(TestOneHotInfo, InferTensorMap2) {
}
TEST_F(TestOneHotInfo, InferSliceShape1) {
std::vector<Dimensions> str = {{8, 1}, {}, {}};
Strategys str = {{8, 1}, {}, {}};
StrategyPtr strategy = NewStrategy(0, str);
Status status = onehot_info->Init(strategy);
@ -144,7 +144,7 @@ TEST_F(TestOneHotInfo, InferSliceShape1) {
}
TEST_F(TestOneHotInfo, InferSliceShape2) {
std::vector<Dimensions> str = {{4, 2}, {}, {}};
Strategys str = {{4, 2}, {}, {}};
StrategyPtr strategy = NewStrategy(0, str);
Status status = onehot_info->Init(strategy);
@ -166,7 +166,7 @@ TEST_F(TestOneHotInfo, InferSliceShape2) {
}
TEST_F(TestOneHotInfo, InferSliceShape3) {
std::vector<Dimensions> str = {{2, 2}, {}, {}};
Strategys str = {{2, 2}, {}, {}};
StrategyPtr strategy = NewStrategy(0, str);
Status status = onehot_info->Init(strategy);
@ -188,7 +188,7 @@ TEST_F(TestOneHotInfo, InferSliceShape3) {
}
TEST_F(TestOneHotInfo, GetMirrorOPs1) {
std::vector<Dimensions> inputs = {{8, 1}, {}, {}};
Strategys inputs = {{8, 1}, {}, {}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status status = onehot_info->Init(strategy);
@ -199,7 +199,7 @@ TEST_F(TestOneHotInfo, GetMirrorOPs1) {
}
TEST_F(TestOneHotInfo, CheckStrategy1) {
std::vector<Dimensions> inputs = {{16}, {}, {}};
Strategys inputs = {{16}, {}, {}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = onehot_info->Init(strategy);

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

@ -38,13 +38,13 @@ class TestOneHotInfo2 : public UT::Common {
};
void TestOneHotInfo2::SetUp() {
std::vector<int32_t> dev_list;
RankList dev_list;
for (int32_t i = 0; i < 10; i++) {
dev_list.push_back(i);
}
std::vector<int32_t> stage_map;
RankList stage_map;
stage_map.push_back(8);
stage_map.push_back(2);
@ -64,43 +64,43 @@ void TestOneHotInfo2::SetUp() {
}
TEST_F(TestOneHotInfo2, InferDevMatrixShape1) {
std::vector<Dimensions> inputs = {{1, 8}, {}, {}};
Strategys inputs = {{1, 8}, {}, {}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status status = onehot_info2->Init(strategy);
ASSERT_EQ(status, SUCCESS);
std::vector<int32_t> dev_matrix_shape = onehot_info2->dev_matrix_shape();
Shape dev_matrix_shape = onehot_info2->dev_matrix_shape();
std::vector<int32_t> expect = {8, 1};
Shape expect = {8, 1};
ASSERT_EQ(dev_matrix_shape, expect);
}
TEST_F(TestOneHotInfo2, InferDevMatrixShape2) {
std::vector<Dimensions> inputs = {{1, 4}, {}, {}};
Strategys inputs = {{1, 4}, {}, {}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status status = onehot_info2->Init(strategy);
ASSERT_EQ(status, SUCCESS);
std::vector<int32_t> dev_matrix_shape = onehot_info2->dev_matrix_shape();
Shape dev_matrix_shape = onehot_info2->dev_matrix_shape();
std::vector<int32_t> expect = {2, 4, 1};
Shape expect = {2, 4, 1};
ASSERT_EQ(dev_matrix_shape, expect);
}
TEST_F(TestOneHotInfo2, InferDevMatrixShape3) {
std::vector<Dimensions> inputs = {{2, 4}, {}, {}};
Strategys inputs = {{2, 4}, {}, {}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status status = onehot_info2->Init(strategy);
ASSERT_EQ(status, FAILED);
std::vector<int32_t> dev_matrix_shape = onehot_info2->dev_matrix_shape();
Shape dev_matrix_shape = onehot_info2->dev_matrix_shape();
std::vector<int32_t> expect = {4, 2};
Shape expect = {4, 2};
ASSERT_EQ(dev_matrix_shape, expect);
}
TEST_F(TestOneHotInfo2, InferTensorMap2) {
std::vector<Dimensions> str = {{1, 8}, {}, {}};
Strategys str = {{1, 8}, {}, {}};
StrategyPtr strategy = NewStrategy(0, str);
Status status = onehot_info2->Init(strategy);
@ -122,7 +122,7 @@ TEST_F(TestOneHotInfo2, InferTensorMap2) {
}
TEST_F(TestOneHotInfo2, InferSliceShape1) {
std::vector<Dimensions> str = {{1, 8}, {}, {}};
Strategys str = {{1, 8}, {}, {}};
StrategyPtr strategy = NewStrategy(0, str);
Status status = onehot_info2->Init(strategy);
@ -144,7 +144,7 @@ TEST_F(TestOneHotInfo2, InferSliceShape1) {
}
TEST_F(TestOneHotInfo2, InferSliceShape2) {
std::vector<Dimensions> str = {{2, 4}, {}, {}};
Strategys str = {{2, 4}, {}, {}};
StrategyPtr strategy = NewStrategy(0, str);
Status status = onehot_info2->Init(strategy);
@ -166,7 +166,7 @@ TEST_F(TestOneHotInfo2, InferSliceShape2) {
}
TEST_F(TestOneHotInfo2, InferSliceShape3) {
std::vector<Dimensions> str = {{2, 2}, {}, {}};
Strategys str = {{2, 2}, {}, {}};
StrategyPtr strategy = NewStrategy(0, str);
Status status = onehot_info2->Init(strategy);

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

@ -38,13 +38,13 @@ class TestPowInfo : public UT::Common {
};
void TestPowInfo::SetUp() {
std::vector<int32_t> dev_list;
RankList dev_list;
for (int32_t i = 0; i < 66; i++) {
dev_list.push_back(i);
}
std::vector<int32_t> stage_map;
RankList stage_map;
stage_map.push_back(64);
stage_map.push_back(2);
@ -63,18 +63,18 @@ void TestPowInfo::SetUp() {
}
TEST_F(TestPowInfo, InferDevMatrixShape1) {
std::vector<Dimensions> inputs = {{2, 4, 8}, {2, 4, 8}};
Strategys inputs = {{2, 4, 8}, {2, 4, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
pow->Init(strategy);
std::vector<int32_t> dev_matrix_shape = pow->dev_matrix_shape();
Shape dev_matrix_shape = pow->dev_matrix_shape();
std::vector<int32_t> expect = {2, 4, 8};
Shape expect = {2, 4, 8};
ASSERT_EQ(dev_matrix_shape, expect);
}
TEST_F(TestPowInfo, InferSliceShape1) {
std::vector<Dimensions> str = {{2, 4, 8}, {2, 4, 8}};
Strategys str = {{2, 4, 8}, {2, 4, 8}};
StrategyPtr strategy = NewStrategy(0, str);
pow->Init(strategy);
@ -95,7 +95,7 @@ TEST_F(TestPowInfo, InferSliceShape1) {
}
TEST_F(TestPowInfo, GetTensorLayout1) {
std::vector<Dimensions> str = {{2, 4, 8}, {2, 4, 8}};
Strategys str = {{2, 4, 8}, {2, 4, 8}};
StrategyPtr strategy = NewStrategy(0, str);
pow->Init(strategy);
@ -116,7 +116,7 @@ TEST_F(TestPowInfo, GetTensorLayout1) {
}
TEST_F(TestPowInfo, GetForwardOp1) {
std::vector<Dimensions> inputs = {{2, 4, 8}, {2, 4, 8}};
Strategys inputs = {{2, 4, 8}, {2, 4, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
pow->Init(strategy);
@ -127,7 +127,7 @@ TEST_F(TestPowInfo, GetForwardOp1) {
}
TEST_F(TestPowInfo, GetMirrorOPs1) {
std::vector<Dimensions> inputs = {{2, 4, 8}, {2, 4, 8}};
Strategys inputs = {{2, 4, 8}, {2, 4, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
pow->Init(strategy);
@ -139,7 +139,7 @@ TEST_F(TestPowInfo, GetMirrorOPs1) {
}
TEST_F(TestPowInfo, CheckStrategy1) {
std::vector<Dimensions> inputs = {{2, 2, 8}, {2, 4, 8}};
Strategys inputs = {{2, 2, 8}, {2, 4, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = pow->Init(strategy);
@ -147,7 +147,7 @@ TEST_F(TestPowInfo, CheckStrategy1) {
}
TEST_F(TestPowInfo, CheckStrategy2) {
std::vector<Dimensions> inputs = {{2, 4, 8, 16}, {2, 4, 8, 16}};
Strategys inputs = {{2, 4, 8, 16}, {2, 4, 8, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = pow->Init(strategy);
@ -155,7 +155,7 @@ TEST_F(TestPowInfo, CheckStrategy2) {
}
TEST_F(TestPowInfo, CheckStrategy3) {
std::vector<Dimensions> inputs = {{2, 4, 8}, {2, 4, 8}};
Strategys inputs = {{2, 4, 8}, {2, 4, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = pow->Init(strategy);

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

@ -39,13 +39,13 @@ class TestPReLUInfo : public UT::Common {
};
void TestPReLUInfo::SetUp() {
std::vector<int32_t> dev_list;
RankList dev_list;
for (int32_t i = 0; i < 1050; i++) {
dev_list.push_back(i);
}
std::vector<int32_t> stage_map;
RankList stage_map;
stage_map.push_back(1024);
stage_map.push_back(26);
int32_t local_dev = 0;
@ -64,18 +64,18 @@ void TestPReLUInfo::SetUp() {
}
TEST_F(TestPReLUInfo, InferDevMatrixShape1) {
std::vector<Dimensions> inputs = {{2, 1, 8, 16}, {1}};
Strategys inputs = {{2, 1, 8, 16}, {1}};
StrategyPtr strategy = NewStrategy(0, inputs);
prelu->Init(strategy);
std::vector<int32_t> dev_matrix_shape = prelu->dev_matrix_shape();
Shape dev_matrix_shape = prelu->dev_matrix_shape();
std::vector<int32_t> expect = {4, 2, 1, 8, 16};
Shape expect = {4, 2, 1, 8, 16};
ASSERT_EQ(dev_matrix_shape, expect);
}
TEST_F(TestPReLUInfo, InferSliceShape1) {
std::vector<Dimensions> str = {{2, 1, 8, 16}, {1}};
Strategys str = {{2, 1, 8, 16}, {1}};
StrategyPtr strategy = NewStrategy(0, str);
prelu->Init(strategy);
@ -98,7 +98,7 @@ TEST_F(TestPReLUInfo, InferSliceShape1) {
}
TEST_F(TestPReLUInfo, GetTensorLayout1) {
std::vector<Dimensions> str = {{2, 1, 8, 16}, {1}};
Strategys str = {{2, 1, 8, 16}, {1}};
StrategyPtr strategy = NewStrategy(0, str);
prelu->Init(strategy);
@ -122,7 +122,7 @@ TEST_F(TestPReLUInfo, GetTensorLayout1) {
}
TEST_F(TestPReLUInfo, GetMirrorOPs1) {
std::vector<Dimensions> str = {{2, 1, 2, 2}, {1}};
Strategys str = {{2, 1, 2, 2}, {1}};
StrategyPtr strategy = NewStrategy(0, str);
prelu->Init(strategy);
MirrorOps mirror_ops = prelu->mirror_ops();
@ -139,14 +139,14 @@ TEST_F(TestPReLUInfo, GetMirrorOPs1) {
TEST_F(TestPReLUInfo, CheckStrategy1) {
// Success: {{2,1,8,16},{1}}
std::vector<Dimensions> inputs = {{2, 1, 8, 16}};
Strategys inputs = {{2, 1, 8, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = prelu->Init(strategy);
ASSERT_EQ(ret, FAILED);
}
TEST_F(TestPReLUInfo, CheckStrategy2) {
std::vector<Dimensions> inputs = {{2, 4, 8, 16}, {4}};
Strategys inputs = {{2, 4, 8, 16}, {4}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = prelu->Init(strategy);
ASSERT_EQ(ret, SUCCESS);
@ -169,18 +169,18 @@ TEST_F(TestPReLUInfo, AutoStrategy1) {
}
TEST_F(TestPReLUInfo, InferDevMatrixShape_2d1) {
std::vector<Dimensions> inputs = {{128, 1}, {1}};
Strategys inputs = {{128, 1}, {1}};
StrategyPtr strategy = NewStrategy(0, inputs);
prelu_2d->Init(strategy);
std::vector<int32_t> dev_matrix_shape = prelu_2d->dev_matrix_shape();
Shape dev_matrix_shape = prelu_2d->dev_matrix_shape();
std::vector<int32_t> expect = {8, 128, 1};
Shape expect = {8, 128, 1};
ASSERT_EQ(dev_matrix_shape, expect);
}
TEST_F(TestPReLUInfo, InferSliceShape_2d1) {
std::vector<Dimensions> str = {{128, 1}, {1}};
Strategys str = {{128, 1}, {1}};
StrategyPtr strategy = NewStrategy(0, str);
prelu_2d->Init(strategy);
@ -203,7 +203,7 @@ TEST_F(TestPReLUInfo, InferSliceShape_2d1) {
}
TEST_F(TestPReLUInfo, GetTensorLayout_2d1) {
std::vector<Dimensions> str = {{128, 1}, {1}};
Strategys str = {{128, 1}, {1}};
StrategyPtr strategy = NewStrategy(0, str);
prelu_2d->Init(strategy);
@ -227,7 +227,7 @@ TEST_F(TestPReLUInfo, GetTensorLayout_2d1) {
}
TEST_F(TestPReLUInfo, GetMirrorOPs_2d1) {
std::vector<Dimensions> str = {{128, 1}, {1}};
Strategys str = {{128, 1}, {1}};
StrategyPtr strategy = NewStrategy(0, str);
prelu_2d->Init(strategy);
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}}
std::vector<Dimensions> inputs = {{128, 1}};
Strategys inputs = {{128, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = prelu_2d->Init(strategy);
ASSERT_EQ(ret, FAILED);
}
TEST_F(TestPReLUInfo, CheckStrategy_2d2) {
std::vector<Dimensions> inputs = {{128, 4}, {4}};
Strategys inputs = {{128, 4}, {4}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = prelu_2d->Init(strategy);
ASSERT_EQ(ret, SUCCESS);

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

@ -39,13 +39,13 @@ class TestReduceSumInfo : public UT::Common {
void TestReduceSumInfo::SetUp() {
UT::InitPythonPath();
std::vector<int32_t> dev_list;
RankList dev_list;
for (int32_t i = 0; i < 34; i++) {
dev_list.push_back(i);
}
std::vector<int32_t> stage_map;
RankList stage_map;
stage_map.push_back(32);
stage_map.push_back(2);
@ -68,18 +68,18 @@ void TestReduceSumInfo::SetUp() {
}
TEST_F(TestReduceSumInfo, InferDevMatrixShape1) {
std::vector<Dimensions> inputs = {{4, 8, 1}};
Strategys inputs = {{4, 8, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
reduce_sum->Init(strategy);
std::vector<int32_t> dev_matrix_shape = reduce_sum->dev_matrix_shape();
Shape dev_matrix_shape = reduce_sum->dev_matrix_shape();
std::vector<int32_t> expect = {4, 8, 1};
Shape expect = {4, 8, 1};
ASSERT_EQ(dev_matrix_shape, expect);
}
TEST_F(TestReduceSumInfo, InferSliceShape1) {
std::vector<Dimensions> str = {{4, 8, 1}};
Strategys str = {{4, 8, 1}};
StrategyPtr strategy = NewStrategy(0, str);
reduce_sum->Init(strategy);
@ -100,7 +100,7 @@ TEST_F(TestReduceSumInfo, InferSliceShape1) {
}
TEST_F(TestReduceSumInfo, GetTensorLayout1) {
std::vector<Dimensions> str = {{4, 8, 1}};
Strategys str = {{4, 8, 1}};
StrategyPtr strategy = NewStrategy(0, str);
reduce_sum->Init(strategy);
@ -121,7 +121,7 @@ TEST_F(TestReduceSumInfo, GetTensorLayout1) {
}
TEST_F(TestReduceSumInfo, GetForwardOp1) {
std::vector<Dimensions> inputs = {{4, 8, 1}};
Strategys inputs = {{4, 8, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
reduce_sum->Init(strategy);
@ -132,7 +132,7 @@ TEST_F(TestReduceSumInfo, GetForwardOp1) {
}
TEST_F(TestReduceSumInfo, GetForwardOp2) {
std::vector<Dimensions> inputs = {{4, 4, 2}};
Strategys inputs = {{4, 4, 2}};
StrategyPtr strategy = NewStrategy(0, inputs);
reduce_sum->Init(strategy);
@ -156,7 +156,7 @@ TEST_F(TestReduceSumInfo, GetForwardOp2) {
}
TEST_F(TestReduceSumInfo, GetMirrorOPs1) {
std::vector<Dimensions> inputs = {{4, 8, 1}};
Strategys inputs = {{4, 8, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
reduce_sum->Init(strategy);
@ -168,7 +168,7 @@ TEST_F(TestReduceSumInfo, GetMirrorOPs1) {
}
TEST_F(TestReduceSumInfo, GetMirrorOPs2) {
std::vector<Dimensions> inputs = {{4, 4, 1}};
Strategys inputs = {{4, 4, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
reduce_sum->Init(strategy);
@ -187,7 +187,7 @@ TEST_F(TestReduceSumInfo, GetMirrorOPs2) {
}
TEST_F(TestReduceSumInfo, CheckStrategy1) {
std::vector<Dimensions> inputs = {{2, 2, 8, 16}};
Strategys inputs = {{2, 2, 8, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = reduce_sum->Init(strategy);
@ -195,7 +195,7 @@ TEST_F(TestReduceSumInfo, CheckStrategy1) {
}
TEST_F(TestReduceSumInfo, CheckStrategy2) {
std::vector<Dimensions> inputs = {{2, 4, 8}, {2, 4, 8}};
Strategys inputs = {{2, 4, 8}, {2, 4, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = reduce_sum->Init(strategy);
@ -203,7 +203,7 @@ TEST_F(TestReduceSumInfo, CheckStrategy2) {
}
TEST_F(TestReduceSumInfo, CheckStrategy3) {
std::vector<Dimensions> inputs = {{4, 4, 2}};
Strategys inputs = {{4, 4, 2}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = reduce_sum->Init(strategy);
@ -211,7 +211,7 @@ TEST_F(TestReduceSumInfo, CheckStrategy3) {
}
TEST_F(TestReduceSumInfo, CheckStrategy4) {
std::vector<Dimensions> inputs = {{4, 8, 1}};
Strategys inputs = {{4, 8, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = reduce_sum->Init(strategy);

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

@ -38,13 +38,13 @@ class TestReshapeInfo : public UT::Common {
};
void TestReshapeInfo::SetUp() {
std::vector<int32_t> dev_list;
RankList dev_list;
for (int32_t i = 0; i < 34; i++) {
dev_list.push_back(i);
}
std::vector<int32_t> stage_map;
RankList stage_map;
stage_map.push_back(32);
stage_map.push_back(2);
@ -68,29 +68,29 @@ void TestReshapeInfo::SetUp() {
}
TEST_F(TestReshapeInfo, InferDevMatrixShape1) {
std::vector<Dimensions> inputs = {{4, 1, 1, 1}};
Strategys inputs = {{4, 1, 1, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
reshape->Init(strategy);
std::vector<int32_t> dev_matrix_shape = reshape->dev_matrix_shape();
Shape dev_matrix_shape = reshape->dev_matrix_shape();
std::vector<int32_t> expect = {8, 4};
Shape expect = {8, 4};
ASSERT_EQ(dev_matrix_shape, expect);
}
TEST_F(TestReshapeInfo, InferDevMatrixShape2) {
std::vector<Dimensions> inputs = {{32, 1, 1, 1}};
Strategys inputs = {{32, 1, 1, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
reshape->Init(strategy);
std::vector<int32_t> dev_matrix_shape = reshape->dev_matrix_shape();
Shape dev_matrix_shape = reshape->dev_matrix_shape();
std::vector<int32_t> expect = {32};
Shape expect = {32};
ASSERT_EQ(dev_matrix_shape, expect);
}
TEST_F(TestReshapeInfo, InferSliceShape1) {
std::vector<Dimensions> str = {{4, 1, 1, 1}};
Strategys str = {{4, 1, 1, 1}};
StrategyPtr strategy = NewStrategy(0, str);
reshape->Init(strategy);
@ -111,7 +111,7 @@ TEST_F(TestReshapeInfo, InferSliceShape1) {
}
TEST_F(TestReshapeInfo, InferSliceShape2) {
std::vector<Dimensions> str = {{32, 1, 1, 1}};
Strategys str = {{32, 1, 1, 1}};
StrategyPtr strategy = NewStrategy(0, str);
reshape->Init(strategy);
@ -132,7 +132,7 @@ TEST_F(TestReshapeInfo, InferSliceShape2) {
}
TEST_F(TestReshapeInfo, GetTensorLayout1) {
std::vector<Dimensions> str = {{4, 1, 1, 1}};
Strategys str = {{4, 1, 1, 1}};
StrategyPtr strategy = NewStrategy(0, str);
reshape->Init(strategy);
@ -153,7 +153,7 @@ TEST_F(TestReshapeInfo, GetTensorLayout1) {
}
TEST_F(TestReshapeInfo, GetTensorLayout2) {
std::vector<Dimensions> str = {{32, 1, 1, 1}};
Strategys str = {{32, 1, 1, 1}};
StrategyPtr strategy = NewStrategy(0, str);
reshape->Init(strategy);
@ -174,7 +174,7 @@ TEST_F(TestReshapeInfo, GetTensorLayout2) {
}
TEST_F(TestReshapeInfo, GetForwardOp1) {
std::vector<Dimensions> inputs = {{4, 1, 1, 1}};
Strategys inputs = {{4, 1, 1, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
reshape->Init(strategy);
@ -185,7 +185,7 @@ TEST_F(TestReshapeInfo, GetForwardOp1) {
}
TEST_F(TestReshapeInfo, GetMirrorOPs1) {
std::vector<Dimensions> inputs = {{4, 1, 1, 1}};
Strategys inputs = {{4, 1, 1, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
reshape->Init(strategy);
@ -197,7 +197,7 @@ TEST_F(TestReshapeInfo, GetMirrorOPs1) {
}
TEST_F(TestReshapeInfo, CheckStrategy1) {
std::vector<Dimensions> inputs = {{1, 4, 8}};
Strategys inputs = {{1, 4, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = reshape->Init(strategy);
@ -205,7 +205,7 @@ TEST_F(TestReshapeInfo, CheckStrategy1) {
}
TEST_F(TestReshapeInfo, CheckStrategy2) {
std::vector<Dimensions> inputs = {{2, 4, 8}, {2, 4, 8}};
Strategys inputs = {{2, 4, 8}, {2, 4, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = reshape->Init(strategy);
@ -213,7 +213,7 @@ TEST_F(TestReshapeInfo, CheckStrategy2) {
}
TEST_F(TestReshapeInfo, CheckStrategy3) {
std::vector<Dimensions> inputs = {{4, 1, 1, 1}};
Strategys inputs = {{4, 1, 1, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = reshape->Init(strategy);

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

@ -38,13 +38,13 @@ class TestSoftmaxLoss : public UT::Common {
};
void TestSoftmaxLoss::SetUp() {
std::vector<int32_t> dev_list;
RankList dev_list;
for (int32_t i = 0; i < 65; i++) {
dev_list.push_back(i);
}
std::vector<int32_t> stage_map;
RankList stage_map;
stage_map.push_back(64);
stage_map.push_back(1);
@ -64,18 +64,18 @@ void TestSoftmaxLoss::SetUp() {
}
TEST_F(TestSoftmaxLoss, InferDevMatrixShape1) {
std::vector<Dimensions> inputs = {{2, 4, 8, 1}, {2, 4, 8, 1}};
Strategys inputs = {{2, 4, 8, 1}, {2, 4, 8, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
loss->Init(strategy);
std::vector<int32_t> dev_matrix_shape = loss->dev_matrix_shape();
Shape dev_matrix_shape = loss->dev_matrix_shape();
std::vector<int32_t> expect = {2, 4, 8, 1};
Shape expect = {2, 4, 8, 1};
ASSERT_EQ(dev_matrix_shape, expect);
}
TEST_F(TestSoftmaxLoss, InferSliceShape1) {
std::vector<Dimensions> str = {{2, 4, 8, 1}, {2, 4, 8, 1}};
Strategys str = {{2, 4, 8, 1}, {2, 4, 8, 1}};
StrategyPtr strategy = NewStrategy(0, str);
loss->Init(strategy);
@ -104,7 +104,7 @@ TEST_F(TestSoftmaxLoss, InferSliceShape1) {
}
TEST_F(TestSoftmaxLoss, GetTensorLayout1) {
std::vector<Dimensions> str = {{2, 4, 8, 1}, {2, 4, 8, 1}};
Strategys str = {{2, 4, 8, 1}, {2, 4, 8, 1}};
StrategyPtr strategy = NewStrategy(0, str);
loss->Init(strategy);
@ -133,7 +133,7 @@ TEST_F(TestSoftmaxLoss, GetTensorLayout1) {
}
TEST_F(TestSoftmaxLoss, GetForwardOp1) {
std::vector<Dimensions> inputs = {{2, 4, 8, 1}, {2, 4, 8, 1}};
Strategys inputs = {{2, 4, 8, 1}, {2, 4, 8, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
loss->Init(strategy);
@ -144,7 +144,7 @@ TEST_F(TestSoftmaxLoss, GetForwardOp1) {
}
TEST_F(TestSoftmaxLoss, GetMirrorOPs1) {
std::vector<Dimensions> inputs = {{2, 4, 8, 1}, {2, 4, 8, 1}};
Strategys inputs = {{2, 4, 8, 1}, {2, 4, 8, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
loss->Init(strategy);
@ -156,7 +156,7 @@ TEST_F(TestSoftmaxLoss, GetMirrorOPs1) {
}
TEST_F(TestSoftmaxLoss, GetVirtualDivOPs1) {
std::vector<Dimensions> inputs = {{1, 4, 8, 1}, {1, 4, 8, 1}};
Strategys inputs = {{1, 4, 8, 1}, {1, 4, 8, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
loss->Init(strategy);
@ -176,7 +176,7 @@ TEST_F(TestSoftmaxLoss, GetVirtualDivOPs1) {
TEST_F(TestSoftmaxLoss, CheckStrategy1) {
// Success: {{2,4,8,16}}
std::vector<Dimensions> inputs = {{2, 2, 8, 16}, {2, 4, 16, 1}};
Strategys inputs = {{2, 2, 8, 16}, {2, 4, 16, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = loss->Init(strategy);
@ -185,7 +185,7 @@ TEST_F(TestSoftmaxLoss, CheckStrategy1) {
TEST_F(TestSoftmaxLoss, CheckStrategy2) {
// Success: {{2,4,8,16}}
std::vector<Dimensions> inputs = {{2, 4, 8}};
Strategys inputs = {{2, 4, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = loss->Init(strategy);

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

@ -39,13 +39,13 @@ class TestSoftmaxInfo : public UT::Common {
};
void TestSoftmaxInfo::SetUp() {
std::vector<int32_t> dev_list;
RankList dev_list;
for (int32_t i = 0; i < 130; i++) {
dev_list.push_back(i);
}
std::vector<int32_t> stage_map;
RankList stage_map;
stage_map.push_back(128);
stage_map.push_back(2);
@ -68,18 +68,18 @@ void TestSoftmaxInfo::SetUp() {
}
TEST_F(TestSoftmaxInfo, InferDevMatrixShape1) {
std::vector<Dimensions> inputs = {{2, 4, 1, 16}};
Strategys inputs = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
softmax->Init(strategy);
std::vector<int32_t> dev_matrix_shape = softmax->dev_matrix_shape();
Shape dev_matrix_shape = softmax->dev_matrix_shape();
std::vector<int32_t> expect = {2, 4, 1, 16};
Shape expect = {2, 4, 1, 16};
ASSERT_EQ(dev_matrix_shape, expect);
}
TEST_F(TestSoftmaxInfo, InferSliceShape1) {
std::vector<Dimensions> str = {{2, 4, 1, 16}};
Strategys str = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, str);
softmax->Init(strategy);
@ -100,7 +100,7 @@ TEST_F(TestSoftmaxInfo, InferSliceShape1) {
}
TEST_F(TestSoftmaxInfo, GetTensorLayout1) {
std::vector<Dimensions> str = {{2, 4, 1, 16}};
Strategys str = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, str);
softmax->Init(strategy);
@ -121,7 +121,7 @@ TEST_F(TestSoftmaxInfo, GetTensorLayout1) {
}
TEST_F(TestSoftmaxInfo, GetForwardOp1) {
std::vector<Dimensions> inputs = {{2, 4, 1, 16}};
Strategys inputs = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
softmax->Init(strategy);
@ -132,7 +132,7 @@ TEST_F(TestSoftmaxInfo, GetForwardOp1) {
}
TEST_F(TestSoftmaxInfo, GetMirrorOPs1) {
std::vector<Dimensions> inputs = {{2, 4, 1, 16}};
Strategys inputs = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
softmax->Init(strategy);
@ -145,7 +145,7 @@ TEST_F(TestSoftmaxInfo, GetMirrorOPs1) {
TEST_F(TestSoftmaxInfo, CheckStrategy1) {
// Success: {{2,4,1,16}}
std::vector<Dimensions> inputs = {{2, 2, 8, 16}, {2, 4, 16, 1}};
Strategys inputs = {{2, 2, 8, 16}, {2, 4, 16, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = softmax->Init(strategy);
@ -154,7 +154,7 @@ TEST_F(TestSoftmaxInfo, CheckStrategy1) {
TEST_F(TestSoftmaxInfo, CheckStrategy2) {
// Success: {{2,4,1,16}}
std::vector<Dimensions> inputs = {{2, 4, 8}};
Strategys inputs = {{2, 4, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = softmax->Init(strategy);
@ -163,7 +163,7 @@ TEST_F(TestSoftmaxInfo, CheckStrategy2) {
TEST_F(TestSoftmaxInfo, CheckStrategy3) {
// Success: {{2,4,1,16}}
std::vector<Dimensions> inputs = {{2, 4, 8, 16}};
Strategys inputs = {{2, 4, 8, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = softmax->Init(strategy);
@ -172,7 +172,7 @@ TEST_F(TestSoftmaxInfo, CheckStrategy3) {
TEST_F(TestSoftmaxInfo, InitFailed1) {
// softmax2's axis is wrong
std::vector<Dimensions> inputs = {{2, 4, 1, 16}};
Strategys inputs = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = softmax2->Init(strategy);
@ -181,7 +181,7 @@ TEST_F(TestSoftmaxInfo, InitFailed1) {
TEST_F(TestSoftmaxInfo, InitFailed2) {
// dev num is wrong
std::vector<Dimensions> inputs = {{2, 4, 1, 100}};
Strategys inputs = {{2, 4, 1, 100}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = softmax2->Init(strategy);

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

@ -38,13 +38,13 @@ class TestTanhInfo : public UT::Common {
};
void TestTanhInfo::SetUp() {
std::vector<int32_t> dev_list;
RankList dev_list;
for (int32_t i = 0; i < 130; i++) {
dev_list.push_back(i);
}
std::vector<int32_t> stage_map;
RankList stage_map;
stage_map.push_back(128);
stage_map.push_back(2);
@ -63,18 +63,18 @@ void TestTanhInfo::SetUp() {
}
TEST_F(TestTanhInfo, InferDevMatrixShape1) {
std::vector<Dimensions> inputs = {{2, 4, 1, 16}};
Strategys inputs = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
tanh->Init(strategy);
std::vector<int32_t> dev_matrix_shape = tanh->dev_matrix_shape();
Shape dev_matrix_shape = tanh->dev_matrix_shape();
std::vector<int32_t> expect = {2, 4, 1, 16};
Shape expect = {2, 4, 1, 16};
ASSERT_EQ(dev_matrix_shape, expect);
}
TEST_F(TestTanhInfo, InferSliceShape1) {
std::vector<Dimensions> str = {{2, 4, 1, 16}};
Strategys str = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, str);
tanh->Init(strategy);
@ -95,7 +95,7 @@ TEST_F(TestTanhInfo, InferSliceShape1) {
}
TEST_F(TestTanhInfo, GetTensorLayout1) {
std::vector<Dimensions> str = {{2, 4, 1, 16}};
Strategys str = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, str);
tanh->Init(strategy);
@ -116,7 +116,7 @@ TEST_F(TestTanhInfo, GetTensorLayout1) {
}
TEST_F(TestTanhInfo, GetForwardOp1) {
std::vector<Dimensions> inputs = {{2, 4, 1, 16}};
Strategys inputs = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
tanh->Init(strategy);
@ -127,7 +127,7 @@ TEST_F(TestTanhInfo, GetForwardOp1) {
}
TEST_F(TestTanhInfo, GetMirrorOPs1) {
std::vector<Dimensions> inputs = {{2, 4, 1, 16}};
Strategys inputs = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
tanh->Init(strategy);
@ -140,7 +140,7 @@ TEST_F(TestTanhInfo, GetMirrorOPs1) {
TEST_F(TestTanhInfo, CheckStrategy1) {
// Success: {{2,4,1,16}}
std::vector<Dimensions> inputs = {{2, 2, 8, 16}, {2, 4, 16, 1}};
Strategys inputs = {{2, 2, 8, 16}, {2, 4, 16, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = tanh->Init(strategy);
@ -149,7 +149,7 @@ TEST_F(TestTanhInfo, CheckStrategy1) {
TEST_F(TestTanhInfo, CheckStrategy2) {
// Success: {{2,4,1,16}}
std::vector<Dimensions> inputs = {{2, 4, 8}};
Strategys inputs = {{2, 4, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = tanh->Init(strategy);
@ -158,7 +158,7 @@ TEST_F(TestTanhInfo, CheckStrategy2) {
TEST_F(TestTanhInfo, CheckStrategy3) {
// Success: {{2,4,1,16}}
std::vector<Dimensions> inputs = {{2, 4, 1, 16}};
Strategys inputs = {{2, 4, 1, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = tanh->Init(strategy);

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

@ -38,13 +38,13 @@ class TestTensorAddInfo : public UT::Common {
};
void TestTensorAddInfo::SetUp() {
std::vector<int32_t> dev_list;
RankList dev_list;
for (int32_t i = 0; i < 34; i++) {
dev_list.push_back(i);
}
std::vector<int32_t> stage_map;
RankList stage_map;
stage_map.push_back(32);
stage_map.push_back(2);
@ -66,18 +66,18 @@ void TestTensorAddInfo::SetUp() {
}
TEST_F(TestTensorAddInfo, InferDevMatrixShape1) {
std::vector<Dimensions> inputs = {{2, 4, 4}, {2, 4, 4}};
Strategys inputs = {{2, 4, 4}, {2, 4, 4}};
StrategyPtr strategy = NewStrategy(0, inputs);
tensor_add->Init(strategy);
std::vector<int32_t> dev_matrix_shape = tensor_add->dev_matrix_shape();
Shape dev_matrix_shape = tensor_add->dev_matrix_shape();
std::vector<int32_t> expect = {2, 4, 4};
Shape expect = {2, 4, 4};
ASSERT_EQ(dev_matrix_shape, expect);
}
TEST_F(TestTensorAddInfo, InferSliceShape1) {
std::vector<Dimensions> str = {{2, 4, 4}, {2, 4, 4}};
Strategys str = {{2, 4, 4}, {2, 4, 4}};
StrategyPtr strategy = NewStrategy(0, str);
tensor_add->Init(strategy);
@ -101,7 +101,7 @@ TEST_F(TestTensorAddInfo, InferSliceShape1) {
}
TEST_F(TestTensorAddInfo, GetTensorLayout1) {
std::vector<Dimensions> str = {{2, 4, 4}, {2, 4, 4}};
Strategys str = {{2, 4, 4}, {2, 4, 4}};
StrategyPtr strategy = NewStrategy(0, str);
tensor_add->Init(strategy);
@ -125,7 +125,7 @@ TEST_F(TestTensorAddInfo, GetTensorLayout1) {
}
TEST_F(TestTensorAddInfo, GetForwardOp1) {
std::vector<Dimensions> inputs = {{2, 4, 4}, {2, 4, 4}};
Strategys inputs = {{2, 4, 4}, {2, 4, 4}};
StrategyPtr strategy = NewStrategy(0, inputs);
tensor_add->Init(strategy);
@ -136,7 +136,7 @@ TEST_F(TestTensorAddInfo, GetForwardOp1) {
}
TEST_F(TestTensorAddInfo, GetMirrorOPs1) {
std::vector<Dimensions> inputs = {{2, 4, 4}, {2, 4, 4}};
Strategys inputs = {{2, 4, 4}, {2, 4, 4}};
StrategyPtr strategy = NewStrategy(0, inputs);
tensor_add->Init(strategy);
@ -148,7 +148,7 @@ TEST_F(TestTensorAddInfo, GetMirrorOPs1) {
}
TEST_F(TestTensorAddInfo, CheckStrategy1) {
std::vector<Dimensions> inputs = {{2, 4, 4}, {2, 6, 4}};
Strategys inputs = {{2, 4, 4}, {2, 6, 4}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = tensor_add->Init(strategy);
@ -156,7 +156,7 @@ TEST_F(TestTensorAddInfo, CheckStrategy1) {
}
TEST_F(TestTensorAddInfo, CheckStrategy2) {
std::vector<Dimensions> inputs = {{2, 4, 8}, {2, 4, 8}};
Strategys inputs = {{2, 4, 8}, {2, 4, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = tensor_add->Init(strategy);
@ -164,7 +164,7 @@ TEST_F(TestTensorAddInfo, CheckStrategy2) {
}
TEST_F(TestTensorAddInfo, CheckStrategy3) {
std::vector<Dimensions> inputs = {{2, 4, 6}};
Strategys inputs = {{2, 4, 6}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = tensor_add->Init(strategy);
@ -172,7 +172,7 @@ TEST_F(TestTensorAddInfo, CheckStrategy3) {
}
TEST_F(TestTensorAddInfo, CheckStrategy4) {
std::vector<Dimensions> inputs = {{2, 4, 4}, {2, 4, 4}};
Strategys inputs = {{2, 4, 4}, {2, 4, 4}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = tensor_add->Init(strategy);
@ -224,7 +224,7 @@ TEST_F(TestTensorAddInfo, GenerateStrategies1) {
}
TEST_F(TestTensorAddInfo, mirror_ops) {
std::vector<Dimensions> inputs = {{1, 8}, {4, 1}};
Strategys inputs = {{1, 8}, {4, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
tensor_add1->Init(strategy);

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

@ -19,6 +19,7 @@
#include "frontend/parallel/device_manager.h"
#include "frontend/parallel/ops_info/operator_info.h"
#include "frontend/parallel/ops_info/tmp_identity_info.h"
#include "frontend/parallel/step_parallel.h"
namespace mindspore {
namespace parallel {
@ -26,7 +27,6 @@ namespace parallel {
class TmpIdentityInfo;
using TmpIdentityInfoPtr = std::shared_ptr<TmpIdentityInfo>;
TmpIdentityInfoPtr identity_ptr;
using TensorMap = std::vector<int32_t>;
class TestTmpIdentityInfo : public UT::Common {
public:
@ -38,13 +38,13 @@ class TestTmpIdentityInfo : public UT::Common {
};
void TestTmpIdentityInfo::SetUp() {
std::vector<int32_t> dev_list;
RankList dev_list;
for (int32_t i = 0; i < 1050; i++) {
dev_list.push_back(i);
}
std::vector<int32_t> stage_map;
RankList stage_map;
stage_map.push_back(1024);
stage_map.push_back(26);
@ -65,18 +65,18 @@ void TestTmpIdentityInfo::SetUp() {
}
TEST_F(TestTmpIdentityInfo, InferDevMatrixShape1) {
std::vector<Dimensions> inputs = {{2, 4, 8, 16}};
Strategys inputs = {{2, 4, 8, 16}};
StrategyPtr strategy = NewStrategy(0, inputs);
identity_ptr->Init(strategy);
std::vector<int32_t> dev_matrix_shape = identity_ptr->dev_matrix_shape();
Shape dev_matrix_shape = identity_ptr->dev_matrix_shape();
std::vector<int32_t> expect = {2, 4, 8, 16};
Shape expect = {2, 4, 8, 16};
ASSERT_EQ(dev_matrix_shape, expect);
}
TEST_F(TestTmpIdentityInfo, InferSliceShape1) {
std::vector<Dimensions> str = {{2, 4, 8, 16}};
Strategys str = {{2, 4, 8, 16}};
StrategyPtr strategy = NewStrategy(0, str);
identity_ptr->Init(strategy);
@ -97,7 +97,7 @@ TEST_F(TestTmpIdentityInfo, InferSliceShape1) {
}
TEST_F(TestTmpIdentityInfo, GetTensorLayout1) {
std::vector<Dimensions> str = {{2, 4, 8, 16}};
Strategys str = {{2, 4, 8, 16}};
StrategyPtr strategy = NewStrategy(0, str);
identity_ptr->Init(strategy);
@ -119,7 +119,7 @@ TEST_F(TestTmpIdentityInfo, GetTensorLayout1) {
TEST_F(TestTmpIdentityInfo, CheckStrategy1) {
// Success: {{2,4,8,16}}
std::vector<Dimensions> inputs = {{2, 2, 8, 16}, {2, 4, 16, 1}};
Strategys inputs = {{2, 2, 8, 16}, {2, 4, 16, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = identity_ptr->Init(strategy);
@ -128,7 +128,7 @@ TEST_F(TestTmpIdentityInfo, CheckStrategy1) {
TEST_F(TestTmpIdentityInfo, CheckStrategy2) {
// Success: {{2,4,8,16}}
std::vector<Dimensions> inputs = {{2, 4, 8}};
Strategys inputs = {{2, 4, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = identity_ptr->Init(strategy);

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

@ -38,13 +38,13 @@ class TestTransposeInfo : public UT::Common {
};
void TestTransposeInfo::SetUp() {
std::vector<int32_t> dev_list;
RankList dev_list;
for (int32_t i = 0; i < 34; i++) {
dev_list.push_back(i);
}
std::vector<int32_t> stage_map;
RankList stage_map;
stage_map.push_back(32);
stage_map.push_back(2);
@ -68,29 +68,29 @@ void TestTransposeInfo::SetUp() {
}
TEST_F(TestTransposeInfo, InferDevMatrixShape1) {
std::vector<Dimensions> inputs = {{4, 8}};
Strategys inputs = {{4, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
transpose->Init(strategy);
std::vector<int32_t> dev_matrix_shape = transpose->dev_matrix_shape();
Shape dev_matrix_shape = transpose->dev_matrix_shape();
std::vector<int32_t> expect = {4, 8};
Shape expect = {4, 8};
ASSERT_EQ(dev_matrix_shape, expect);
}
TEST_F(TestTransposeInfo, InferDevMatrixShape2) {
std::vector<Dimensions> inputs = {{4, 1}};
Strategys inputs = {{4, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
transpose->Init(strategy);
std::vector<int32_t> dev_matrix_shape = transpose->dev_matrix_shape();
Shape dev_matrix_shape = transpose->dev_matrix_shape();
std::vector<int32_t> expect = {8, 4, 1};
Shape expect = {8, 4, 1};
ASSERT_EQ(dev_matrix_shape, expect);
}
TEST_F(TestTransposeInfo, InferSliceShape1) {
std::vector<Dimensions> str = {{4, 8}};
Strategys str = {{4, 8}};
StrategyPtr strategy = NewStrategy(0, str);
transpose->Init(strategy);
@ -111,7 +111,7 @@ TEST_F(TestTransposeInfo, InferSliceShape1) {
}
TEST_F(TestTransposeInfo, GetTensorLayout1) {
std::vector<Dimensions> str = {{4, 8}};
Strategys str = {{4, 8}};
StrategyPtr strategy = NewStrategy(0, str);
transpose->Init(strategy);
@ -132,7 +132,7 @@ TEST_F(TestTransposeInfo, GetTensorLayout1) {
}
TEST_F(TestTransposeInfo, GetForwardOp1) {
std::vector<Dimensions> inputs = {{4, 8}};
Strategys inputs = {{4, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
transpose->Init(strategy);
@ -143,7 +143,7 @@ TEST_F(TestTransposeInfo, GetForwardOp1) {
}
TEST_F(TestTransposeInfo, GetMirrorOPs1) {
std::vector<Dimensions> inputs = {{4, 8}};
Strategys inputs = {{4, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
transpose->Init(strategy);
@ -155,7 +155,7 @@ TEST_F(TestTransposeInfo, GetMirrorOPs1) {
}
TEST_F(TestTransposeInfo, CheckStrategy1) {
std::vector<Dimensions> inputs = {{1, 4, 8}};
Strategys inputs = {{1, 4, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = transpose->Init(strategy);
@ -163,7 +163,7 @@ TEST_F(TestTransposeInfo, CheckStrategy1) {
}
TEST_F(TestTransposeInfo, CheckStrategy2) {
std::vector<Dimensions> inputs = {{2, 4, 8}, {2, 4, 8}};
Strategys inputs = {{2, 4, 8}, {2, 4, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = transpose->Init(strategy);
@ -171,7 +171,7 @@ TEST_F(TestTransposeInfo, CheckStrategy2) {
}
TEST_F(TestTransposeInfo, CheckStrategy3) {
std::vector<Dimensions> inputs = {{4, 8}};
Strategys inputs = {{4, 8}};
StrategyPtr strategy = NewStrategy(0, inputs);
Status ret = transpose->Init(strategy);

4
tests/ut/cpp/parallel/step_auto_parallel_test.cc
View File

@ -32,13 +32,13 @@ class TestStepAutoParallel : public UT::Common {
};
void TestStepAutoParallel::SetUp() {
std::vector<int32_t> dev_list;
RankList dev_list;
for (int32_t i = 0; i < 20; i++) {
dev_list.push_back(i);
}
std::vector<int32_t> stage_map;
RankList stage_map;
stage_map.push_back(16);
stage_map.push_back(4);

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

@ -34,13 +34,13 @@ class TestStepParallel : public UT::Common {
void TestStepParallel::SetUp() { UT::InitPythonPath(); }
void Init_Device_Manager() {
std::vector<int32_t> dev_list;
RankList dev_list;
for (int32_t i = 0; i < 20; i++) {
dev_list.push_back(i);
}
std::vector<int32_t> stage_map;
RankList stage_map;
stage_map.push_back(16);
stage_map.push_back(4);
@ -112,11 +112,11 @@ CNodePtr Make_Node(Shape x, Shape y, Shape out, int condition = 0) {
}
FuncGraphManagerPtr Make_Manager(int condition = 0) {
Shape inputs_x = {64, 32};
Shape inputs_y = {32, 64};
Shape inputs_z = {64, 128};
Shape outputs_1 = {64, 64};
Shape outputs_2 = {64, 128};
std::vector<int32_t> inputs_x = {64, 32};
std::vector<int32_t> inputs_y = {32, 64};
std::vector<int32_t> inputs_z = {64, 128};
std::vector<int32_t> outputs_1 = {64, 64};
std::vector<int32_t> outputs_2 = {64, 128};
FuncGraphPtr func_graph = std::make_shared<FuncGraph>();
ParameterPtr param1 = func_graph->add_parameter();
ParameterPtr param2 = func_graph->add_parameter();
@ -134,8 +134,8 @@ FuncGraphManagerPtr Make_Manager(int condition = 0) {
param1->set_abstract(abstract_x);
param2->set_abstract(abstract_y);
param3->set_abstract(abstract_z);
std::vector<int> v1 = {2, 2};
std::vector<int> v2 = {2, 4};
Dimensions v1 = {2, 2};
Dimensions v2 = {2, 4};
std::vector<ValuePtr> elements = {MakeValue(v1), MakeValue(v2)};
ValueTuplePtr var = std::make_shared<ValueTuple>(elements);
std::vector<AnfNodePtr> inputs;
@ -153,8 +153,8 @@ FuncGraphManagerPtr Make_Manager(int condition = 0) {
prim1->AddAttr("instance_name", MakeValue("matmul1"));
prim1->AddAttr("strategy", var);
inputs.clear();
std::vector<int> v3 = {2, 2};
std::vector<int> v4 = {2, 4};
Dimensions v3 = {2, 2};
Dimensions v4 = {2, 4};
std::vector<ValuePtr> elements2 = {MakeValue(v3), MakeValue(v4)};
ValueTuplePtr var2 = std::make_shared<ValueTuple>(elements2);
inputs.push_back(NewValueNode(prim::kPrimMatMul));
@ -186,8 +186,8 @@ FuncGraphManagerPtr Make_Manager(int condition = 0) {
break;
}
case 3: {
std::vector<int> vt1 = {2, 4};
std::vector<int> vt2 = {2, 4};
Dimensions vt1 = {2, 4};
Dimensions vt2 = {2, 4};
std::vector<ValuePtr> elements_t2 = {MakeValue(vt1), MakeValue(vt2)};
ValueTuplePtr var_t2 = std::make_shared<ValueTuple>(elements_t2);
prim1->set_attr("strategy", var_t2);
@ -224,9 +224,9 @@ TEST_F(TestStepParallel, ExtractStrategy) {
std::vector<ValuePtr> elements = {val1, val2};
ValueTuplePtr strategy_tuple = std::make_shared<ValueTuple>(elements);
attrs["strategy"] = strategy_tuple;
std::vector<Dimensions> strategy_expect = {v1, v2};
Strategys strategy_expect = {v1, v2};
StrategyPtr strategy = ExtractStrategy(attrs);
std::vector<Dimensions> strategy_test = strategy->GetInputDim();
Strategys strategy_test = strategy->GetInputDim();
ASSERT_EQ(strategy_expect, strategy_test);
}
@ -353,7 +353,7 @@ TEST_F(TestStepParallel, OperatorInstance) {
prim->set_attr("transpose_b", transpose_b);
auto attrs = prim->attrs();
// creat strategy
std::vector<Dimensions> strategy = {{2, 2}, {2, 4}};
Strategys strategy = {{2, 2}, {2, 4}};
StrategyPtr strategyPtr = parallel::NewStrategy(0, strategy);
// creat shape
Shapes inputs_shape = std::vector<Shape>{{64, 32}, {32, 64}};
@ -514,7 +514,7 @@ TEST_F(TestStepParallel, GetTensorInLayout) {
prim->set_attr("transpose_b", transpose_b);
auto attrs = prim->attrs();
// creat strategy
std::vector<Dimensions> strategy = {{2, 2}, {2, 4}};
Strategys strategy = {{2, 2}, {2, 4}};
StrategyPtr strategyPtr = parallel::NewStrategy(0, strategy);
// creat shape
Shapes inputs_shape = std::vector<Shape>{{64, 32}, {32, 64}};
@ -525,9 +525,9 @@ TEST_F(TestStepParallel, GetTensorInLayout) {
node->set_user_data<OperatorInfo>(matmul_info);
OperatorInfoPtr distribute_operator_pre = node->user_data<OperatorInfo>();
TensorLayout tensorlayout_e;
std::vector<int32_t> array = {64, 64};
Shape array = {64, 64};
TensorLayout tensorlayout = GetTensorInLayout(node1, prim, distribute_operator_pre);
std::vector<int32_t> tensor_shape_test = tensorlayout.tensor_shape().array();
Shape tensor_shape_test = tensorlayout.tensor_shape().array();
ASSERT_EQ(array, tensor_shape_test);
}

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

@ -33,9 +33,9 @@ class TestStrategy : public UT::Common {
TEST_F(TestStrategy, GetInputNumber) {
int32_t number = 2;
int32_t stage = 1;
std::vector<int32_t> dimension1 = {2, 4};
std::vector<int32_t> dimension2 = {2, 2};
std::vector<std::vector<int32_t>> inputs = {dimension1, dimension2};
Dimensions dimension1 = {2, 4};
Dimensions dimension2 = {2, 2};
Strategys inputs = {dimension1, dimension2};
Strategy strategy(stage, inputs);
int32_t number_test = strategy.GetInputNumber();
@ -44,9 +44,9 @@ TEST_F(TestStrategy, GetInputNumber) {
TEST_F(TestStrategy, GetInputStage) {
int32_t stage = 1;
std::vector<int32_t> dimension1 = {2, 4};
std::vector<int32_t> dimension2 = {2, 2};
std::vector<std::vector<int32_t>> inputs = {dimension1, dimension2};
Dimensions dimension1 = {2, 4};
Dimensions dimension2 = {2, 2};
Strategys inputs = {dimension1, dimension2};
Strategy strategy(stage, inputs);
int32_t stage_test = strategy.GetInputStage();
@ -55,23 +55,23 @@ TEST_F(TestStrategy, GetInputStage) {
TEST_F(TestStrategy, GetInputDim) {
int32_t stage = 1;
std::vector<int32_t> dimension1 = {2, 4};
std::vector<int32_t> dimension2 = {2, 2};
std::vector<std::vector<int32_t>> inputs = {dimension1, dimension2};
Dimensions dimension1 = {2, 4};
Dimensions dimension2 = {2, 2};
Strategys inputs = {dimension1, dimension2};
Strategy strategy(stage, inputs);
std::vector<std::vector<int32_t>> inputs_test = strategy.GetInputDim();
Strategys inputs_test = strategy.GetInputDim();
ASSERT_EQ(inputs, inputs_test);
}
TEST_F(TestStrategy, IsEqual) {
int32_t stage1 = 0, stage2 = 0, stage3 = 1, stage4 = 0;
std::vector<int32_t> dimension1 = {8, 1};
std::vector<int32_t> dimension2 = {1, 8};
std::vector<std::vector<int32_t>> inputs1 = {dimension1};
std::vector<std::vector<int32_t>> inputs2 = {dimension1};
std::vector<std::vector<int32_t>> inputs3 = {dimension2};
std::vector<std::vector<int32_t>> inputs4 = {dimension1, dimension2};
Dimensions dimension1 = {8, 1};
Dimensions dimension2 = {1, 8};
Strategys inputs1 = {dimension1};
Strategys inputs2 = {dimension1};
Strategys inputs3 = {dimension2};
Strategys inputs4 = {dimension1, dimension2};
StrategyPtr stra1 = std::make_shared<Strategy>(stage1, inputs1);
StrategyPtr stra2 = std::make_shared<Strategy>(stage2, inputs2);

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

@ -39,12 +39,12 @@ class TestConstructOperator : public UT::Common {
};
void TestConstructOperator::SetUp() {
std::vector<int32_t> dev_list;
RankList dev_list;
for (int32_t i = 0; i < 1050; i++) {
dev_list.push_back(i);
}
std::vector<int32_t> stage_map;
RankList stage_map;
stage_map.push_back(1024);
stage_map.push_back(26);
@ -62,7 +62,7 @@ void TestConstructOperator::SetUp() {
MatMulInfoPtr matmul = std::make_shared<MatMulInfo>("matmul_info", inputs_shape_1, outputs_shape_1, attr_1);
std::vector<Dimensions> str = {{2, 4, 8, 16}, {2, 4, 16, 1}};
Strategys str = {{2, 4, 8, 16}, {2, 4, 16, 1}};
StrategyPtr strategy = NewStrategy(0, str);
matmul->Init(strategy);
Shape tensor_shape = {512, 1024};
@ -79,8 +79,8 @@ TEST_F(TestConstructOperator, TestReshapeOP) {
TEST_F(TestConstructOperator, TestStridedSliceOP) {
Args args = {1, 2, 3};
int32_t split_count = args[0];
int32_t split_dim = args[1];
int64_t split_count = args[0];
int64_t split_dim = args[1];
Shape device_arrangement = {8, 4};
Arrangement dev_mat;
dev_mat.Init(device_arrangement);
@ -98,12 +98,12 @@ TEST_F(TestConstructOperator, TestStridedSliceOP) {
OperatorParams params = op.second.second;
ValuePtr begin_ptr = params[0].first.second;
ValuePtr end_ptr = params[1].first.second;
Shape begin = GetValue<const std::vector<int>>(begin_ptr);
Shape end = GetValue<const std::vector<int>>(end_ptr);
Shape begin = GetValue<const std::vector<int64_t>>(begin_ptr);
Shape end = GetValue<const std::vector<int64_t>>(end_ptr);
for (size_t i = 0; i < begin.size(); i++) {
int32_t diff = end[i] - begin[i];
int32_t num = shape[i];
if (SizeToInt(i) != split_dim) {
int64_t diff = end[i] - begin[i];
int64_t num = shape[i];
if (SizeToLong(i) != split_dim) {
ASSERT_EQ(diff, shape[i]);
} else {
ASSERT_EQ(diff, num / split_count);

29
tests/ut/cpp/parallel/tensor_layout/redistribution_layout_transfer_test.cc
View File

@ -20,14 +20,11 @@
#include "frontend/parallel/tensor_layout/tensor_layout.h"
#include "frontend/parallel/tensor_layout/redistribution_layout_transfer.h"
#include "util_layout_gen_test.h"
#include "frontend/parallel/step_parallel.h"
namespace mindspore {
namespace parallel {
using DeviceArrangement = std::vector<int32_t>;
using TensorMap = std::vector<int32_t>;
using TensorShape = std::vector<int32_t>;
class TestRedistributionLayoutTransfer : public UT::Common {
public:
TestRedistributionLayoutTransfer() {}
@ -245,13 +242,13 @@ void ValidRedistributionLayoutCheck(const DeviceArrangement& in_device_arrangeme
unified_out_tensor_map, unified_tensor_shape);
}
void ValidRedistributionLayoutCheckAll(int32_t device_pow_size, int32_t tensor_pow_size,
int32_t max_device_dim, int32_t max_shape_dim) {
void ValidRedistributionLayoutCheckAll(int64_t device_pow_size, int64_t tensor_pow_size,
int64_t max_device_dim, int64_t max_shape_dim) {
std::vector<std::tuple<DeviceArrangement, TensorMap, TensorShape>> layout_list;
GenerateValidLayoutByDeviceSizeAndTensorSize(device_pow_size, tensor_pow_size, max_device_dim, max_shape_dim,
&layout_list);
for (uint32_t in = 0; in < layout_list.size(); in++) {
for (uint32_t out = 0; out < layout_list.size(); out++) {
for (size_t in = 0; in < layout_list.size(); in++) {
for (size_t out = 0; out < layout_list.size(); out++) {
DeviceArrangement in_device_arrangement = std::get<0>(layout_list[in]);
TensorMap in_tensor_map = std::get<1>(layout_list[in]);
TensorShape in_tensor_shape = std::get<2>(layout_list[in]);
@ -273,15 +270,15 @@ void ValidRedistributionLayoutCheckAll(int32_t device_pow_size, int32_t tensor_p
}
TEST_F(TestRedistributionLayoutTransfer, RedistributionLayoutTransferCheckAll) {
int32_t device_pow_size_max = 4;
int32_t tensor_pow_size_max = 4;
int32_t device_pow_size_min = 1;
int32_t tensor_pow_size_min = 1;
const int32_t max_device_dim = 5;
const int32_t max_shape_dim = 5;
int32_t device_pow_size = device_pow_size_min;
int64_t device_pow_size_max = 4;
int64_t tensor_pow_size_max = 4;
int64_t device_pow_size_min = 1;
int64_t tensor_pow_size_min = 1;
const int64_t max_device_dim = 5;
const int64_t max_shape_dim = 5;
int64_t device_pow_size = device_pow_size_min;
while (device_pow_size <= device_pow_size_max) {
int32_t tensor_pow_size = tensor_pow_size_min;
int64_t tensor_pow_size = tensor_pow_size_min;
while (tensor_pow_size <= tensor_pow_size_max) {
ValidRedistributionLayoutCheckAll(device_pow_size, tensor_pow_size, max_device_dim, max_shape_dim);
tensor_pow_size++;

4
tests/ut/cpp/parallel/tensor_layout/redistribution_operator_infer_test.cc
View File

@ -28,13 +28,13 @@ class TestRedistributionOperatorInfer : public UT::Common {
TestRedistributionOperatorInfer() {}
void SetUp() {
std::vector<int32_t> dev_list;
RankList dev_list;
for (int32_t i = 0; i < 1050; i++) {
dev_list.push_back(i);
}
std::vector<int32_t> stage_map;
RankList stage_map;
stage_map.push_back(1024);
stage_map.push_back(26);

45
tests/ut/cpp/parallel/tensor_layout/reshape_layout_transfer_test.cc
View File

@ -21,14 +21,11 @@
#include "frontend/parallel/tensor_layout/reshape_layout_transfer.h"
#include "util_layout_gen_test.h"
#include "utils/log_adapter.h"
#include "frontend/parallel/step_parallel.h"
namespace mindspore {
namespace parallel {
using DeviceArrangement = std::vector<int32_t>;
using TensorMap = std::vector<int32_t>;
using TensorShape = std::vector<int32_t>;
class TestReshapeLayoutTransfer : public UT::Common {
public:
TestReshapeLayoutTransfer() {}
@ -260,13 +257,13 @@ TEST_F(TestReshapeLayoutTransfer, ValidInferUnifiedLayoutCheck11) {
ValidUnifiedLayoutCheck(device_arrangement, in_tensor_map, in_tensor_shape, out_tensor_map, out_tensor_shape);
}
void ValidInferUnifiedLayoutCheckAll(int32_t device_pow_size, int32_t tensor_pow_size,
int32_t max_device_dim, int32_t max_shape_dim) {
void ValidInferUnifiedLayoutCheckAll(int64_t device_pow_size, int64_t tensor_pow_size,
int64_t max_device_dim, int64_t max_shape_dim) {
std::vector<std::tuple<DeviceArrangement, TensorMap, TensorShape>> layout_list;
GenerateValidLayoutByDeviceSizeAndTensorSize(device_pow_size, tensor_pow_size, max_device_dim, max_shape_dim,
&layout_list);
for (uint32_t in = 0; in < layout_list.size(); in++) {
for (uint32_t out = 0; out < layout_list.size(); out++) {
for (size_t in = 0; in < layout_list.size(); in++) {
for (size_t out = 0; out < layout_list.size(); out++) {
DeviceArrangement in_device_arrangement = std::get<0>(layout_list[in]);
TensorMap in_tensor_map = std::get<1>(layout_list[in]);
TensorShape in_tensor_shape = std::get<2>(layout_list[in]);
@ -287,15 +284,15 @@ void ValidInferUnifiedLayoutCheckAll(int32_t device_pow_size, int32_t tensor_pow
}
TEST_F(TestReshapeLayoutTransfer, ValidInferUnifiedLayoutCheckAll) {
int32_t device_pow_size_max = 4;
int32_t tensor_pow_size_max = 4;
int32_t device_pow_size_min = 1;
int32_t tensor_pow_size_min = 1;
const int32_t max_device_dim = 5;
const int32_t max_shape_dim = 5;
int32_t device_pow_size = device_pow_size_min;
int64_t device_pow_size_max = 4;
int64_t tensor_pow_size_max = 4;
int64_t device_pow_size_min = 1;
int64_t tensor_pow_size_min = 1;
const int64_t max_device_dim = 5;
const int64_t max_shape_dim = 5;
int64_t device_pow_size = device_pow_size_min;
while (device_pow_size <= device_pow_size_max) {
int32_t tensor_pow_size = tensor_pow_size_min;
int64_t tensor_pow_size = tensor_pow_size_min;
while (tensor_pow_size <= tensor_pow_size_max) {
ValidInferUnifiedLayoutCheckAll(device_pow_size, tensor_pow_size, max_device_dim, max_shape_dim);
tensor_pow_size++;
@ -305,15 +302,15 @@ TEST_F(TestReshapeLayoutTransfer, ValidInferUnifiedLayoutCheckAll) {
}
TEST_F(TestReshapeLayoutTransfer, ValidInferUnifiedLayoutCheckAll2) {
int32_t device_pow_size_max = 1;
int32_t tensor_pow_size_max = 2;
int32_t device_pow_size_min = 1;
int32_t tensor_pow_size_min = 2;
const int32_t max_device_dim = 5;
const int32_t max_shape_dim = 5;
int32_t device_pow_size = device_pow_size_min;
int64_t device_pow_size_max = 1;
int64_t tensor_pow_size_max = 2;
int64_t device_pow_size_min = 1;
int64_t tensor_pow_size_min = 2;
const int64_t max_device_dim = 5;
const int64_t max_shape_dim = 5;
int64_t device_pow_size = device_pow_size_min;
while (device_pow_size <= device_pow_size_max) {
int32_t tensor_pow_size = tensor_pow_size_min;
int64_t tensor_pow_size = tensor_pow_size_min;
while (tensor_pow_size <= tensor_pow_size_max) {
ValidInferUnifiedLayoutCheckAll(device_pow_size, tensor_pow_size, max_device_dim, max_shape_dim);
tensor_pow_size++;

44
tests/ut/cpp/parallel/tensor_layout/shape_util_test.cc
View File

@ -26,7 +26,7 @@ namespace parallel {
* shape_accum = [2, 2 * 8, 2 * 8 * 32]
*/
TEST(ShapeUtilTest, ShapeToAccumulateProduct) {
std::vector<int32_t> shape = {2, 8, 32};
Shape shape = {2, 8, 32};
std::vector<int64_t> shape_accum;
Status status = ShapeToAccumulateProduct(shape, &shape_accum);
ASSERT_EQ(Status::SUCCESS, status);
@ -39,7 +39,7 @@ TEST(ShapeUtilTest, ShapeToAccumulateProduct) {
* shape_accum = [2 * 8 * 32, 8 * 32, 32]
*/
TEST(ShapeUtilTest, ShapeToAccumulateProductReverse) {
std::vector<int32_t> shape = {2, 8, 32};
Shape shape = {2, 8, 32};
std::vector<int64_t> shape_accum;
Status status = ShapeToAccumulateProductReverse(shape, &shape_accum);
ASSERT_EQ(Status::SUCCESS, status);
@ -53,10 +53,10 @@ TEST(ShapeUtilTest, ShapeToAccumulateProductReverse) {
*/
TEST(ShapeUtilTest, AccumulateProductToShape) {
std::vector<int64_t> shape_accum = {2, 2 * 8, 2 * 8 * 32};
std::vector<int32_t> shape;
Shape shape;
Status status = AccumulateProductToShape(shape_accum, &shape);
ASSERT_EQ(Status::SUCCESS, status);
std::vector<int32_t> shape_expect = {2, 8, 32};
Shape shape_expect = {2, 8, 32};
ASSERT_EQ(shape_expect, shape);
}
@ -66,10 +66,10 @@ TEST(ShapeUtilTest, AccumulateProductToShape) {
*/
TEST(ShapeUtilTest, AccumulateProductReverseToShape) {
std::vector<int64_t> shape_accum = {2 * 8 * 32, 8 * 32, 32};
std::vector<int32_t> shape;
Shape shape;
Status status = AccumulateProductReverseToShape(shape_accum, &shape);
ASSERT_EQ(Status::SUCCESS, status);
std::vector<int32_t> shape_expect = {2, 8, 32};
Shape shape_expect = {2, 8, 32};
ASSERT_EQ(shape_expect, shape);
}
@ -94,12 +94,12 @@ TEST(ShapeUtilTest, UnifyAccumulateProduct) {
* out = [2, 2, 2]
*/
TEST(ShapeUtilTest, UnifyShape1) {
std::vector<int32_t> in1 = {2, 4};
std::vector<int32_t> in2 = {4, 2};
std::vector<int32_t> out;
Shape in1 = {2, 4};
Shape in2 = {4, 2};
Shape out;
Status status = UnifyShape(in1, in2, &out);
ASSERT_EQ(Status::SUCCESS, status);
std::vector<int32_t> out_expect = {2, 2, 2};
Shape out_expect = {2, 2, 2};
ASSERT_EQ(out_expect, out);
}
@ -109,12 +109,12 @@ TEST(ShapeUtilTest, UnifyShape1) {
* out = [2, 4, 4]
*/
TEST(ShapeUtilTest, UnifyShape2) {
std::vector<int32_t> in1 = {8, 4};
std::vector<int32_t> in2 = {2, 16};
std::vector<int32_t> out;
Shape in1 = {8, 4};
Shape in2 = {2, 16};
Shape out;
Status status = UnifyShape(in1, in2, &out);
ASSERT_EQ(Status::SUCCESS, status);
std::vector<int32_t> out_expect = {2, 4, 4};
Shape out_expect = {2, 4, 4};
ASSERT_EQ(out_expect, out);
}
@ -184,12 +184,12 @@ TEST(ShapeUtilTest, ExpandAccumulateProduct4) {
* out = [2, 8, 4, 8]
*/
TEST(ShapeUtilTest, ExpandShape1) {
std::vector<int32_t> in = {2, 8, 32};
std::vector<int32_t> expand = {16, 4, 8};
std::vector<int32_t> out;
Shape in = {2, 8, 32};
Shape expand = {16, 4, 8};
Shape out;
Status status = ExpandShape(in, expand, &out);
ASSERT_EQ(Status::SUCCESS, status);
std::vector<int32_t> out_expect = {2, 8, 4, 8};
Shape out_expect = {2, 8, 4, 8};
ASSERT_EQ(out_expect, out);
}
@ -199,12 +199,12 @@ TEST(ShapeUtilTest, ExpandShape1) {
* out = [2, 8, 4, 8]
*/
TEST(ShapeUtilTest, ExpandShape2) {
std::vector<int32_t> in = {2, 8, 32};
std::vector<int32_t> expand = {2, 4, 8};
std::vector<int32_t> out;
Shape in = {2, 8, 32};
Shape expand = {2, 4, 8};
Shape out;
Status status = ExpandShape(in, expand, &out);
ASSERT_EQ(Status::SUCCESS, status);
std::vector<int32_t> out_expect = {2, 4, 2, 4, 8};
Shape out_expect = {2, 4, 2, 4, 8};
ASSERT_EQ(out_expect, out);
}

181
tests/ut/cpp/parallel/tensor_layout/tensor_layout_test.cc
View File

@ -18,6 +18,7 @@
#include "common/common_test.h"
#include "common/py_func_graph_fetcher.h"
#include "frontend/parallel/tensor_layout/tensor_layout.h"
#include "frontend/parallel/step_parallel.h"
namespace mindspore {
namespace parallel {
@ -31,12 +32,12 @@ class TestTensorLayout : public UT::Common {
virtual void TearDown() {}
};
void ReshapeExpandDeviceArrangementTestFunction(const std::vector<int32_t>& in_device_arrangement_shape,
const std::vector<int32_t>& in_tensor_map_shape,
const std::vector<int32_t>& in_tensor_shape_shape,
const std::vector<int32_t>& out_device_arrangement_shape,
const std::vector<int32_t>& out_tensor_map_shape,
const std::vector<int32_t>& out_tensor_shape_shape) {
void ReshapeExpandDeviceArrangementTestFunction(const DeviceArrangement& in_device_arrangement_shape,
const TensorMap& in_tensor_map_shape,
const TensorShape& in_tensor_shape_shape,
const DeviceArrangement& out_device_arrangement_shape,
const TensorMap& out_tensor_map_shape,
const TensorShape& out_tensor_shape_shape) {
Arrangement device_arrangement;
Status status = device_arrangement.Init(in_device_arrangement_shape);
ASSERT_EQ(Status::SUCCESS, status);
@ -70,12 +71,12 @@ void ReshapeExpandDeviceArrangementTestFunction(const std::vector<int32_t>& in_d
*
*/
TEST_F(TestTensorLayout, ReshapeExpandDeviceArrangement1) {
std::vector<int32_t> device_arrangement = {8, 4};
std::vector<int32_t> tensor_map = {1, 0};
std::vector<int32_t> tensor_shape = {512, 1024};
std::vector<int32_t> device_arrangement_new = {4, 2, 2, 2};
std::vector<int32_t> tensor_map_expect = {3, 2, 1, 0};
std::vector<int32_t> tensor_shape_expect = {4, 128, 2, 512};
DeviceArrangement device_arrangement = {8, 4};
TensorMap tensor_map = {1, 0};
TensorShape tensor_shape = {512, 1024};
DeviceArrangement device_arrangement_new = {4, 2, 2, 2};
TensorMap tensor_map_expect = {3, 2, 1, 0};
TensorShape tensor_shape_expect = {4, 128, 2, 512};
ReshapeExpandDeviceArrangementTestFunction(device_arrangement, tensor_map, tensor_shape, device_arrangement_new,
tensor_map_expect, tensor_shape_expect);
}
@ -91,12 +92,12 @@ TEST_F(TestTensorLayout, ReshapeExpandDeviceArrangement1) {
* out_tensor_shape = [2, 256, 4, 256]
*/
TEST_F(TestTensorLayout, ReshapeExpandDeviceArrangement2) {
std::vector<int32_t> device_arrangement = {8, 4};
std::vector<int32_t> tensor_map = {0, 1};
std::vector<int32_t> tensor_shape = {512, 1024};
std::vector<int32_t> device_arrangement_new = {4, 2, 2, 2};
std::vector<int32_t> tensor_map_expect = {1, 0, 3, 2};
std::vector<int32_t> tensor_shape_expect = {2, 256, 4, 256};
DeviceArrangement device_arrangement = {8, 4};
TensorMap tensor_map = {0, 1};
TensorShape tensor_shape = {512, 1024};
DeviceArrangement device_arrangement_new = {4, 2, 2, 2};
TensorMap tensor_map_expect = {1, 0, 3, 2};
TensorShape tensor_shape_expect = {2, 256, 4, 256};
ReshapeExpandDeviceArrangementTestFunction(device_arrangement, tensor_map, tensor_shape, device_arrangement_new,
tensor_map_expect, tensor_shape_expect);
}
@ -111,12 +112,12 @@ TEST_F(TestTensorLayout, ReshapeExpandDeviceArrangement2) {
* out_tensor_shape = [4, 128, 1024]
*/
TEST_F(TestTensorLayout, ReshapeExpandDeviceArrangement3) {
std::vector<int32_t> device_arrangement = {8, 4};
std::vector<int32_t> tensor_map = {1, -1};
std::vector<int32_t> tensor_shape = {512, 1024};
std::vector<int32_t> device_arrangement_new = {4, 2, 2, 2};
std::vector<int32_t> tensor_map_expect = {3, 2, -1};
std::vector<int32_t> tensor_shape_expect = {4, 128, 1024};
DeviceArrangement device_arrangement = {8, 4};
TensorMap tensor_map = {1, -1};
TensorShape tensor_shape = {512, 1024};
DeviceArrangement device_arrangement_new = {4, 2, 2, 2};
TensorMap tensor_map_expect = {3, 2, -1};
TensorShape tensor_shape_expect = {4, 128, 1024};
ReshapeExpandDeviceArrangementTestFunction(device_arrangement, tensor_map, tensor_shape, device_arrangement_new,
tensor_map_expect, tensor_shape_expect);
}
@ -132,33 +133,33 @@ TEST_F(TestTensorLayout, ReshapeExpandDeviceArrangement3) {
* out_tensor_shape = [512, 4, 256]
*/
TEST_F(TestTensorLayout, ReshapeExpandDeviceArrangement4) {
std::vector<int32_t> device_arrangement = {8, 4};
std::vector<int32_t> tensor_map = {0, 1};
std::vector<int32_t> tensor_shape = {512, 1024};
std::vector<int32_t> device_arrangement_new = {4, 2, 4};
std::vector<int32_t> tensor_map_expect = {0, 2, 1};
std::vector<int32_t> tensor_shape_expect = {512, 4, 256};
DeviceArrangement device_arrangement = {8, 4};
TensorMap tensor_map = {0, 1};
TensorShape tensor_shape = {512, 1024};
DeviceArrangement device_arrangement_new = {4, 2, 4};
TensorMap tensor_map_expect = {0, 2, 1};
TensorShape tensor_shape_expect = {512, 4, 256};
ReshapeExpandDeviceArrangementTestFunction(device_arrangement, tensor_map, tensor_shape, device_arrangement_new,
tensor_map_expect, tensor_shape_expect);
}
TEST_F(TestTensorLayout, ReshapeExpandDeviceArrangement5) {
std::vector<int32_t> device_arrangement = {8, 4};
std::vector<int32_t> tensor_map = {1, -1, 0};
std::vector<int32_t> tensor_shape = {128, 4, 1024};
std::vector<int32_t> device_arrangement_new = {8, 4};
std::vector<int32_t> tensor_map_expect = {1, -1, 0};
std::vector<int32_t> tensor_shape_expect = {128, 4, 1024};
DeviceArrangement device_arrangement = {8, 4};
TensorMap tensor_map = {1, -1, 0};
TensorShape tensor_shape = {128, 4, 1024};
DeviceArrangement device_arrangement_new = {8, 4};
TensorMap tensor_map_expect = {1, -1, 0};
TensorShape tensor_shape_expect = {128, 4, 1024};
ReshapeExpandDeviceArrangementTestFunction(device_arrangement, tensor_map, tensor_shape, device_arrangement_new,
tensor_map_expect, tensor_shape_expect);
}
void ExpandTensorShapeTestFunction(const std::vector<int32_t>& in_device_arrangement_shape,
const std::vector<int32_t>& in_tensor_map_shape,
const std::vector<int32_t>& in_tensor_shape_shape,
const std::vector<int32_t>& out_device_arrangement_shape,
const std::vector<int32_t>& out_tensor_map_shape,
const std::vector<int32_t>& out_tensor_shape_shape) {
void ExpandTensorShapeTestFunction(const DeviceArrangement& in_device_arrangement_shape,
const TensorMap& in_tensor_map_shape,
const TensorShape& in_tensor_shape_shape,
const DeviceArrangement& out_device_arrangement_shape,
const TensorMap& out_tensor_map_shape,
const TensorShape& out_tensor_shape_shape) {
Arrangement device_arrangement;
Status status = device_arrangement.Init(in_device_arrangement_shape);
ASSERT_EQ(Status::SUCCESS, status);
@ -193,31 +194,31 @@ void ExpandTensorShapeTestFunction(const std::vector<int32_t>& in_device_arrange
* out_tensor_map = [2, 1, 0],
*/
TEST_F(TestTensorLayout, ExpandTensorShape1) {
std::vector<int32_t> device_arrangement = {8, 4};
std::vector<int32_t> tensor_map = {1, 0};
std::vector<int32_t> tensor_shape = {512, 1024};
std::vector<int32_t> device_arrangement_expect = {4, 2, 4};
std::vector<int32_t> tensor_map_expect = {2, 1, 0};
std::vector<int32_t> tensor_shape_new = {4, 128, 1024};
DeviceArrangement device_arrangement = {8, 4};
TensorMap tensor_map = {1, 0};
TensorShape tensor_shape = {512, 1024};
DeviceArrangement device_arrangement_expect = {4, 2, 4};
TensorMap tensor_map_expect = {2, 1, 0};
TensorShape tensor_shape_new = {4, 128, 1024};
ExpandTensorShapeTestFunction(device_arrangement, tensor_map, tensor_shape, device_arrangement_expect,
tensor_map_expect, tensor_shape_new);
}
TEST_F(TestTensorLayout, ExpandTensorShape2) {
std::vector<int32_t> device_arrangement = {8, 4};
std::vector<int32_t> tensor_map = {1, 0};
std::vector<int32_t> tensor_shape = {128, 4096};
std::vector<int32_t> device_arrangement_expect = {8, 4};
std::vector<int32_t> tensor_map_expect = {1, 0, -1};
std::vector<int32_t> tensor_shape_new = {128, 4, 1024};
DeviceArrangement device_arrangement = {8, 4};
TensorMap tensor_map = {1, 0};
TensorShape tensor_shape = {128, 4096};
DeviceArrangement device_arrangement_expect = {8, 4};
TensorMap tensor_map_expect = {1, 0, -1};
TensorShape tensor_shape_new = {128, 4, 1024};
ExpandTensorShapeTestFunction(device_arrangement, tensor_map, tensor_shape, device_arrangement_expect,
tensor_map_expect, tensor_shape_new);
}
TEST_F(TestTensorLayout, GetSliceShape) {
std::vector<int32_t> in_device_arrangement = {8, 4};
std::vector<int32_t> in_tensor_map = {1, -1};
std::vector<int32_t> in_tensor_shape = {512, 1024};
DeviceArrangement in_device_arrangement = {8, 4};
TensorMap in_tensor_map = {1, -1};
TensorShape in_tensor_shape = {512, 1024};
Arrangement device_arrangement;
device_arrangement.Init(in_device_arrangement);
Map tensor_map;
@ -233,9 +234,9 @@ TEST_F(TestTensorLayout, GetSliceShape) {
}
TEST_F(TestTensorLayout, UpdateTensorMap) {
std::vector<int32_t> in_device_arrangement = {8, 4};
std::vector<int32_t> in_tensor_map = {1, -1};
std::vector<int32_t> in_tensor_shape = {512, 1024};
DeviceArrangement in_device_arrangement = {8, 4};
TensorMap in_tensor_map = {1, -1};
TensorShape in_tensor_shape = {512, 1024};
Arrangement device_arrangement;
device_arrangement.Init(in_device_arrangement);
Map tensor_map;
@ -250,12 +251,12 @@ TEST_F(TestTensorLayout, UpdateTensorMap) {
ASSERT_EQ(in_tensor_map, new_tensor_map);
}
void RemoveElementEqualToOneInDeviceArrangementTestFunction(const std::vector<int32_t>& in_device_arrangement_shape,
const std::vector<int32_t>& in_tensor_map_shape,
const std::vector<int32_t>& in_tensor_shape_shape,
const std::vector<int32_t>& out_device_arrangement_shape,
const std::vector<int32_t>& out_tensor_map_shape,
const std::vector<int32_t>& out_tensor_shape_shape) {
void RemoveElementEqualToOneInDeviceArrangementTestFunction(const DeviceArrangement& in_device_arrangement_shape,
const TensorMap& in_tensor_map_shape,
const TensorShape& in_tensor_shape_shape,
const DeviceArrangement& out_device_arrangement_shape,
const TensorMap& out_tensor_map_shape,
const TensorShape& out_tensor_shape_shape) {
Arrangement device_arrangement;
Status status = device_arrangement.Init(in_device_arrangement_shape);
ASSERT_EQ(Status::SUCCESS, status);
@ -277,45 +278,45 @@ void RemoveElementEqualToOneInDeviceArrangementTestFunction(const std::vector<in
}
TEST_F(TestTensorLayout, RemoveElementEqualToOneInDeviceArrangement1) {
std::vector<int32_t> device_arrangement = {2, 2, 1};
std::vector<int32_t> tensor_map = {2, 1};
std::vector<int32_t> tensor_shape = {128, 4096};
std::vector<int32_t> device_arrangement_expect = {2, 2};
std::vector<int32_t> tensor_map_expect = {1, 0};
std::vector<int32_t> tensor_shape_new = {128, 4096};
DeviceArrangement device_arrangement = {2, 2, 1};
TensorMap tensor_map = {2, 1};
TensorShape tensor_shape = {128, 4096};
DeviceArrangement device_arrangement_expect = {2, 2};
TensorMap tensor_map_expect = {1, 0};
TensorShape tensor_shape_new = {128, 4096};
RemoveElementEqualToOneInDeviceArrangementTestFunction(
device_arrangement, tensor_map, tensor_shape, device_arrangement_expect, tensor_map_expect, tensor_shape_new);
}
TEST_F(TestTensorLayout, RemoveElementEqualToOneInDeviceArrangement2) {
std::vector<int32_t> device_arrangement = {16, 1, 1};
std::vector<int32_t> tensor_map = {2, 0};
std::vector<int32_t> tensor_shape = {128, 4096};
std::vector<int32_t> device_arrangement_expect = {16};
std::vector<int32_t> tensor_map_expect = {0, -1};
std::vector<int32_t> tensor_shape_new = {128, 4096};
DeviceArrangement device_arrangement = {16, 1, 1};
TensorMap tensor_map = {2, 0};
TensorShape tensor_shape = {128, 4096};
DeviceArrangement device_arrangement_expect = {16};
TensorMap tensor_map_expect = {0, -1};
TensorShape tensor_shape_new = {128, 4096};
RemoveElementEqualToOneInDeviceArrangementTestFunction(
device_arrangement, tensor_map, tensor_shape, device_arrangement_expect, tensor_map_expect, tensor_shape_new);
}
TEST_F(TestTensorLayout, RemoveElementEqualToOneInDeviceArrangement3) {
std::vector<int32_t> device_arrangement = {1, 16, 1};
std::vector<int32_t> tensor_map = {2, 1};
std::vector<int32_t> tensor_shape = {128, 4096};
std::vector<int32_t> device_arrangement_expect = {16};
std::vector<int32_t> tensor_map_expect = {-1, 0};
std::vector<int32_t> tensor_shape_new = {128, 4096};
DeviceArrangement device_arrangement = {1, 16, 1};
TensorMap tensor_map = {2, 1};
TensorShape tensor_shape = {128, 4096};
DeviceArrangement device_arrangement_expect = {16};
TensorMap tensor_map_expect = {-1, 0};
TensorShape tensor_shape_new = {128, 4096};
RemoveElementEqualToOneInDeviceArrangementTestFunction(
device_arrangement, tensor_map, tensor_shape, device_arrangement_expect, tensor_map_expect, tensor_shape_new);
}
TEST_F(TestTensorLayout, RemoveElementEqualToOneInDeviceArrangement4) {
std::vector<int32_t> device_arrangement = {1, 1, 1};
std::vector<int32_t> tensor_map = {2, 1};
std::vector<int32_t> tensor_shape = {128, 4096};
std::vector<int32_t> device_arrangement_expect = {};
std::vector<int32_t> tensor_map_expect = {-1, -1};
std::vector<int32_t> tensor_shape_new = {128, 4096};
DeviceArrangement device_arrangement = {1, 1, 1};
TensorMap tensor_map = {2, 1};
TensorShape tensor_shape = {128, 4096};
DeviceArrangement device_arrangement_expect = {};
TensorMap tensor_map_expect = {-1, -1};
TensorShape tensor_shape_new = {128, 4096};
RemoveElementEqualToOneInDeviceArrangementTestFunction(
device_arrangement, tensor_map, tensor_shape, device_arrangement_expect, tensor_map_expect, tensor_shape_new);
}

21
tests/ut/cpp/parallel/tensor_layout/tensor_redistribution_test.cc
View File

@ -18,6 +18,7 @@
#include "common/common_test.h"
#include "common/py_func_graph_fetcher.h"
#include "frontend/parallel/tensor_layout/tensor_redistribution.h"
#include "frontend/parallel/step_parallel.h"
namespace mindspore {
namespace parallel {
@ -33,7 +34,7 @@ class TestTensorRedistribution : public UT::Common {
dev_list.push_back(i);
}
std::vector<int32_t> stage_map;
RankList stage_map;
stage_map.push_back(16);
stage_map.push_back(4);
@ -49,9 +50,9 @@ class TestTensorRedistribution : public UT::Common {
// Redistribution: Reshape -> SplitByAxis -> ConcatByAxis -> SplitByAxis -> Reshape
TEST_F(TestTensorRedistribution, TestInferRedistribution1) {
std::vector<int32_t> device_arrangement = {2, 4, 2};
std::vector<int32_t> tensor_map = {2, 0};
std::vector<int32_t> tensor_shape = {512, 1024};
DeviceArrangement device_arrangement = {2, 4, 2};
TensorMap tensor_map = {2, 0};
TensorShape tensor_shape = {512, 1024};
Arrangement in_device_arrangement;
Status status = in_device_arrangement.Init(device_arrangement);
@ -102,9 +103,9 @@ TEST_F(TestTensorRedistribution, TestInferRedistribution1) {
// Redistribution: AlltoAll
TEST_F(TestTensorRedistribution, TestInferRedistribution2) {
std::vector<int32_t> device_arrangement = {16, 1, 1};
std::vector<int32_t> tensor_map = {2, 0};
std::vector<int32_t> tensor_shape = {512, 1024};
DeviceArrangement device_arrangement = {16, 1, 1};
TensorMap tensor_map = {2, 0};
TensorShape tensor_shape = {512, 1024};
Arrangement in_device_arrangement;
Status status = in_device_arrangement.Init(device_arrangement);
@ -154,9 +155,9 @@ TEST_F(TestTensorRedistribution, TestInferRedistribution2) {
// Redistribution: Reshape
TEST_F(TestTensorRedistribution, TestInferRedistribution3) {
std::vector<int32_t> device_arrangement = {8};
std::vector<int32_t> tensor_map = {0, -1, -1, -1};
std::vector<int32_t> tensor_shape = {128, 64, 1, 1};
DeviceArrangement device_arrangement = {8};
TensorMap tensor_map = {0, -1, -1, -1};
TensorShape tensor_shape = {128, 64, 1, 1};
Arrangement in_device_arrangement;
Status status = in_device_arrangement.Init(device_arrangement);

182
tests/ut/cpp/parallel/tensor_layout/util_layout_gen_test.cc
View File

@ -28,21 +28,21 @@ using std::pow;
namespace mindspore {
namespace parallel {
std::vector<std::vector<int32_t>> combine(const std::vector<int32_t>& in, int32_t target) {
std::vector<std::vector<int32_t>> output;
for (int32_t i = 0; i < pow(2, in.size()); i++) {
int32_t temp = 0;
int32_t count = 0;
std::vector<int32_t> left;
for (int32_t j = 0; j < in.size(); j++) {
std::vector<Shape> combine(const Shape& in, int64_t target) {
std::vector<Shape> output;
for (int64_t i = 0; i < pow(2, in.size()); i++) {
size_t temp = 0;
size_t count = 0;
Shape left;
for (size_t j = 0; j < in.size(); j++) {
if ((i & (1 << j)) != 0) {
left.push_back(j);
count++;
}
}
if (count == target) {
std::vector<int32_t> one_case;
for (int32_t j = 0; j < count; j++) {
Shape one_case;
for (size_t j = 0; j < count; j++) {
temp = in.size() - 1 - left[j];
one_case.push_back(in[temp]);
}
@ -54,24 +54,23 @@ std::vector<std::vector<int32_t>> combine(const std::vector<int32_t>& in, int32_
return output;
}
void GenerateValidShapeBySizeAndDim(int32_t pow_size, int32_t dim,
std::vector<std::vector<int32_t>>* out) {
void GenerateValidShapeBySizeAndDim(int64_t pow_size, int64_t dim, std::vector<Shape>* out) {
out->clear();
std::vector<int32_t> in;
for (int32_t i = 1; i < pow_size; i++) {
Shape in;
for (int64_t i = 1; i < pow_size; i++) {
in.push_back(i);
}
std::vector<std::vector<int32_t>> combine_result;
std::vector<Shape> combine_result;
combine_result = combine(in, dim - 1);
if (combine_result.size() == 0) {
int32_t size = exp2(pow_size);
std::vector<int32_t> item = {size};
int64_t size = exp2(pow_size);
Shape item = {size};
out->push_back(item);
}
for (uint32_t i = 0; i < combine_result.size(); i++) {
std::vector<int32_t> item;
int32_t prev = 0;
for (int32_t j = combine_result[i].size() - 1; j >= 0; j--) {
for (size_t i = 0; i < combine_result.size(); i++) {
Shape item;
int64_t prev = 0;
for (int64_t j = combine_result[i].size() - 1; j >= 0; j--) {
item.push_back(exp2(combine_result[i][j] - prev));
prev = combine_result[i][j];
}
@ -81,22 +80,21 @@ void GenerateValidShapeBySizeAndDim(int32_t pow_size, int32_t dim,
return;
}
void GenerateValidShapeBySize(int32_t pow_size, std::vector<std::vector<int32_t>>* out) {
void GenerateValidShapeBySize(int64_t pow_size, std::vector<Shape>* out) {
out->clear();
for (int32_t dim = 1; dim <= pow_size; dim++) {
std::vector<std::vector<int32_t>> combine_result;
for (int64_t dim = 1; dim <= pow_size; dim++) {
std::vector<Shape> combine_result;
GenerateValidShapeBySizeAndDim(pow_size, dim, &combine_result);
for (uint32_t i = 0; i < combine_result.size(); i++) {
for (size_t i = 0; i < combine_result.size(); i++) {
out->push_back(combine_result[i]);
}
}
return;
}
std::vector<int32_t> GenerateTensorMap(const uint32_t& map_size, const std::vector<int32_t>& pos_index,
const std::vector<int32_t>& pos_value) {
std::vector<int32_t> tensor_map(map_size, -1);
for (uint32_t i = 0; i < pos_index.size() && i < pos_value.size(); i++) {
TensorMap GenerateTensorMap(const int64_t& map_size, const Shape& pos_index, const Shape& pos_value) {
TensorMap tensor_map(map_size, -1);
for (size_t i = 0; i < pos_index.size() && i < pos_value.size(); i++) {
if (pos_index[i] >= map_size) {
continue;
}
@ -105,43 +103,43 @@ std::vector<int32_t> GenerateTensorMap(const uint32_t& map_size, const std::vect
return tensor_map;
}
void GenerateValidTensorMap(const std::vector<int32_t>& device_arrangement, const std::vector<int32_t>& tensor_shape,
std::vector<std::vector<int32_t>>* tensor_map_list) {
void GenerateValidTensorMap(const DeviceArrangement& device_arrangement, const TensorShape& tensor_shape,
std::vector<TensorMap>* tensor_map_list) {
tensor_map_list->clear();
int32_t device_size = device_arrangement.size();
int32_t shape_size = tensor_shape.size();
std::vector<int32_t> pos_ind_combine_in;
for (int32_t i = 0; i < shape_size; i++) {
int64_t device_size = device_arrangement.size();
int64_t shape_size = tensor_shape.size();
Shape pos_ind_combine_in;
for (int64_t i = 0; i < shape_size; i++) {
pos_ind_combine_in.push_back(i);
}
std::vector<int32_t> dev_ind_combine_in;
for (int32_t i = 0; i < device_size; i++) {
Shape dev_ind_combine_in;
for (int64_t i = 0; i < device_size; i++) {
dev_ind_combine_in.push_back(i);
}
std::vector<int32_t> none_map(tensor_shape.size(), -1);
TensorMap none_map(tensor_shape.size(), -1);
tensor_map_list->push_back(none_map);
for (uint32_t pos_num = 1; (pos_num <= shape_size) && (pos_num <= device_size); pos_num++) {
std::vector<std::vector<int32_t>> pos_index;
for (int64_t pos_num = 1; (pos_num <= shape_size) && (pos_num <= device_size); pos_num++) {
std::vector<Shape> pos_index;
pos_index = combine(pos_ind_combine_in, pos_num);
std::vector<std::vector<int32_t>> dev_index;
std::vector<Shape> dev_index;
dev_index = combine(dev_ind_combine_in, pos_num);
for (int l = 0; l < dev_index.size(); l++) {
std::vector<int32_t> pos_value_combine_in;
for (size_t l = 0; l < dev_index.size(); l++) {
Shape pos_value_combine_in;
for (int32_t i = dev_index[l].size() - 1; i >= 0; i--) {
pos_value_combine_in.push_back(dev_index[l][i]);
}
std::vector<std::vector<int32_t>> pos_value;
std::vector<int32_t>::iterator it = pos_value_combine_in.begin();
std::vector<Shape> pos_value;
Shape::iterator it = pos_value_combine_in.begin();
do {
std::vector<int32_t> pos_value_item;
for (uint32_t m = 0; m < pos_num; m++) {
Shape pos_value_item;
for (size_t m = 0; m < pos_num; m++) {
pos_value_item.push_back(pos_value_combine_in[m]);
}
pos_value.push_back(pos_value_item);
} while (next_permutation(it, it + pos_num));
for (uint32_t j = 0; j < pos_index.size(); j++) {
for (uint32_t k = 0; k < pos_value.size(); k++) {
std::vector<int32_t> tensor_map = GenerateTensorMap(shape_size, pos_index[j], pos_value[k]);
for (size_t j = 0; j < pos_index.size(); j++) {
for (size_t k = 0; k < pos_value.size(); k++) {
TensorMap tensor_map = GenerateTensorMap(shape_size, pos_index[j], pos_value[k]);
tensor_map_list->push_back(tensor_map);
}
}
@ -151,19 +149,19 @@ void GenerateValidTensorMap(const std::vector<int32_t>& device_arrangement, cons
}
void GenerateValidLayoutByDeviceSizeAndTensorSize(
int32_t device_pow_size, int32_t tensor_pow_size, int32_t max_device_dim,
int32_t max_shape_dim,
std::vector<std::tuple<std::vector<int32_t>, std::vector<int32_t>, std::vector<int32_t>>>* layout_list) {
int64_t device_pow_size, int64_t tensor_pow_size, int64_t max_device_dim,
int64_t max_shape_dim,
std::vector<std::tuple<DeviceArrangement, TensorMap, TensorShape>>* layout_list) {
layout_list->clear();
std::vector<std::vector<int32_t>> device_arrangement_list;
std::vector<DeviceArrangement> device_arrangement_list;
GenerateValidShapeBySize(device_pow_size, &device_arrangement_list);
std::vector<std::vector<int32_t>> tensor_shape_list;
std::vector<TensorShape> tensor_shape_list;
GenerateValidShapeBySize(tensor_pow_size, &tensor_shape_list);
for (uint32_t device_idx = 0; device_idx < device_arrangement_list.size(); device_idx++) {
for (uint32_t shape_idx = 0; shape_idx < tensor_shape_list.size(); shape_idx++) {
std::vector<std::vector<int32_t>> tensor_map_list;
for (size_t device_idx = 0; device_idx < device_arrangement_list.size(); device_idx++) {
for (size_t shape_idx = 0; shape_idx < tensor_shape_list.size(); shape_idx++) {
std::vector<TensorMap> tensor_map_list;
GenerateValidTensorMap(device_arrangement_list[device_idx], tensor_shape_list[shape_idx], &tensor_map_list);
for (uint32_t map_idx = 0; map_idx < tensor_map_list.size(); map_idx++) {
for (size_t map_idx = 0; map_idx < tensor_map_list.size(); map_idx++) {
if (!CheckLayoutValid(device_arrangement_list[device_idx], tensor_map_list[map_idx],
tensor_shape_list[shape_idx])) {
continue;
@ -176,8 +174,8 @@ void GenerateValidLayoutByDeviceSizeAndTensorSize(
return;
}
bool CheckLayoutValid(const std::vector<int32_t>& device_arrangement, const std::vector<int32_t>& tensor_map,
const std::vector<int32_t>& tensor_shape) {
bool CheckLayoutValid(const DeviceArrangement& device_arrangement, const TensorMap& tensor_map,
const TensorShape& tensor_shape) {
bool flag = false;
if ((tensor_map.size() - ComputeNoneNumber(tensor_map)) > device_arrangement.size()) {
return flag;
@ -188,9 +186,9 @@ bool CheckLayoutValid(const std::vector<int32_t>& device_arrangement, const std:
return true;
}
uint32_t ComputeNoneNumber(const std::vector<int32_t>& tensor_map) {
uint32_t num = 0;
for (uint32_t i = 0; i < tensor_map.size(); i++) {
size_t ComputeNoneNumber(const TensorMap& tensor_map) {
size_t num = 0;
for (size_t i = 0; i < tensor_map.size(); i++) {
if (tensor_map[i] == -1) {
num++;
}
@ -198,14 +196,14 @@ uint32_t ComputeNoneNumber(const std::vector<int32_t>& tensor_map) {
return num;
}
bool ShapeIsDividedByDevice(const std::vector<int32_t>& device_arrangement, const std::vector<int32_t>& tensor_map,
const std::vector<int32_t>& tensor_shape) {
bool ShapeIsDividedByDevice(const DeviceArrangement& device_arrangement, const TensorMap& tensor_map,
const TensorShape& tensor_shape) {
bool flag = false;
for (uint32_t i = 0; i < tensor_map.size() && i < tensor_shape.size(); i++) {
if (tensor_map[i] == -1) {
continue;
}
int32_t dim = device_arrangement[device_arrangement.size() - 1 - tensor_map[i]];
int64_t dim = device_arrangement[device_arrangement.size() - 1 - tensor_map[i]];
if (tensor_shape[i] % dim != 0) {
return flag;
}
@ -213,8 +211,8 @@ bool ShapeIsDividedByDevice(const std::vector<int32_t>& device_arrangement, cons
return true;
}
bool IsExpended(const std::vector<int32_t>& in1, const std::vector<int32_t>& in2) {
int32_t size = 1;
bool IsExpended(const Shape& in1, const Shape& in2) {
int64_t size = 1;
uint32_t ind = 0;
for (uint32_t i = 0; i < in1.size(); i++) {
size *= in1[i];
@ -236,9 +234,9 @@ bool IsExpended(const std::vector<int32_t>& in1, const std::vector<int32_t>& in2
return true;
}
void ComputeAccumDeviceTOAccumShapeMap(const std::vector<int32_t>& device_arrangement,
const std::vector<int32_t>& tensor_map, const std::vector<int32_t>& tensor_shape,
std::map<int32_t, int32_t>* accum_device_to_accum_shape_map) {
void ComputeAccumDeviceTOAccumShapeMap(const DeviceArrangement& device_arrangement,
const TensorMap& tensor_map, const TensorShape& tensor_shape,
std::map<int64_t, int64_t>* accum_device_to_accum_shape_map) {
accum_device_to_accum_shape_map->clear();
std::vector<int64_t> shape_accum_reverse;
Status status = ShapeToAccumulateProductReverse(tensor_shape, &shape_accum_reverse);
@ -258,42 +256,42 @@ void ComputeAccumDeviceTOAccumShapeMap(const std::vector<int32_t>& device_arrang
return;
}
void IsLinearValue(int32_t small, int32_t big, int32_t small_value, int32_t big_value, int32_t middle,
int32_t middle_value) {
void IsLinearValue(int64_t small, int64_t big, int64_t small_value, int64_t big_value, int64_t middle,
int64_t middle_value) {
ASSERT_NE(big, small);
int32_t value = (middle - small) * (big_value - small_value) / (big - small) + small_value;
int64_t value = (middle - small) * (big_value - small_value) / (big - small) + small_value;
ASSERT_EQ(middle_value, value);
}
void LayoutTransferValidLayoutChangeCheck(const std::vector<int32_t>& in_device_arrangement,
const std::vector<int32_t>& in_tensor_map,
const std::vector<int32_t>& in_tensor_shape,
const std::vector<int32_t>& out_device_arrangement,
const std::vector<int32_t>& out_tensor_map,
const std::vector<int32_t>& out_tensor_shape) {
void LayoutTransferValidLayoutChangeCheck(const DeviceArrangement& in_device_arrangement,
const TensorMap& in_tensor_map,
const TensorShape& in_tensor_shape,
const DeviceArrangement& out_device_arrangement,
const TensorMap& out_tensor_map,
const TensorShape& out_tensor_shape) {
bool is_expended = IsExpended(out_device_arrangement, in_device_arrangement);
ASSERT_EQ(true, is_expended);
is_expended = IsExpended(out_tensor_shape, in_tensor_shape);
ASSERT_EQ(true, is_expended);
std::map<int32_t, int32_t> out_accum_device_to_accum_shape_map;
std::map<int64_t, int64_t> out_accum_device_to_accum_shape_map;
ComputeAccumDeviceTOAccumShapeMap(out_device_arrangement, out_tensor_map, out_tensor_shape,
&out_accum_device_to_accum_shape_map);
std::map<int32_t, int32_t> in_accum_device_to_accum_shape_map;
std::map<int64_t, int64_t> in_accum_device_to_accum_shape_map;
ComputeAccumDeviceTOAccumShapeMap(in_device_arrangement, in_tensor_map, in_tensor_shape,
&in_accum_device_to_accum_shape_map);
std::map<int32_t, int32_t>::iterator in_iter = in_accum_device_to_accum_shape_map.begin();
std::map<int64_t, int64_t>::iterator in_iter = in_accum_device_to_accum_shape_map.begin();
while (in_iter != in_accum_device_to_accum_shape_map.end()) {
if (in_iter->second != out_accum_device_to_accum_shape_map[in_iter->first]) {
continue;
}
in_iter++;
}
std::map<int32_t, int32_t>::iterator out_iter = out_accum_device_to_accum_shape_map.begin();
std::map<int64_t, int64_t>::iterator out_iter = out_accum_device_to_accum_shape_map.begin();
while (out_iter != out_accum_device_to_accum_shape_map.end()) {
if (out_accum_device_to_accum_shape_map.find(out_iter->first) == out_accum_device_to_accum_shape_map.end()) {
in_iter = in_accum_device_to_accum_shape_map.begin();
int32_t small = 1;
int32_t big = 1;
int64_t small = 1;
int64_t big = 1;
while (in_iter != in_accum_device_to_accum_shape_map.end()) {
if (in_iter->first < out_iter->first) {
small = in_iter->second;
@ -311,18 +309,18 @@ void LayoutTransferValidLayoutChangeCheck(const std::vector<int32_t>& in_device_
if (big == 1) {
ASSERT_EQ(true, false);
}
int32_t small_value = in_accum_device_to_accum_shape_map[small];
int32_t big_value = in_accum_device_to_accum_shape_map[big];
int64_t small_value = in_accum_device_to_accum_shape_map[small];
int64_t big_value = in_accum_device_to_accum_shape_map[big];
IsLinearValue(small, big, small_value, big_value, out_iter->first, out_iter->second);
}
out_iter++;
}
}
void ValidLayoutChangeCheck(const std::vector<int32_t>& in_device_arrangement,
const std::vector<int32_t>& in_tensor_map, const std::vector<int32_t>& in_tensor_shape,
const std::vector<int32_t>& out_device_arrangement,
const std::vector<int32_t>& out_tensor_map, const std::vector<int32_t>& out_tensor_shape) {
void ValidLayoutChangeCheck(const DeviceArrangement& in_device_arrangement,
const TensorMap& in_tensor_map, const TensorShape& in_tensor_shape,
const DeviceArrangement& out_device_arrangement,
const TensorMap& out_tensor_map, const TensorShape& out_tensor_shape) {
LayoutTransferValidLayoutChangeCheck(in_device_arrangement, in_tensor_map, in_tensor_shape, out_device_arrangement,
out_tensor_map, out_tensor_shape);
}

57
tests/ut/cpp/parallel/tensor_layout/util_layout_gen_test.h
View File

@ -21,51 +21,50 @@
#include <vector>
#include "frontend/parallel/tensor_layout/tensor_layout.h"
#include "frontend/parallel/step_parallel.h"
namespace mindspore {
namespace parallel {
std::vector<std::vector<int32_t>> combine(const std::vector<int32_t>& in, int32_t target);
std::vector<Shape> combine(const Shape& in, int64_t target);
void GenerateValidShapeBySizeAndDim(int32_t pow_size, int32_t dim,
std::vector<std::vector<int32_t>>* out);
void GenerateValidShapeBySizeAndDim(int64_t pow_size, int64_t dim, std::vector<Shape>* out);
void GenerateValidShapeBySize(int32_t pow_size, std::vector<std::vector<int32_t>>* out);
void GenerateValidShapeBySize(int64_t pow_size, std::vector<Shape>* out);
std::vector<int32_t> GenerateTensorMap(const uint32_t& map_size, const std::vector<int32_t>& pos_index,
const std::vector<int32_t>& pos_value);
TensorMap GenerateTensorMap(const int64_t& map_size, const Shape& pos_index, const Shape& pos_value);
void GenerateValidTensorMap(const std::vector<int32_t>& device_arrangement, const std::vector<int32_t>& tensor_shape,
std::vector<std::vector<int32_t>>* tensor_map_list);
void GenerateValidTensorMap(const DeviceArrangement& device_arrangement, const TensorMap& tensor_shape,
std::vector<TensorMap>* tensor_map_list);
void GenerateValidLayoutByDeviceSizeAndTensorSize(
int32_t device_pow_size, int32_t tensor_pow_size, int32_t max_device_dim,
int32_t max_shape_dim,
std::vector<std::tuple<std::vector<int32_t>, std::vector<int32_t>, std::vector<int32_t>>>* layout_list);
int64_t device_pow_size, int64_t tensor_pow_size, int64_t max_device_dim,
int64_t max_shape_dim,
std::vector<std::tuple<DeviceArrangement, TensorMap, TensorShape>>* layout_list);
uint32_t ComputeNoneNumber(const std::vector<int32_t>& tensor_map);
size_t ComputeNoneNumber(const TensorMap& tensor_map);
bool ShapeIsDividedByDevice(const std::vector<int32_t>& device_arrangement, const std::vector<int32_t>& tensor_map,
const std::vector<int32_t>& tensor_shape);
bool ShapeIsDividedByDevice(const DeviceArrangement& device_arrangement, const TensorMap& tensor_map,
const TensorShape& tensor_shape);
bool CheckLayoutValid(const std::vector<int32_t>& device_arrangement, const std::vector<int32_t>& tensor_map,
const std::vector<int32_t>& tensor_shape);
bool CheckLayoutValid(const DeviceArrangement& device_arrangement, const TensorMap& tensor_map,
const TensorShape& tensor_shape);
void ComputeAccumDeviceTOAccumShapeMap(const std::vector<int32_t>& device_arrangement,
const std::vector<int32_t>& tensor_map, const std::vector<int32_t>& tensor_shape,
std::map<int32_t, int32_t>* accum_device_to_accum_shape_map);
void ComputeAccumDeviceTOAccumShapeMap(const DeviceArrangement& device_arrangement,
const TensorMap& tensor_map, const TensorShape& tensor_shape,
std::map<int64_t, int64_t>* accum_device_to_accum_shape_map);
void LayoutTransferValidLayoutChangeCheck(const std::vector<int32_t>& in_device_arrangement,
const std::vector<int32_t>& in_tensor_map,
const std::vector<int32_t>& in_tensor_shape,
const std::vector<int32_t>& out_device_arrangement,
const std::vector<int32_t>& out_tensor_map,
const std::vector<int32_t>& out_tensor_shape);
void LayoutTransferValidLayoutChangeCheck(const DeviceArrangement& in_device_arrangement,
const TensorMap& in_tensor_map,
const TensorShape& in_tensor_shape,
const DeviceArrangement& out_device_arrangement,
const TensorMap& out_tensor_map,
const TensorShape& out_tensor_shape);
void ValidLayoutChangeCheck(const std::vector<int32_t>& in_device_arrangement,
const std::vector<int32_t>& in_tensor_map, const std::vector<int32_t>& in_tensor_shape,
const std::vector<int32_t>& out_device_arrangement,
const std::vector<int32_t>& out_tensor_map, const std::vector<int32_t>& out_tensor_shape);
void ValidLayoutChangeCheck(const DeviceArrangement& in_device_arrangement,
const TensorMap& in_tensor_map, const TensorShape& in_tensor_shape,
const DeviceArrangement& out_device_arrangement,
const TensorMap& out_tensor_map, const TensorShape& out_tensor_shape);
} // namespace parallel
} // namespace mindspore

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

@ -37,13 +37,13 @@ class TestVirtualDatasetInfo : public UT::Common {
};
void TestVirtualDatasetInfo::SetUp() {
std::vector<int32_t> dev_list;
RankList dev_list;
for (int32_t i = 0; i < 130; i++) {
dev_list.push_back(i);
}
std::vector<int32_t> stage_map;
RankList stage_map;
stage_map.push_back(16);
stage_map.push_back(114);
@ -62,27 +62,27 @@ void TestVirtualDatasetInfo::SetUp() {
}
TEST_F(TestVirtualDatasetInfo, InferDevMatrixShape1) {
std::vector<Dimensions> inputs = {{16, 1}, {16, 1}, {16, 1}};
Strategys inputs = {{16, 1}, {16, 1}, {16, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
virtual_dataset->Init(strategy);
std::vector<int32_t> dev_matrix_shape = virtual_dataset->dev_matrix_shape();
Shape dev_matrix_shape = virtual_dataset->dev_matrix_shape();
std::vector<int32_t> expect = {16};
Shape expect = {16};
ASSERT_EQ(dev_matrix_shape, expect);
}
TEST_F(TestVirtualDatasetInfo, InferDevMatrixShape2) {
std::vector<Dimensions> inputs = {{8, 1}, {8, 1}, {8, 1}};
Strategys inputs = {{8, 1}, {8, 1}, {8, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
virtual_dataset->Init(strategy);
std::vector<int32_t> dev_matrix_shape = virtual_dataset->dev_matrix_shape();
Shape dev_matrix_shape = virtual_dataset->dev_matrix_shape();
std::vector<int32_t> expect = {8, 2};
Shape expect = {8, 2};
ASSERT_EQ(dev_matrix_shape, expect);
}
TEST_F(TestVirtualDatasetInfo, InferSliceShape1) {
std::vector<Dimensions> str = {{8, 1}, {8, 1}, {8, 1}};
Strategys str = {{8, 1}, {8, 1}, {8, 1}};
StrategyPtr strategy = NewStrategy(0, str);
virtual_dataset->Init(strategy);
@ -127,7 +127,7 @@ TEST_F(TestVirtualDatasetInfo, InferSliceShape1) {
}
TEST_F(TestVirtualDatasetInfo, GetTensorLayout1) {
std::vector<Dimensions> str = {{8, 1}, {8, 1}, {8, 1}};
Strategys str = {{8, 1}, {8, 1}, {8, 1}};
StrategyPtr strategy = NewStrategy(0, str);
virtual_dataset->Init(strategy);
@ -148,7 +148,7 @@ TEST_F(TestVirtualDatasetInfo, GetTensorLayout1) {
}
TEST_F(TestVirtualDatasetInfo, GetForwardOp1) {
std::vector<Dimensions> inputs = {{8, 1}, {8, 1}, {8, 1}};
Strategys inputs = {{8, 1}, {8, 1}, {8, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
virtual_dataset->Init(strategy);
@ -159,7 +159,7 @@ TEST_F(TestVirtualDatasetInfo, GetForwardOp1) {
}
TEST_F(TestVirtualDatasetInfo, GetMirrorOPs1) {
std::vector<Dimensions> inputs = {{8, 1}, {8, 1}, {8, 1}};
Strategys inputs = {{8, 1}, {8, 1}, {8, 1}};
StrategyPtr strategy = NewStrategy(0, inputs);
virtual_dataset->Init(strategy);