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

Optimize the compile performance in Parser, FG, Manager and Renormalize: 

---
Remove the routine of handling isolated nodes in Renormalize.
Add isolated nodes from Parser&Resolver.
Modify isolated nodes handling in FG&Manager.
Optimize the renormalize routines.
Other optimizations.
This commit is contained in:
Zhang Qinghua 2021-02-25 14:52:44 +08:00
parent 609a518068
commit 8b8c59f01e
37 changed files with 460 additions and 956 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
mindspore/ccsrc/debug/anf_ir_utils.cc
View File

@ -1,5 +1,5 @@
/**
* Copyright 2019-2020 Huawei Technologies Co., Ltd
* Copyright 2019-2021 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -610,24 +610,7 @@ void AnfExporter::OutputOrderList(std::ofstream &ofs, const FuncGraphPtr &func_g
constexpr int width = 4;
ofs << "# order:\n";
int i = 1;
auto &isolate_nodes = func_graph->isolate_nodes();
for (auto &node : order_list) {
bool is_isolate = (isolate_nodes.find(node) != isolate_nodes.end());
const std::string isolate_str = (is_isolate ? " # isolate" : "");
ofs << '#' << std::setw(width) << i << ": " << node->DebugString() << isolate_str << '\n';
++i;
}
}
void AnfExporter::OutputIsolateNodes(std::ofstream &ofs, const FuncGraphPtr &func_graph) {
auto &isolate_nodes = func_graph->isolate_nodes();
if (isolate_nodes.empty()) {
return;
}
constexpr int width = 4;
ofs << "# isolate nodes:\n";
int i = 1;
for (auto &node : isolate_nodes) {
ofs << '#' << std::setw(width) << i << ": " << node->DebugString() << '\n';
++i;
}
@ -670,7 +653,6 @@ void AnfExporter::ExportOneFuncGraph(std::ofstream &ofs, const FuncGraphPtr &fun
ofs << "}\n";
OutputOrderList(ofs, func_graph);
OutputIsolateNodes(ofs, func_graph);
}
void AnfExporter::ExportFuncGraph(const std::string &filename, const FuncGraphPtr &func_graph) {

3
mindspore/ccsrc/debug/anf_ir_utils.h
View File

@ -1,5 +1,5 @@
/**
* Copyright 2019 Huawei Technologies Co., Ltd
* Copyright 2019-2021 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -98,7 +98,6 @@ class AnfExporter {
void OutputStatementComment(std::ofstream &ofs, const CNodePtr &node);
virtual void OutputCNodes(std::ofstream &ofs, const std::vector<AnfNodePtr> &nodes, const FuncGraphPtr &func_graph);
void OutputOrderList(std::ofstream &ofs, const FuncGraphPtr &func_graph);
void OutputIsolateNodes(std::ofstream &ofs, const FuncGraphPtr &func_graph);
int param_index;
OrderedSet<FuncGraphPtr> func_graph_set{};

18
mindspore/ccsrc/debug/trace.cc
View File

@ -1,5 +1,5 @@
/**
* Copyright 2019-2020 Huawei Technologies Co., Ltd
* Copyright 2019-2021 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -36,7 +36,7 @@
#include "utils/log_adapter.h"
namespace mindspore {
// namespace to support debug trace infomation
// namespace to support debug trace information
namespace trace {
using abstract::AbstractBasePtr;
using abstract::AnalysisContextPtr;
@ -167,7 +167,7 @@ std::string AnalyzedFuncGraphExporter::GetNodeType(const AnfNodePtr &node) {
MS_EXCEPTION_IF_NULL(engine_);
auto cfg = engine_->MakeConfig(node, cur_ctx_);
auto ret = engine_->cache().GetValue(cfg);
auto ret = engine_->analysis_cache().GetValue(cfg);
if (ret == nullptr) {
return "Undefined";
}
@ -180,7 +180,7 @@ AbstractBasePtr AnalyzedFuncGraphExporter::GetNodeAbstract(const AnfNodePtr &nod
}
MS_EXCEPTION_IF_NULL(engine_);
auto cfg = engine_->MakeConfig(node, cur_ctx_);
auto ret = engine_->cache().GetValue(cfg);
auto ret = engine_->analysis_cache().GetValue(cfg);
return ret == nullptr ? nullptr : ret->abstract();
}
@ -439,7 +439,7 @@ void AnalyzedFuncGraphExporter::ExportFuncGraph(const std::string &filename,
param_index = 1;
auto tagged_func_graphs = CalcTaggedFuncGraphs();
// first output graph on the analysis stack
// 1. Output graph on the analysis stack
for (const auto &node_cfg : node_cfgs) {
auto ctx = node_cfg->context();
if (engine_ == nullptr) {
@ -448,7 +448,7 @@ void AnalyzedFuncGraphExporter::ExportFuncGraph(const std::string &filename,
if (context_map_.insert({ctx, false}).second) {
context_vec_.push_back(ctx);
}
// the graph has already been printed
// If the graph has already been printed
if (context_map_[ctx]) {
continue;
}
@ -456,7 +456,7 @@ void AnalyzedFuncGraphExporter::ExportFuncGraph(const std::string &filename,
auto fg = ctx->func_graph();
// set current context
// Set current context
cur_ctx_ = ctx;
tagged_cnodes_ = tagged_func_graphs[fg];
ExportOneFuncGraph(ofs, fg);
@ -465,10 +465,10 @@ void AnalyzedFuncGraphExporter::ExportFuncGraph(const std::string &filename,
tagged_cnodes_.clear();
// print seperator between function graphs on analyzed graph call stack and others
// Print separator between function graphs on analyzed graph call stack and others
ofs << "#===============================================================================\n\n\n";
// second output other graphs
// 2. Output other graphs
size_t ctx_idx = 0;
while (ctx_idx < context_vec_.size()) {
auto ctx = context_vec_[ctx_idx++];

35
mindspore/ccsrc/frontend/optimizer/opt.cc
View File

@ -1,5 +1,5 @@
/**
* Copyright 2019 Huawei Technologies Co., Ltd
* Copyright 2019-2021 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -238,27 +238,6 @@ bool SubstitutionList::ApplySubstitutionToIR(const OptimizerPtr &optimizer, cons
return changes;
}
bool SubstitutionList::ApplySubstitutionsToIRForIsolate(const OptimizerPtr &optimizer) const {
const auto &manager = optimizer->manager();
const auto &nodes = manager->isolate_nodes();
bool changes = false;
bool loop = true;
while (loop) {
loop = false;
std::for_each(list_.cbegin(), list_.cend(), [&](const auto &substitution) {
std::for_each(nodes.cbegin(), nodes.cend(), [&](const auto &node) {
bool change = ApplySubstitutionToIR(optimizer, node, substitution);
changes = changes || change;
loop = loop || change;
});
});
if (is_once_) {
break;
}
}
return changes;
}
bool SubstitutionList::ApplySubstitutionsToIR(const OptimizerPtr &optimizer, const FuncGraphPtr &func_graph) const {
// Add for substitution status counting
size_t space = 0;
@ -336,18 +315,6 @@ bool SubstitutionList::operator()(const FuncGraphPtr &func_graph, const Optimize
} else {
changes = ApplySubstitutionsToIR(optimizer, func_graph);
}
bool has_isolate = !manager->isolate_nodes().empty();
if (has_isolate) {
#ifdef ENABLE_PROFILE
double t = GetTime();
#endif
bool change = ApplySubstitutionsToIRForIsolate(optimizer);
changes = changes || change;
#ifdef ENABLE_PROFILE
MsProfile::StatTime("opt.isolate.transform." + optimizer->name(), GetTime() - t);
#endif
}
return changes;
}
} // namespace opt

4
mindspore/ccsrc/frontend/optimizer/opt.h
View File

@ -1,5 +1,5 @@
/**
* Copyright 2019 Huawei Technologies Co., Ltd
* Copyright 2019-2021 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -73,7 +73,7 @@ class SubstitutionList {
bool ApplyIRToSubstitutions(const OptimizerPtr &optimizer, const FuncGraphPtr &func_graph) const;
bool ApplySubstitutionToIR(const OptimizerPtr &optimizer, const AnfNodePtr &node, const SubstitutionPtr &sub) const;
bool ApplySubstitutionsToIR(const OptimizerPtr &optimizer, const FuncGraphPtr &func_graph) const;
bool ApplySubstitutionsToIRForIsolate(const OptimizerPtr &optimizer) const;
std::vector<SubstitutionPtr> list_;
// a flag to mark this list of Substitution can only be executed only once
bool is_once_;

4
mindspore/ccsrc/pipeline/jit/action.cc
View File

@ -1,5 +1,5 @@
/**
* Copyright 2019 Huawei Technologies Co., Ltd
* Copyright 2019-2021 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -163,7 +163,7 @@ bool CombineLikeGraphs(const ResourcePtr &res) {
auto &graphs = it.second;
MS_LOG(DEBUG) << "Start combine like graph:" << it.first << ", size:" << graphs.size();
auto fg = graphs[0];
FuncGraphPtrList func_graphs = {fg};
FuncGraphVector func_graphs = {fg};
ClonerPtr cloner = std::make_shared<Cloner>(func_graphs, false, false, true, std::make_shared<TraceCopy>(),
std::make_shared<TraceCombileLikeGraphs>());
cloner->Run();

92
mindspore/ccsrc/pipeline/jit/parse/function_block.cc
View File

@ -1,7 +1,7 @@
/**
* This is the C++ adaptation and derivative work of Myia (https://github.com/mila-iqia/myia/).
*
* Copyright 2019 Huawei Technologies Co., Ltd
* Copyright 2019-2021 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -37,7 +37,7 @@ FunctionBlock::FunctionBlock(const Parser &parser) : parser_(parser) {
void FunctionBlock::AddPrevBlock(const FunctionBlockPtr &block) { prev_blocks_.push_back(block.get()); }
static bool CanBeIsolateNode(const std::string &var_name, const AnfNodePtr &node) {
static bool CanBeIsolatedNode(const std::string &var_name, const AnfNodePtr &node) {
auto cnode = dyn_cast<CNode>(node);
if (cnode == nullptr || cnode->inputs().empty()) {
// Not a valid cnode, can not be isolate node.
@ -46,7 +46,7 @@ static bool CanBeIsolateNode(const std::string &var_name, const AnfNodePtr &node
auto prim = GetValueNode<PrimitivePtr>(cnode->inputs().at(0));
if (prim == nullptr) {
// Not a primitive cnode, it may have side effects or not,
// we add it as an isolate node if its name is not '_' or empty.
// We add it as an isolate node if its name is not '_' or empty.
// this means that code like:
// _ = func_call()
// will be ignored even if func_call() has side effects.
@ -58,7 +58,7 @@ static bool CanBeIsolateNode(const std::string &var_name, const AnfNodePtr &node
return has_effects;
}
// write variable records the variable name to corresponding node
// Write variable records the variable name to corresponding node
void FunctionBlock::WriteVariable(const std::string &var_name, const AnfNodePtr &node) {
MS_LOG(DEBUG) << func_graph_->ToString() << " write var " << var_name << " with node " << node->DebugString();
auto [iter, is_new_name] = vars_.emplace(var_name, std::make_pair(node, false));
@ -67,18 +67,24 @@ void FunctionBlock::WriteVariable(const std::string &var_name, const AnfNodePtr
// add it as an isolate node. for example:
// a = print(x)
// a = print(y)
// when we write variable 'a = print(y)',
// When we write variable 'a = print(y)',
// the cnode 'print(x)' should added as an isolate node.
if (!iter->second.second && CanBeIsolateNode(var_name, iter->second.first)) {
func_graph_->AddIsolateNode(iter->second.first);
auto is_used = iter->second.second;
auto hidden_node = iter->second.first;
auto is_isolated = CanBeIsolatedNode(var_name, hidden_node);
MS_LOG(INFO) << "Isolated node found(Hidden), hidden_node: " << hidden_node->DebugString(2) << " is hidden by "
<< node->DebugString(2) << " with the same name, var_name: " << var_name
<< ", is_isolated: " << is_isolated << ", !is_used: " << !is_used;
if (!is_used && is_isolated) {
AddIsolatedNode(hidden_node);
}
iter->second = std::make_pair(node, false);
}
}
// read variable from predecessors
// Read variable from predecessors
AnfNodePtr FunctionBlock::ReadVariable(const std::string &var) {
// get var node if it is found
// Get var node if it is found
auto found = vars_.find(var);
if (found != vars_.end()) {
auto &node = found->second.first;
@ -91,7 +97,7 @@ AnfNodePtr FunctionBlock::ReadVariable(const std::string &var) {
}
return node;
}
// get var from predecessor block ,if can't get the make a resolve node to it
// Get var from predecessor block ,if can't get the make a resolve node to it
if (matured_) {
// If only one predecessor block, read the definition of var from it.
if (prev_blocks_.size() == 1) {
@ -99,7 +105,7 @@ AnfNodePtr FunctionBlock::ReadVariable(const std::string &var) {
MS_EXCEPTION_IF_NULL(block);
return block->ReadVariable(var);
} else if (prev_blocks_.empty()) {
// get namespace and make Resolve
// Get namespace and make Resolve
auto it = var_to_resolve_.find(var);
if (it != var_to_resolve_.end()) {
return it->second;
@ -181,7 +187,7 @@ AnfNodePtr FunctionBlock::MakeResolve(const NameSpacePtr &name_space, const Symb
return node;
}
// add input for the block's phi parameter
// Add input for the block's phi parameter
void FunctionBlock::SetPhiArgument(const ParameterPtr &phi) {
std::string var = phi_nodes_[phi];
MS_LOG(DEBUG) << "graph " << func_graph_->ToString() << " set phi " << phi->ToString() << " for var " << var;
@ -227,7 +233,7 @@ AnfNodePtr FunctionBlock::SearchReplaceNode(const std::string &var, const Parame
}
// Check if there is removable unnecessary phi node in this graph.
// as per the FIRM TR 3.2, a phi node can be remove if:
// As per the FIRM TR 3.2, a phi node can be remove if:
// <Quote>
// If all arguments of a φ-function are the same value s or the φfunction itself,
// then we remove the φ-function and let all users directly uses. We call such a
@ -255,7 +261,7 @@ bool FunctionBlock::CollectRemovablePhi(const ParameterPtr &phi) {
if (arg_node != nullptr) {
MS_LOG(DEBUG) << "graph " << func_graph_->ToString() << " phi " << phi->ToString() << " can be replaced with "
<< arg_node->DebugString();
// replace var with new one. This equal to statement in TR "v0 is immediately replaced by v1."
// Replace var with new one. This equal to statement in TR "v0 is immediately replaced by v1."
WriteVariable(var, arg_node);
removable_phis_[phi] = arg_node;
resolve_to_removable_phis_[arg_node] = phi;
@ -326,6 +332,8 @@ void FunctionBlock::Jump(const FunctionBlockPtr &target_block, AnfNodePtr node)
jumps_[target_block.get()] = jump;
target_block->AddPrevBlock(shared_from_this());
func_graph()->set_output(jump);
// Attach all isolated nodes.
AttachIsolatedNodesBeforeReturn();
}
// Perform a conditional jump using switch operation.
@ -341,6 +349,8 @@ void FunctionBlock::ConditionalJump(AnfNodePtr condNode, const FunctionBlockPtr
NewValueNode(false_block->func_graph())});
CNodePtr switch_app_new = func_graph()->NewCNodeInOrder({switch_app});
func_graph()->set_output(switch_app_new);
// Attach all isolated nodes.
AttachIsolatedNodesBeforeReturn();
}
// Create cnode for the assign statement like 'self.target = source'.
@ -349,11 +359,12 @@ void FunctionBlock::SetStateAssign(const AnfNodePtr &target, const AnfNodePtr &s
const std::string primitive_name("assign");
const std::string module_name("mindspore.ops.functional");
ValueNodePtr assign_op = NewValueNode(prim::GetPythonOps(primitive_name, module_name, true));
auto assign = func_graph_->NewCNodeInOrder({assign_op, target, source});
func_graph_->AddIsolateNode(assign);
auto assign_node = func_graph_->NewCNodeInOrder({assign_op, target, source});
MS_LOG(DEBUG) << "Isolated node found(Assign), assign_node: " << assign_node->DebugString(2);
AddIsolatedNode(assign_node);
}
void FunctionBlock::FindIsolateVariables() {
void FunctionBlock::FindIsolatedNodes() {
//
// Search isolate nodes from variables, for example,
// variable 'a' is an isolate node in below code:
@ -374,7 +385,7 @@ void FunctionBlock::FindIsolateVariables() {
used.emplace(node);
}
}
// Add isolate nodes which is unused var but not found in used set.
// Add isolated nodes which is unused var but not found in used set.
for (const auto &var : vars_) {
auto &node = var.second.first;
bool is_used = var.second.second;
@ -382,11 +393,52 @@ void FunctionBlock::FindIsolateVariables() {
continue;
}
auto &var_name = var.first;
if (used.find(node) == used.end() && CanBeIsolateNode(var_name, node)) {
func_graph_->AddIsolateNode(node);
if (used.find(node) == used.end() && CanBeIsolatedNode(var_name, node)) {
// We don't call AddIsolatedNode(node) anymore.
// If need, to call FindIsolatedNodes() in appropriate place.
MS_LOG(ERROR) << "Isolated node found(NoUse), node: " << node->DebugString(2) << ", var_name: " << var_name;
}
}
}
void FunctionBlock::AddIsolatedNode(const AnfNodePtr &target) { isolated_nodes_.add(target); }
void FunctionBlock::AttachIsolatedNodesBeforeReturn() {
if (isolated_nodes_.size() == 0) {
return;
}
std::vector<AnfNodePtr> states;
states.emplace_back(NewValueNode(prim::kPrimMakeTuple));
for (auto &node : isolated_nodes_) {
MS_LOG(DEBUG) << "Adding dependency, node: " << node->DebugString(2) << " in " << func_graph()->ToString();
states.emplace_back(node);
}
AnfNodePtr state = nullptr;
// If there are only make_tuple and another node in states(the states size is 2),
// do not need to make_tuple, just use the node.
if (states.size() == 2) {
state = states[1];
} else {
state = func_graph()->NewCNode(states);
}
AnfNodePtr old_output = nullptr;
auto return_node = func_graph()->get_return();
if (return_node) {
if (return_node->inputs().size() < 1) {
MS_LOG(EXCEPTION) << "Length of inputs of output node is less than 2";
}
old_output = return_node->input(1);
} else {
old_output = NewValueNode(kNone);
}
AnfNodePtr stop_grad_node = func_graph()->NewCNode({NewValueNode(prim::kPrimStopGradient), state});
AnfNodePtr depend_node = func_graph()->NewCNode({NewValueNode(prim::kPrimDepend), old_output, stop_grad_node});
MS_LOG(INFO) << "Attached for side-effect nodes, depend_node: " << depend_node->DebugString()
<< ", state: " << state->DebugString(2);
func_graph()->set_output(depend_node, true);
}
} // namespace parse
} // namespace mindspore

35
mindspore/ccsrc/pipeline/jit/parse/function_block.h
View File

@ -1,7 +1,7 @@
/**
* This is the C++ adaptation and derivative work of Myia (https://github.com/mila-iqia/myia/).
*
* Copyright 2019 Huawei Technologies Co., Ltd
* Copyright 2019-2021 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -28,7 +28,7 @@
#include <utility>
#include "pipeline/jit/parse/parse_base.h"
#include "utils/log_adapter.h"
#include "utils/ordered_map.h"
#include "utils/ordered_set.h"
namespace mindspore {
namespace parse {
@ -71,46 +71,51 @@ class FunctionBlock : public std::enable_shared_from_this<FunctionBlock> {
AnfNodePtr MakeResolveOperation(const std::string &value);
AnfNodePtr MakeResolve(const std::shared_ptr<NameSpace> &name_space, const std::shared_ptr<Symbol> &resolve_symbol);
const std::unordered_map<ParameterPtr, AnfNodePtr> &removable_phis() const { return removable_phis_; }
void FindIsolateVariables();
void FindIsolatedNodes();
void AddIsolatedNode(const AnfNodePtr &target);
void AttachIsolatedNodesBeforeReturn();
private:
// block graph
// Block graph
FuncGraphPtr func_graph_;
// the block's parser
// Block parser
const Parser &parser_;
// A block is matured if all its prev_blocks is processed
bool matured_;
// store the nest-level block
// refer to comments in Parser::func_block_list_;
// Store the nest-level block.
// Refer to comments in Parser::func_block_list_;
std::vector<FunctionBlock *> prev_blocks_;
// store args and variable's node, use a bool flag to indicate if the variable is used.
// Store args and variable's node, use a bool flag to indicate if the variable is used.
std::map<std::string, std::pair<AnfNodePtr, bool>> vars_;
// phi_nodes map the parameter node to variable, it can be resolved if the block's predecessors are processed
// Map the parameter node to variable, it can be resolved if the block's predecessors are processed
std::map<ParameterPtr, std::string> phi_nodes_;
// jumps map the successor block and the function call that perform jump
// refer to comments in Parser::func_block_list_ that how to break the cyclic reference
// Jumps map the successor block and the function call that perform jump
// Refer to comments in Parser::func_block_list_ that how to break the cyclic reference
std::map<FunctionBlock *, CNodePtr> jumps_;
// keeps all removable phis which will be removed in one pass.
// Keep all removable phis which will be removed in one pass.
std::unordered_map<ParameterPtr, AnfNodePtr> removable_phis_;
// Keeps the map for the resolve node to the removable phi node.
// Keep the map for the resolve node to the removable phi node.
// For the case that ReadVariable returns a phi node although this phi node
// generated in the prev block is identified as removable. The other blocks
// should find this phi node.
std::unordered_map<AnfNodePtr, ParameterPtr> resolve_to_removable_phis_;
// hold declared global variables in function
// Hold declared global variables in function
std::set<std::string> global_vars_;
// keeps the new made resolve symbol for the variable not found in vars_.
// Keep new made resolve symbol for the variable not found in vars_.
std::unordered_map<std::string, AnfNodePtr> var_to_resolve_;
// Isolated nodes.
OrderedSet<AnfNodePtr> isolated_nodes_;
};
} // namespace parse

242
mindspore/ccsrc/pipeline/jit/parse/parse.cc
View File

@ -1,7 +1,7 @@
/**
* This is the C++ adaptation and derivative work of Myia (https://github.com/mila-iqia/myia/).
*
* Copyright 2019 Huawei Technologies Co., Ltd
* Copyright 2019-2021 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -70,7 +70,7 @@ TypePtr GetMixedPrecisionTargetType(const FuncGraphPtr &func_graph) {
}
}
// if any mixed precision flag add a cast node after the parameter node.
// If any mixed precision flag add a cast node after the parameter node.
AnfNodePtr GetMixedPrecisionCastHelp(const FuncGraphPtr &func_graph, const AnfNodePtr &param) {
TypePtr dst_type;
if (func_graph->has_flag(GRAPH_FLAG_MIX_PRECISION_FP32)) {
@ -145,16 +145,16 @@ void Parser::CleanParserResource() {
AnfNodePtr AppendParameterObj(const FuncGraphPtr &func_graph, const py::object &obj) {
MS_EXCEPTION_IF_NULL(func_graph);
auto value = py::cast<tensor::MetaTensorPtr>(obj);
// parameter object should not be none
// Parameter object should not be none
if (value == nullptr || !value->is_parameter()) {
MS_LOG(EXCEPTION) << "Parameter error: because obj is not Parameter object.";
}
// get the parameter name from parameter object
// Get the parameter name from parameter object
auto param_name = value->param_info()->name();
auto top_graph = func_graph;
// if the parameter node has been created , return it
// If the parameter node has been created , return it
AnfNodePtr para_node = nullptr;
for (auto param : top_graph->parameters()) {
auto param_node = dyn_cast<Parameter>(param);
@ -169,7 +169,7 @@ AnfNodePtr AppendParameterObj(const FuncGraphPtr &func_graph, const py::object &
node->set_default_param(value);
// set_abstract for parameter
auto abs = value->ToAbstract();
// boarden value
// Boarden value
abs = abs->Broaden();
node->set_abstract(abs);
para_node = node;
@ -185,7 +185,7 @@ void UpdataParam(const FuncGraphPtr &top_graph, const py::object &cell) {
}
void CheckFuncReturn(const FuncGraphPtr &fn, const std::shared_ptr<ParseAst> &ast) {
// check whether the functions referred by this function and itself are missing 'return' statement
// Check whether the functions referred by this function and itself are missing 'return' statement
auto mng = Manage(fn, false);
for (auto func_graph : mng->func_graphs()) {
if (func_graph->get_return() != nullptr) {
@ -197,14 +197,14 @@ void CheckFuncReturn(const FuncGraphPtr &fn, const std::shared_ptr<ParseAst> &as
python_adapter::CallPyModFn(ast->module(), PYTHON_MOD_GET_OBJECT_DESCRIPTION, ast->function(), ret[0], ret[1]);
MS_EXCEPTION(TypeError) << "Missing return statement in " << desc.cast<std::string>() << ".";
}
// clear manager info after checking missing return
// Clear manager info after checking missing return
for (auto fg : mng->func_graphs()) {
fg->ClearAllManagerInfo();
}
}
FuncGraphPtr Parser::ParseFuncGraph() {
// get ast FunctionDef node
// Get ast FunctionDef node
py::object node = ast_->GetAstNode();
FunctionBlockPtr pFnBlock = ParseFunction(node);
if (errcode() != PARSE_SUCCESS) {
@ -214,7 +214,8 @@ FuncGraphPtr Parser::ParseFuncGraph() {
// Add unused variables as isolate nodes.
for (auto &block : func_block_list_) {
block->FindIsolateVariables();
// Find unused variables.
block->FindIsolatedNodes();
}
RemoveUnnecessaryPhis();
@ -294,7 +295,7 @@ ScopePtr Parser::GetScopeForParseFunction() {
FunctionBlockPtr Parser::ParseFunction(const py::object &node, const FunctionBlockPtr &block) {
ScopePtr scope = GetScopeForParseFunction();
// the node created in the parsefunction context, will inherit the scope created using scope_guard
// The node created in the parsefunction context, will inherit the scope created using scope_guard
ScopeGuard scope_guard(scope);
TraceGuard trace_guard(data_converter::GetObjKey(ast()->obj())[0], GetLocation(node));
FunctionBlockPtr pFunBlock = MakeFunctionBlock(*this);
@ -326,12 +327,12 @@ FunctionBlockPtr Parser::ParseFunction(const py::object &node, const FunctionBlo
}
GenerateArgsNodeForFunction(pFunBlock, node);
// when parsing the top graph of construct, save the top graph
// When parsing the top graph of construct, save the top graph
if (GetTopFuncGraph() == nullptr) {
UpdateTopFuncGraph(pFunBlock->func_graph());
}
// save the function node to block
// Save the function node to block
pFunBlock->WriteVariable(function_name, NewValueNode(current_fg));
py::object funcObj = python_adapter::GetPyObjAttr(node, "body");
@ -346,33 +347,35 @@ FunctionBlockPtr Parser::ParseFunction(const py::object &node, const FunctionBlo
return pFunBlock;
}
FunctionBlockPtr Parser::ParseStatements(FunctionBlockPtr fn_block, const py::object &nodes) {
FunctionBlockPtr Parser::ParseStatements(FunctionBlockPtr block, const py::object &nodes) {
auto node_list = py::cast<py::list>(nodes);
size_t count = py::len(node_list);
MS_LOG(DEBUG) << "The nodes count is " << count;
for (size_t i = 0; i < count; ++i) {
auto node = node_list[i];
fn_block = ParseStatement(fn_block, node);
// insert appropriate depended items for the function block if it has a return node
if (fn_block->func_graph()->get_return() != nullptr) {
block = ParseStatement(block, node);
// Insert appropriate depended items for the function block if it has a return node
if (block->func_graph()->get_return() != nullptr) {
// Attach all isolated nodes.
block->AttachIsolatedNodesBeforeReturn();
// Skip statements after 'return' (or 'break', 'continue').
break;
}
}
return fn_block;
return block;
}
FunctionBlockPtr Parser::ParseStatement(const FunctionBlockPtr &block, const py::object &node) {
TraceGuard trace_guard(GetLocation(node));
auto node_type = ast_->GetNodeType(node);
// check the node type
// Check the node type
AstMainType nodeType = node_type->main_type();
if (nodeType != AST_MAIN_TYPE_STMT) {
MS_LOG(INFO) << "Node type is error : " << nodeType;
return block;
}
// call the process function
// Call the process function
std::string node_name = node_type->node_name();
MS_LOG(DEBUG) << "Ast node is " << node_name;
if (stmt_method_map_.count(node_name)) {
@ -389,14 +392,14 @@ AnfNodePtr Parser::ParseExprNode(const FunctionBlockPtr &block, const py::object
MS_LOG(DEBUG) << "Process ast expr";
TraceGuard trace_guard(GetLocation(node));
auto node_type = ast_->GetNodeType(node);
// check the node type
// Check the node type
AstMainType node_main_type = node_type->main_type();
if (node_main_type != AST_MAIN_TYPE_EXPR) {
MS_LOG(ERROR) << "Node type is error : " << node_main_type;
errcode_ = PARSE_NODE_TYPE_NO_MATCH;
return nullptr;
}
// call the process function
// Call the process function
std::string node_name = node_type->node_name();
MS_LOG(DEBUG) << "Ast node is " << node_name;
if (expr_method_map_.count(node_name)) {
@ -409,34 +412,37 @@ AnfNodePtr Parser::ParseExprNode(const FunctionBlockPtr &block, const py::object
}
}
// process the expr statement and expand it
// Process the expr statement and expand it
FunctionBlockPtr Parser::ParseExpr(const FunctionBlockPtr &block, const py::object &node) {
MS_LOG(DEBUG) << "Process ast Expr";
// Expr only have value , no target
// Expr only have value, no target
py::tuple expand_info = ast_->CallParserObjMethod(PYTHON_PARSE_EXPAND_EXPR_STATEMENT, node);
// refer python function expand_expr_statement, expand_info is one of the following:
// Refer python function expand_expr_statement, expand_info is one of the following:
// True, expr.value, x
// True, expr.value
// False, None, None
// check the expand info result
//
// Check the expand info result
auto is_expand = py::cast<bool>(expand_info[0]);
if (is_expand) {
// process the expr statement
// Process the expr statement
py::object value_object = expand_info[1];
AnfNodePtr value_node = ParseExprNode(block, value_object);
// Make a Expr CNode.
AnfNodePtr call_node = ParseExprNode(block, value_object);
if (py::len(expand_info) == 2) {
// expression that not assigned to any variable,
// this is usually a call with side effects,
// Expression that not assigned to any variable.
// This is usually a call with side effects.
// e.g.: print(x)
// we save it as an isolate node.
value_node->func_graph()->AddIsolateNode(value_node);
// We save it as an isolated node.
auto &no_return_node = call_node;
MS_LOG(INFO) << "Isolated node found(NoReturn), no_return_node: " << no_return_node->DebugString(2);
block->AddIsolatedNode(no_return_node);
} else {
// expand the assign statement,
// Expand the assign statement,
// e.g.: x.append(y) -> x = x.append(y)
py::object target_node = expand_info[2];
WriteAssignVars(block, target_node, value_node);
WriteAssignVars(block, target_node, call_node);
}
}
return block;
@ -448,7 +454,7 @@ LocationPtr Parser::GetLocation(const py::object &node) const {
if (ret.size() < 5) {
MS_LOG(EXCEPTION) << "List size should not be less than 5.";
}
// refer to Location::Location() for each member of ret: line, column, line_end, column_end.
// Refer to Location::Location() for each member of ret: line, column, line_end, column_end.
auto location = std::make_shared<Location>(ret[0].cast<std::string>(), ret[1].cast<int64_t>(), ret[2].cast<int64_t>(),
ret[3].cast<int64_t>(), ret[4].cast<int64_t>());
return location;
@ -466,9 +472,9 @@ void Parser::MakeConditionBlocks(const FunctionBlockPtr &pre_block, const Functi
FunctionBlockPtr Parser::ParseReturn(const FunctionBlockPtr &block, const py::object &node) {
MS_LOG(DEBUG) << "Process ast return";
MS_EXCEPTION_IF_NULL(block);
// create return valuenode
// Create return valuenode
AnfNodePtr pReturnValueNode = NewValueNode(prim::kPrimReturn);
// parse the return Statements value
// Parse the return Statements value
py::object value = python_adapter::GetPyObjAttr(node, "value");
AnfNodePtr pReturnStatementNode = ParseExprNode(block, value);
// Create the cnode
@ -486,7 +492,7 @@ AnfNodePtr Parser::ParseBinOp(const FunctionBlockPtr &block, const py::object &n
py::object left = python_adapter::GetPyObjAttr(node, "left");
py::object right = python_adapter::GetPyObjAttr(node, "right");
py::object op = python_adapter::GetPyObjAttr(node, "op");
// create left and right ANF node
// Create left and right ANF node
AnfNodePtr left_node = ParseExprNode(block, left);
if (left_node == nullptr) {
MS_LOG(WARNING) << "DoBinOp process left node failed: " << errcode();
@ -497,9 +503,9 @@ AnfNodePtr Parser::ParseBinOp(const FunctionBlockPtr &block, const py::object &n
MS_LOG(WARNING) << "DoBinOp process right node failed:" << errcode();
return nullptr;
}
// resolve the op
// Resolve the op
AnfNodePtr op_node = block->MakeResolveAstOp(op);
// create apply node
// Create apply node
return block->func_graph()->NewCNodeInOrder({op_node, left_node, right_node});
}
@ -622,10 +628,10 @@ AnfNodePtr Parser::ParseSuper(const FunctionBlockPtr &block, const py::list &arg
return block->MakeResolve(name_space, symbol);
}
// process function call, eg : f1(x, y) ...
// Process function call, eg : f1(x, y) ...
AnfNodePtr Parser::ParseCall(const FunctionBlockPtr &block, const py::object &node) {
MS_LOG(DEBUG) << "Process ast Call";
// process function call
// Process function call
py::object function_ast_node = python_adapter::GetPyObjAttr(node, "func");
py::list args = python_adapter::GetPyObjAttr(node, "args");
@ -639,13 +645,13 @@ AnfNodePtr Parser::ParseCall(const FunctionBlockPtr &block, const py::object &no
}
AnfNodePtr call_function_anf_node = ParseExprNode(block, function_ast_node);
// function call arguments should be passed in as groups and unpacked later using unpack call
// Function call arguments should be passed in as groups and unpacked later using unpack call
std::vector<AnfNodePtr> packed_arguments;
std::vector<AnfNodePtr> group_arguments;
bool need_unpack_args = ParseArgsInCall(block, args, &packed_arguments, &group_arguments);
bool need_unpack_keywords = ParseKeywordsInCall(block, node, &packed_arguments);
// if there is stared or keyword argument, unpack may be needed
// If there is stared or keyword argument, unpack may be needed
bool need_unpack = need_unpack_args || need_unpack_keywords;
return GenerateAnfNodeForCall(block, call_function_anf_node, packed_arguments, group_arguments, need_unpack);
@ -666,7 +672,7 @@ CNodePtr MakeUnpackCall(const FuncGraphPtr &func_graph, const AnfNodePtr &call_f
AnfNodePtr Parser::GenerateAnfNodeForCall(const FunctionBlockPtr &block, const AnfNodePtr &call_function_anf_node,
const std::vector<AnfNodePtr> &packed_arguments,
const std::vector<AnfNodePtr> &group_arguments, bool need_unpack) const {
// if there is keyword arguments or starred, using an unpack_call op to unpack the argument
// If there is keyword arguments or starred, using an unpack_call op to unpack the argument
if (need_unpack) {
return MakeUnpackCall(block->func_graph(), call_function_anf_node, packed_arguments);
}
@ -732,11 +738,11 @@ bool Parser::ParseKeywordsInCall(const FunctionBlockPtr &block, const py::object
return need_unpack;
}
// process call attributes of class type define, eg: x.y()
// Process call attributes of class type define, eg: x.y()
AnfNodePtr Parser::ParseAttribute(const FunctionBlockPtr &block, const py::object &node) {
MS_LOG(DEBUG) << "Process ast Attribute";
// process class value,eg: self.xx
// Process class value,eg: self.xx
if (ast()->target_type() == PARSE_TARGET_OBJECT_INSTANCE) {
if (ast_->IsClassMember(node)) {
std::string var_name = "self.";
@ -754,12 +760,12 @@ AnfNodePtr Parser::ParseAttribute(const FunctionBlockPtr &block, const py::objec
}
}
// process the get attr
// Use the Primitive replace the operation resolve node (getattr)
// Process the get attr
// Use the Primitive replace the operation resolve node (getattr),
// because the getattr will eventually be converted to Primitive node
AnfNodePtr op_node = NewValueNode(prim::kPrimGetAttr);
// process the attr body
// Process the attr body
py::object value_body = python_adapter::GetPyObjAttr(node, "value");
AnfNodePtr value_node = ParseExprNode(block, value_body);
if (value_node == nullptr) {
@ -767,7 +773,7 @@ AnfNodePtr Parser::ParseAttribute(const FunctionBlockPtr &block, const py::objec
return nullptr;
}
// process the node attr
// Process the node attr
auto attr_str = python_adapter::GetPyObjAttr(node, "attr").cast<std::string>();
MS_LOG(DEBUG) << "Attr = " << attr_str;
AnfNodePtr attr_node = nullptr;
@ -776,7 +782,7 @@ AnfNodePtr Parser::ParseAttribute(const FunctionBlockPtr &block, const py::objec
attr_node = NewValueNode(attr_str);
}
// create the apply node
// Create the apply node
return block->func_graph()->NewCNodeInOrder({op_node, value_node, attr_node});
}
@ -784,8 +790,8 @@ AnfNodePtr Parser::ParseAttribute(const FunctionBlockPtr &block, const py::objec
AnfNodePtr Parser::ParseCompare(const FunctionBlockPtr &block, const py::object &node) {
MS_LOG(DEBUG) << "Process ast Compare";
// for python comparison ,there may be if x>y>5 ,
// which there is two ops , but we only support one now
// For python comparison ,there may be if x>y>5 ,
// Which there is two ops , but we only support one now
py::list ops = python_adapter::GetPyObjAttr(node, "ops");
if (ops.size() > MAX_COMPARISON_OPS_SUPPORTED) {
MS_LOG(ERROR) << "MindSpore does not support comparison with operators more than one now, ops size =" << ops.size();
@ -804,7 +810,7 @@ AnfNodePtr Parser::ParseCompare(const FunctionBlockPtr &block, const py::object
}
AnfNodePtr Parser::ProcessBoolOpValueList(const FunctionBlockPtr &block, const py::list &value_list, AstSubType mode) {
// if there is only one bool op now
// If there is only one bool op now
if (value_list.size() == 1) {
AnfNodePtr first_node = ParseExprNode(block, value_list[0]);
return first_node;
@ -828,8 +834,8 @@ AnfNodePtr Parser::ProcessBoolOpValueList(const FunctionBlockPtr &block, const p
MakeConditionBlocks(block, true_block, false_block);
FunctionBlockPtr b1, b2;
// if it is and, we need to process the rest nodes;
// if it is or, we continue to next
// If it is and, we need to process the rest nodes;
// If it is or, we continue to next
if (mode == AST_SUB_TYPE_AND) {
b1 = true_block;
b2 = false_block;
@ -875,7 +881,7 @@ FunctionBlockPtr Parser::ParseFunctionDef(const FunctionBlockPtr &block, const p
FunctionBlockPtr function_block = ParseFunction(node, block);
MS_EXCEPTION_IF_NULL(function_block);
// get function name
// Get function name
py::str name = python_adapter::GetPyObjAttr(node, "name");
std::string function_name = name;
ValueNodePtr valuenode_graph = NewValueNode(function_block->func_graph());
@ -890,7 +896,7 @@ AnfNodePtr Parser::ParseLambda(const FunctionBlockPtr &block, const py::object &
func_block->AddPrevBlock(block);
func_block->Mature();
// get lambda args
// Get lambda args
py::list args = ast_->GetArgs(node);
for (std::size_t i = 0; i < args.size(); i++) {
std::string arg = py::cast<std::string>(args[i].attr("arg"));
@ -909,7 +915,7 @@ AnfNodePtr Parser::ParseLambda(const FunctionBlockPtr &block, const py::object &
return const_graph;
}
// process a tuple
// Process a tuple
AnfNodePtr Parser::ParseTuple(const FunctionBlockPtr &block, const py::object &node) {
MS_LOG(DEBUG) << "Process ast Tuple";
MS_EXCEPTION_IF_NULL(block);
@ -930,7 +936,7 @@ AnfNodePtr Parser::ParseTuple(const FunctionBlockPtr &block, const py::object &n
return tuple_app;
}
// process a list
// Process a list
AnfNodePtr Parser::ParseList(const FunctionBlockPtr &block, const py::object &node) {
MS_LOG(DEBUG) << "Process ast List";
MS_EXCEPTION_IF_NULL(block);
@ -951,7 +957,7 @@ AnfNodePtr Parser::ParseList(const FunctionBlockPtr &block, const py::object &no
return list_app;
}
// process a subscript, such as x[y] , node expressed as value[slice]
// Process a subscript, such as x[y] , node expressed as value[slice]
AnfNodePtr Parser::ParseSubscript(const FunctionBlockPtr &block, const py::object &node) {
MS_LOG(DEBUG) << "Process ast Subscript";
MS_EXCEPTION_IF_NULL(block);
@ -964,7 +970,7 @@ AnfNodePtr Parser::ParseSubscript(const FunctionBlockPtr &block, const py::objec
return block->func_graph()->NewCNodeInOrder({op_getitem, value, slice});
}
// process a slice, get the slice value
// Process a slice, get the slice value
AnfNodePtr Parser::ParseSlice(const FunctionBlockPtr &block, const py::object &node) {
MS_LOG(DEBUG) << "Process ast Slice";
MS_EXCEPTION_IF_NULL(block);
@ -979,7 +985,7 @@ AnfNodePtr Parser::ParseSlice(const FunctionBlockPtr &block, const py::object &n
return block->func_graph()->NewCNodeInOrder({op_makeslice, start_node, stop_node, step_node});
}
// process a extslice
// Process a extslice
AnfNodePtr Parser::ParseExtSlice(const FunctionBlockPtr &block, const py::object &node) {
MS_LOG(DEBUG) << "Process ast ExtSlice";
MS_EXCEPTION_IF_NULL(block);
@ -996,20 +1002,20 @@ AnfNodePtr Parser::ParseExtSlice(const FunctionBlockPtr &block, const py::object
return tuple_conde;
}
// process a index, get the index number
// Process a index, get the index number
AnfNodePtr Parser::ParseIndex(const FunctionBlockPtr &block, const py::object &node) {
MS_LOG(DEBUG) << "Process ast Index";
py::object value_node = python_adapter::GetPyObjAttr(node, "value");
return ParseExprNode(block, value_node);
}
// process a UnaryOp, +a, -b
// Process a UnaryOp, +a, -b
AnfNodePtr Parser::ParseUnaryOp(const FunctionBlockPtr &block, const py::object &node) {
MS_LOG(DEBUG) << "Process ast UnaryOp";
py::object op = python_adapter::GetPyObjAttr(node, "op");
MS_EXCEPTION_IF_NULL(block);
// resolve the op
// Resolve the op
AnfNodePtr op_node = block->MakeResolveAstOp(op);
py::object operand = python_adapter::GetPyObjAttr(node, "operand");
@ -1017,7 +1023,7 @@ AnfNodePtr Parser::ParseUnaryOp(const FunctionBlockPtr &block, const py::object
return block->func_graph()->NewCNodeInOrder({op_node, operand_node});
}
// process a dict ast node expression
// Process a dict ast node expression
AnfNodePtr Parser::ParseDict(const FunctionBlockPtr &block, const py::object &node) {
MS_LOG(DEBUG) << "Process ast Dict";
py::list keys = node.attr("keys");
@ -1035,7 +1041,7 @@ AnfNodePtr Parser::ParseDict(const FunctionBlockPtr &block, const py::object &no
return block->func_graph()->NewCNodeInOrder({make_dict_op, keys_tuple, values_tuple});
}
// process a augment assign such as a += b or mat[stride_slice] += b.
// Process a augment assign such as a += b or mat[stride_slice] += b.
FunctionBlockPtr Parser::ParseAugAssign(const FunctionBlockPtr &block, const py::object &node) {
MS_LOG(DEBUG) << "Process ast AugAssign";
MS_EXCEPTION_IF_NULL(block);
@ -1065,7 +1071,7 @@ FunctionBlockPtr Parser::ParseAugAssign(const FunctionBlockPtr &block, const py:
WriteAssignVars(block, target_obj, augassign_app);
return block;
}
// process global declaration such as 'global x';
// Process global declaration such as 'global x';
FunctionBlockPtr Parser::ParseGlobal(const FunctionBlockPtr &block, const py::object &node) {
MS_LOG(DEBUG) << "Process ast Global";
MS_EXCEPTION_IF_NULL(block);
@ -1076,7 +1082,7 @@ FunctionBlockPtr Parser::ParseGlobal(const FunctionBlockPtr &block, const py::ob
return block;
}
// process a if statement
// Process a if statement
FunctionBlockPtr Parser::ParseIf(const FunctionBlockPtr &block, const py::object &node) {
MS_LOG(DEBUG) << "Process ast If";
py::object test_node = python_adapter::GetPyObjAttr(node, "test");
@ -1104,25 +1110,25 @@ FunctionBlockPtr Parser::ParseIf(const FunctionBlockPtr &block, const py::object
}
if (MsContext::GetInstance()->backend_policy() != "ge") {
// for backends excludes 'ge', it can handle multi graph call, use this flag to
// For backends excludes 'ge', it can handle multi graph call, use this flag to
// generate call not inline `after_block` graph to reduce if by if switch expansion.
after_block->func_graph()->set_flag(FUNC_GRAPH_FLAG_AFTER_BLOCK, true);
}
// process the if-true branch
// Process the if-true branch
py::object bodyNode = python_adapter::GetPyObjAttr(node, "body");
FunctionBlockPtr true_end = ParseStatements(true_block, bodyNode);
// if the return_ is set ,it has its own continuation block
// If the return_ is set ,it has its own continuation block
if (true_end->func_graph()->get_return() == nullptr) {
true_end->Jump(after_block, nullptr);
}
// process the orelse branch
// Process the orelse branch
py::object orelseNode = python_adapter::GetPyObjAttr(node, "orelse");
FunctionBlockPtr false_end = ParseStatements(false_block, orelseNode);
// if the return_ is set ,it has its own continuation block
// If the return_ is set ,it has its own continuation block
if (false_end->func_graph()->get_return() == nullptr) {
false_end->Jump(after_block, nullptr);
}
@ -1220,7 +1226,7 @@ int64_t GetForTransToWhileLoop() {
// A for loop will generate 3 functions :the test, the body, and the continuation
// for x in xs:
// body
// it is compiled to be following statement
// It is compiled to be following statement
// if len(xs) < max_loop_cnt:
// ParseForIter() // use iter to implement for loop, which always unroll loop
// else:
@ -1228,7 +1234,7 @@ int64_t GetForTransToWhileLoop() {
FunctionBlockPtr Parser::ParseFor(const FunctionBlockPtr &block, const py::object &node) {
MS_LOG(DEBUG) << "Process ast For, create an if else statement";
MS_EXCEPTION_IF_NULL(block);
// create statement 'len(xs) < MAX_FOR_LOOP_COUNT'
// Create statement 'len(xs) < MAX_FOR_LOOP_COUNT'
AnfNodePtr op_len = block->MakeResolveSymbol(NAMED_PRIMITIVE_LEN);
py::object iter_obj = python_adapter::GetPyObjAttr(node, NAMED_PRIMITIVE_ITER);
AnfNodePtr iter_node = ParseExprNode(block, iter_obj);
@ -1236,7 +1242,7 @@ FunctionBlockPtr Parser::ParseFor(const FunctionBlockPtr &block, const py::objec
CNodePtr bool_node = block->func_graph()->NewCNodeInOrder(
{NewValueNode(prim::kPrimScalarLt), len_iter, NewValueNode(GetForTransToWhileLoop())});
// create statement 'if len(xs) < prim::MAX_FOR_LOOP_COUNT then ParseForIter else ParseForLoop'
// Create statement 'if len(xs) < prim::MAX_FOR_LOOP_COUNT then ParseForIter else ParseForLoop'
FunctionBlockPtr true_block = nullptr;
FunctionBlockPtr false_block = nullptr;
{
@ -1270,7 +1276,7 @@ FunctionBlockPtr Parser::ParseFor(const FunctionBlockPtr &block, const py::objec
// A for loop will generate 3 functions :the test, the body, and the continuation
// for x in xs:
// body
// it is compiled to be following statement
// It is compiled to be following statement
// it = iter(xs)
// while hastnext(it)
// x, it = next(it)
@ -1282,21 +1288,21 @@ FunctionBlockPtr Parser::ParseForIter(const FunctionBlockPtr &block, const py::o
AnfNodePtr op_next = block->MakeResolveOperation(NAMED_PRIMITIVE_NEXT);
AnfNodePtr op_getitem = block->MakeResolveOperation(NAMED_PRIMITIVE_GETITEM);
AnfNodePtr op_hasnext = block->MakeResolveOperation(NAMED_PRIMITIVE_HASNEXT);
// generate the iterator apply
// Generate the iterator apply
CNodePtr iter_apply = GenerateIteratorInFor(block, node, op_iter);
MS_EXCEPTION_IF_NULL(iter_apply);
FunctionBlockPtr header_block =
GenerateBlockInFor(std::make_shared<TraceForHeader>(block->func_graph()->debug_info()));
MS_EXCEPTION_IF_NULL(header_block);
// generate the hasnext apply which is a condition
// Generate the hasnext apply which is a condition
ParameterPtr iter_param = header_block->func_graph()->add_parameter();
CNodePtr cond_apply = GenerateCondInFor(iter_param, header_block, op_hasnext);
// generate the body of the for statement
// Generate the body of the for statement
FunctionBlockPtr body_block = GenerateBlockInFor(std::make_shared<TraceForBody>(block->func_graph()->debug_info()));
MS_EXCEPTION_IF_NULL(body_block);
body_block->AddPrevBlock(header_block);
// generate the iterator next apply
// process as following: `app = next(it); target = app[0]; it = app[1];`
// Generate the iterator next apply
// Process as following: `app = next(it); target = app[0]; it = app[1];`
CNodePtr app = body_block->func_graph()->NewCNodeInOrder({op_next, iter_param});
CNodePtr target_app =
body_block->func_graph()->NewCNodeInOrder({op_getitem, app, NewValueNode(static_cast<int64_t>(0))});
@ -1306,7 +1312,7 @@ FunctionBlockPtr Parser::ParseForIter(const FunctionBlockPtr &block, const py::o
body_block->func_graph()->NewCNodeInOrder({op_getitem, app, NewValueNode(static_cast<int64_t>(1))});
WriteAssignVars(body_block, target_node, target_app);
// link the variable name with the target
// Link the variable name with the target
auto it_info = std::make_shared<TraceIterator>(target_app->debug_info());
iter_param->debug_info()->set_trace_info(it_info);
iter2_app->debug_info()->set_trace_info(it_info);
@ -1348,7 +1354,7 @@ FunctionBlockPtr Parser::ParseForIter(const FunctionBlockPtr &block, const py::o
// A for loop will generate 3 functions :the test, the body, and the continuation
// for x in xs:
// body
// it is compiled to be following statement
// It is compiled to be following statement
// i = 0
// while i < len(xs)
// x = xs[i]
@ -1360,10 +1366,10 @@ FunctionBlockPtr Parser::ParseForLoop(const FunctionBlockPtr &block, const py::o
AnfNodePtr op_len = block->MakeResolveSymbol(NAMED_PRIMITIVE_LEN);
AnfNodePtr op_getitem = block->MakeResolveOperation(NAMED_PRIMITIVE_GETITEM);
// get variable name of 'x' in statement 'for x in xs'
// Get variable name of 'x' in statement 'for x in xs'
py::object target_node = python_adapter::GetPyObjAttr(node, "target");
// create statement 'len(xs)'
// Create statement 'len(xs)'
py::object iter_obj = python_adapter::GetPyObjAttr(node, "iter");
AnfNodePtr iter_node = ParseExprNode(block, iter_obj);
MS_EXCEPTION_IF_NULL(iter_node);
@ -1377,26 +1383,26 @@ FunctionBlockPtr Parser::ParseForLoop(const FunctionBlockPtr &block, const py::o
FunctionBlockPtr header_block =
GenerateBlockInFor(std::make_shared<TraceForHeader>(block->func_graph()->debug_info()));
MS_EXCEPTION_IF_NULL(header_block);
// create loop variable 'i'
// Create loop variable 'i'
ParameterPtr loop_var = header_block->func_graph()->add_parameter();
// create loop condition 'i < len(xs)'
// Create loop condition 'i < len(xs)'
auto prim_less = prim::GetPythonOps("Less", "mindspore.ops.operations");
auto less_node = header_block->func_graph()->NewCNodeInOrder({NewValueNode(prim_less)});
CNodePtr cond_node = header_block->func_graph()->NewCNodeInOrder({less_node, loop_var, len_iter});
// generate the body of the for statement
// Generate the body of the for statement
FunctionBlockPtr body_block = GenerateBlockInFor(std::make_shared<TraceForBody>(block->func_graph()->debug_info()));
MS_EXCEPTION_IF_NULL(body_block);
body_block->AddPrevBlock(header_block);
// create 'x = xs[i]'
// Create 'x = xs[i]'
CNodePtr target_var = body_block->func_graph()->NewCNodeInOrder({op_getitem, iter_node, loop_var});
WriteAssignVars(body_block, target_node, target_var);
// create 'i = i + 1'
// Create 'i = i + 1'
CNodePtr loop_var_inc = body_block->func_graph()->NewCNodeInOrder(
{NewValueNode(prim::kPrimScalarAdd), loop_var, NewValueNode(static_cast<int64_t>(1))});
body_block->WriteVariable(loop_var->name(), loop_var_inc);
// link the variable name with the target
// Link the variable name with the target
auto it_info = std::make_shared<TraceIterator>(loop_var_inc->debug_info());
loop_var->debug_info()->set_trace_info(it_info);
len_iter->debug_info()->set_trace_info(it_info);
@ -1455,12 +1461,12 @@ AnfNodePtr Parser::ParseIfExp(const FunctionBlockPtr &block, const py::object &n
MakeConditionBlocks(block, true_block, false_block);
// process the if-true branch
// Process the if-true branch
py::object bodyNode = python_adapter::GetPyObjAttr(node, "body");
true_block->func_graph()->debug_info()->set_location(GetLocation(bodyNode));
AnfNodePtr true_node = ParseExprNode(true_block, bodyNode);
// process the orelse branch
// Process the orelse branch
py::object orelseNode = python_adapter::GetPyObjAttr(node, "orelse");
false_block->func_graph()->debug_info()->set_location(GetLocation(orelseNode));
AnfNodePtr false_node = ParseExprNode(false_block, orelseNode);
@ -1468,7 +1474,7 @@ AnfNodePtr Parser::ParseIfExp(const FunctionBlockPtr &block, const py::object &n
true_block->func_graph()->set_output(true_node);
false_block->func_graph()->set_output(false_node);
// Use the Primitive replace the operation resolve node (switch)
// Use the Primitive replace the operation resolve node (switch),
// because the switch will eventually be converted to Primitive node
CNodePtr switch_app = block->func_graph()->NewCNodeInOrder({NewValueNode(prim::kPrimSwitch), bool_node,
NewValueNode(true_block->func_graph()),
@ -1485,9 +1491,9 @@ void Parser::HandleAssignName(const FunctionBlockPtr &block, const py::object &t
py::str name = python_adapter::GetPyObjAttr(targ, "id");
std::string name_id = name;
assigned_node->debug_info()->set_name(name_id);
// set the debug name of the constant graph
// Set the debug name of the constant graph
if (IsValueNode<FuncGraph>(assigned_node)) {
// the value should be graph
// The value should be graph
auto fg = GetValueNode<FuncGraphPtr>(assigned_node);
if (fg->debug_info()->name().empty()) {
fg->debug_info()->set_name(name_id);
@ -1501,7 +1507,7 @@ void Parser::HandleAssignTuple(const FunctionBlockPtr &block, const py::object &
AnfNodePtr op_getitem = block->MakeResolveOperation(NAMED_PRIMITIVE_GETITEM);
py::list items = python_adapter::GetPyObjAttr(targ, "elts");
for (size_t i = 0; i < items.size(); i++) {
// Use the Primitive replace the operation resolve node (getitem)
// Use the Primitive replace the operation resolve node (getitem),
// because the getitem will eventually be converted to Primitive node
CNodePtr item_apply =
block->func_graph()->NewCNodeInOrder({op_getitem, assigned_node, NewValueNode(static_cast<int64_t>(i))});
@ -1546,7 +1552,7 @@ void Parser::HandleAssignSubscript(const FunctionBlockPtr &block, const py::obje
AnfNodePtr value_node = ParseExprNode(block, value_obj);
AnfNodePtr slice_node = ParseExprNode(block, slice_obj);
CNodePtr setitem_app = block->func_graph()->NewCNodeInOrder({op_setitem, value_node, slice_node, assigned_node});
// getitem apply should return the sequence data structure itself
// Getitem apply should return the sequence data structure itself
std::string var_name;
if (ast_->IsClassMember(value_obj)) {
std::string attr_name = value_obj.attr("attr").cast<std::string>();
@ -1597,7 +1603,7 @@ void Parser::WriteAssignVars(const FunctionBlockPtr &block, const py::object &ta
}
}
// process a assign statement, such as a =b, a,b = tup
// Process a assign statement, such as a =b, a,b = tup
FunctionBlockPtr Parser::ParseAssign(const FunctionBlockPtr &block, const py::object &node) {
MS_LOG(DEBUG) << "Process ast assign";
py::object value_object = python_adapter::GetPyObjAttr(node, "value");
@ -1657,7 +1663,7 @@ AnfNodePtr FindPhis(const std::unordered_map<ParameterPtr, AnfNodePtr> &removabl
}
void Parser::RemoveUnnecessaryPhis() {
// merge all removable phis to one map;
// Merge all removable phis to one map;
std::unordered_map<ParameterPtr, AnfNodePtr> removable_phis;
std::vector<ParameterPtr> phis;
for (FunctionBlockPtr &block : func_block_list_) {
@ -1671,14 +1677,14 @@ void Parser::RemoveUnnecessaryPhis() {
}
auto fg_name = func_graph_->ToString();
auto mng = Manage(func_graph_, false);
// replace the nodes
// remove from inside to outside
// Replace the nodes
// Remove from inside to outside
for (int64_t idx = SizeToLong(phis.size() - 1); idx >= 0; idx--) {
auto phi = phis[LongToSize(idx)];
auto new_node = FindPhis(removable_phis, phi);
mng->Replace(phi, new_node);
}
// remove the parameter
// Remove the parameter
for (FunctionBlockPtr &block : func_block_list_) {
MS_EXCEPTION_IF_NULL(block);
auto &local_removable_phis = block->removable_phis();
@ -1693,7 +1699,7 @@ void Parser::RemoveUnnecessaryPhis() {
return local_removable_phis.find(param->cast<ParameterPtr>()) == local_removable_phis.end();
});
// shrink container to new size
// Shrink container to new size
new_parameters.resize(std::distance(new_parameters.begin(), it));
func_graph->set_parameters(new_parameters);
}
@ -1704,20 +1710,20 @@ void Parser::RemoveUnnecessaryPhis() {
// ParseAst class code
bool ParseAst::InitParseAstInfo(const std::string &python_mod_get_parse_method) {
// init the type
// Init the type
target_type_ = PARSE_TARGET_UNKNOW;
// call python parse, get the parser fn
// Call python parse, get the parser fn
module_ = python_adapter::GetPyModule(PYTHON_MOD_PARSE_MODULE);
py::object parse_method = python_adapter::GetPyObjAttr(obj_, PYTHON_EXTERN_PARSE_METHOD);
// get the obj type
// Get the obj type
auto type = data_converter::GetObjType(obj_);
if (type == RESOLVE_TYPE_FUNCTION) {
target_type_ = PARSE_TARGET_FUNCTION;
function_ = obj_;
} else if (type == RESOLVE_TYPE_METHOD) {
// process the method ,need get the method's self obj
// Process the method ,need get the method's self obj
target_type_ = PARSE_TARGET_METHOD;
py::object method_object = python_adapter::GetPyObjAttr(obj_, PYTHON_GET_METHOD_SELF_CLASS);
if (py::isinstance<py::none>(method_object)) {
@ -1735,7 +1741,7 @@ bool ParseAst::InitParseAstInfo(const std::string &python_mod_get_parse_method)
return false;
}
target_type_ = PARSE_TARGET_OBJECT_INSTANCE;
// check the fn is method
// Check the fn is method
auto obj_type = data_converter::GetObjType(function_);
if (obj_type != RESOLVE_TYPE_METHOD) {
MS_LOG(WARNING) << "Parse method function is invalid.";
@ -1746,11 +1752,11 @@ bool ParseAst::InitParseAstInfo(const std::string &python_mod_get_parse_method)
return false;
}
// call python parse get ast tree
// Call python parse get ast tree
parser_ = python_adapter::CallPyModFn(module_, PYTHON_MOD_PARSE_OBJECT_FUNCTION, function_, parse_method);
ast_tree_ = python_adapter::CallPyObjMethod(parser_, "parse");
// get fn name and module
// Get fn name and module
function_module_ = py::cast<std::string>(python_adapter::GetPyObjAttr(parser_, "function_module"));
function_name_ = py::cast<std::string>(python_adapter::GetPyObjAttr(parser_, "function_name"));
function_filename_ = py::cast<std::string>(python_adapter::GetPyObjAttr(parser_, "filename"));
@ -1901,7 +1907,7 @@ FuncGraphPtr MakeTopGraph(const py::object &cell, const ValuePtr &cell_ptr) {
// cell_obj
MS_LOG(DEBUG) << "add Flag for " << std::string(py::str(cell));
parse::UpdateFuncGraphFlags(cell, func_graph);
// top graph's construct flag
// Top graph's construct flag
if (py::hasattr(cell, "construct")) {
parse::UpdateFuncGraphFlags(cell.attr("construct"), func_graph);
}
@ -1917,7 +1923,7 @@ FuncGraphPtr MakeTopGraph(const py::object &cell, const ValuePtr &cell_ptr) {
} else {
// ret = cell_obj(*arg, *kwargs)
auto call_fn = MakeUnpackCall(func_graph, NewValueNode(cell_ptr), func_graph->parameters());
// return ret
// Set output as ret
func_graph->set_output(call_fn);
}
return func_graph;

12
mindspore/ccsrc/pipeline/jit/parse/resolve.cc
View File

@ -1,5 +1,5 @@
/**
* Copyright 2019 Huawei Technologies Co., Ltd
* Copyright 2019-2021 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -197,7 +197,7 @@ AnfNodePtr TransformToMakeTupleNodes(const FuncGraphManagerPtr &manager, const F
return cnode;
}
// transform the ValueTuple or ValueList of graph/primitive node to make tuple of const graph/primitive node
// Transform the ValueTuple or ValueList of graph/primitive node to make tuple of const graph/primitive node
bool TransformVectorFuncValueNode(const FuncGraphManagerPtr &manager, const FuncGraphPtr &func_graph,
const ValueNodePtr &value_node, AnfNodePtr *const transformed) {
MS_EXCEPTION_IF_NULL(value_node);
@ -208,18 +208,18 @@ bool TransformVectorFuncValueNode(const FuncGraphManagerPtr &manager, const Func
// (1) The celllist or ordered_cell will be parsed as valuetuple of const graph in it,
// So if has graph in list, try to replace the node with make tuple of graph value node.
// we do this because the graph manager won't investigate the graph inside valuetuple,
// We do this because the graph manager won't investigate the graph inside valuetuple,
// change the vector of graph to be make_tuple of graph value node.
// (2) the primitive valuetuple or valuelist may encounter to abstract error, make it all
// independent nodes.
auto node_tuple_graphs = TransformToMakeTupleNodes(manager, func_graph, value_vec);
// replace the ret ptr to be make tuple of graph value node
// Replace the ret ptr to be make tuple of graph value node
*transformed = node_tuple_graphs;
return true;
}
// resolve the python obj, and if the resovled node is valuenode with graphs, add the graphs to manager
// Resolve the python obj, and if the resovled node is valuenode with graphs, add the graphs to manager.
AnfNodePtr ResolveObjectAndAddToManager(const FuncGraphManagerPtr &manager, const py::object &obj,
const AnfNodePtr &node) {
ScopeGuard scope_guard(node->scope());
@ -233,7 +233,7 @@ AnfNodePtr ResolveObjectAndAddToManager(const FuncGraphManagerPtr &manager, cons
manager->AddFuncGraph(new_fg);
}
// if the constant node is constant of vector of graph ,add graph to manager
// If the constant node is constant of vector of graph, add graph to manager.
if (IsValueNode<ValueTuple>(resolved_node) || IsValueNode<ValueList>(resolved_node)) {
(void)TransformVectorFuncValueNode(manager, node->func_graph(), resolved_node->cast<ValueNodePtr>(),
&resolved_node);

12
mindspore/ccsrc/pipeline/jit/pass.cc
View File

@ -1,5 +1,5 @@
/**
* Copyright 2019 Huawei Technologies Co., Ltd
* Copyright 2019-2021 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -426,16 +426,6 @@ bool AddCacheEmbeddingPass(const ResourcePtr &res) {
return true;
}
bool MergeDupGraphPass(const ResourcePtr &res) {
FuncGraphPtr func_graph = res->func_graph();
MS_EXCEPTION_IF_NULL(func_graph);
MS_EXCEPTION_IF_NULL(res->manager());
if (res->manager()->func_graphs().size() <= 1) {
return true;
}
return MergeDuplicateGraphs(res->manager());
}
bool RemoveValueNodeDuplicationsPass(const ResourcePtr &res) {
if (res->func_graph() == nullptr) {
MS_LOG(EXCEPTION) << "Remove value node duplications error.";

104
mindspore/ccsrc/pipeline/jit/remove_value_node_dup.cc
View File

@ -1,5 +1,5 @@
/**
* Copyright 2019-2020 Huawei Technologies Co., Ltd
* Copyright 2019-2021 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -73,107 +73,5 @@ void TryToDoReplace(FuncGraphManager *const manager, const AnfNodePtr &node, Has
// Meet for the first time, append node to bucket.
bucket.emplace_back(node);
}
size_t HashOfGraph(const FuncGraphPtr &fg) {
std::vector<AnfNodePtr> toposet = TopoSort(fg->get_return());
MS_LOG(DEBUG) << "TopSort for:" << fg->ToString();
std::unordered_map<AnfNodePtr, std::size_t> hashes;
auto &params = fg->parameters();
for (size_t i = 0; i < params.size(); i++) {
hashes[params[i]] = std::hash<std::string>{}("param" + std::to_string(i));
}
for (auto node : toposet) {
MS_EXCEPTION_IF_NULL(node);
if (hashes.find(node) != hashes.end()) {
continue;
}
std::size_t h = 0;
if (node->isa<ValueNode>()) {
ValueNodePtr value_node = node->cast<ValueNodePtr>();
auto value = value_node->value();
MS_EXCEPTION_IF_NULL(value);
if (IsValueNode<FuncGraph>(value_node)) {
auto v_fg = value->cast<FuncGraphPtr>();
h = value->hash();
} else if (IsValueNode<tensor::Tensor>(value_node)) {
// the tensor has same value has been replaced in duplicate value pass,
// so we use the value pointer here as an identifier
h = hash_combine(value->hash(), std::hash<Value *>{}(value.get()));
} else {
h = hash_combine(value->hash(), (opt::AbsOf(value_node)->hash()));
}
} else if (node->isa<CNode>()) {
auto cnode = node->cast<CNodePtr>();
auto &inputs = cnode->inputs();
size_t init = 0;
h = std::accumulate(inputs.begin(), inputs.end(), init, [&hashes](std::size_t hash, const AnfNodePtr &node_in) {
return hash_combine(hash, hashes[node_in]);
});
} else if (node->isa<Parameter>()) {
h = node->hash();
} else {
MS_LOG(ERROR) << "Unknow node type";
}
hashes[node] = h;
}
return hashes[fg->get_return()];
}
bool IsCNodeGraph(const AnfNodePtr &node) {
if (node == nullptr || !node->isa<CNode>()) {
return false;
}
auto inp0 = node->cast<CNodePtr>()->input(0);
return IsValueNode<FuncGraph>(inp0);
}
bool MergeDuplicateGraphs(const FuncGraphManagerPtr manager) {
std::unordered_map<size_t, std::vector<FuncGraphPtr>> hash_graphs;
std::unordered_map<FuncGraphPtr, size_t> graph_hash;
for (auto fg : manager->func_graphs()) {
size_t h = HashOfGraph(fg);
graph_hash[fg] = h;
if (hash_graphs.find(h) == hash_graphs.end()) {
hash_graphs[h] = {fg};
} else {
hash_graphs[h].push_back(fg);
}
}
FuncGraphPairMapEquiv equiv_graph;
NodeMapEquiv equiv_node;
for (auto &fg : manager->func_graphs()) {
MS_LOG(DEBUG) << "Try Merge Graph:" << fg->ToString();
for (auto &item : fg->nodes()) {
if (!item->isa<CNode>()) {
continue;
}
auto &inputs = item->cast<CNodePtr>()->inputs();
for (size_t i = 0; i < inputs.size(); i++) {
if (!inputs[i]->isa<ValueNode>()) {
continue;
}
auto value_ptr = GetValueNode(inputs[i]);
auto v_fg = value_ptr->cast<FuncGraphPtr>();
if (v_fg == nullptr) {
continue;
}
auto &fg_vec = hash_graphs[graph_hash[v_fg]];
if (fg_vec.size() > 1) {
if (v_fg != fg_vec[0]) {
bool is_morphic = Isomorphic(v_fg, fg_vec[0], &equiv_graph, &equiv_node);
if (is_morphic) {
auto new_node = NewValueNode(fg_vec[0]);
MS_LOG(DEBUG) << "Replace graph node :" << inputs[i]->ToString() << " with:" << new_node->ToString();
manager->Replace(inputs[i], new_node);
}
}
}
}
}
}
return true;
}
} // namespace pipeline
} // namespace mindspore

5
mindspore/ccsrc/pipeline/jit/remove_value_node_dup.h
View File

@ -1,5 +1,5 @@
/**
* Copyright 2019 Huawei Technologies Co., Ltd
* Copyright 2019-2021 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -28,9 +28,6 @@ using HashCache = std::unordered_map<std::size_t, std::vector<AnfNodePtr>>;
using HashValue = std::unordered_map<AnfNodePtr, std::size_t>;
void TryToDoReplace(FuncGraphManager *manager, const AnfNodePtr &node, HashCache *hash_cache, HashValue *hash_value);
size_t HashOfGraph(const FuncGraphPtr &fg);
bool IsCNodeGraph(const AnfNodePtr &node);
bool MergeDuplicateGraphs(const FuncGraphManagerPtr manager);
} // namespace pipeline
} // namespace mindspore

26
mindspore/ccsrc/pipeline/jit/static_analysis/auto_monad.cc
View File

@ -1,5 +1,5 @@
/**
* Copyright 2020 Huawei Technologies Co., Ltd
* Copyright 2020-2021 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -846,7 +846,7 @@ class SideEffectFinder {
const SccPtr &GetScc(const FuncGraphPtr &func_graph) const {
auto found = scc_map_.find(func_graph);
if (found == scc_map_.end()) {
MS_LOG(EXCEPTION) << "SCC not found for " << func_graph->ToString();
MS_LOG(EXCEPTION) << "SCC not found for " << func_graph->ToString() << "." << func_graph->debug_info()->get_id();
}
return found->second;
}
@ -1014,7 +1014,6 @@ class AutoMonadConverter {
HandleCNodes();
}
// Clean up after conversion finished.
func_graph_->ClearIsolateNodes();
func_graph_->ClearOrderList();
return has_effect_cnodes_;
}
@ -1248,9 +1247,17 @@ class AutoMonadConverter {
}
void InsertStateDepend(const AnfNodePtr &state) {
auto output = GetGraphOutput();
// It's safe to handle isolated nodes here:
// Node: Depend(output, StopGrad)
if (IsPrimitiveCNode(output, prim::kPrimDepend) &&
IsPrimitiveCNode(output->cast<CNodePtr>()->input(2), prim::kPrimStopGradient)) {
// Replace Depend(orig_output, StopGrad) node with orig_output.
// After that, nodes may be eliminated if have no side effects.
output = output->cast<CNodePtr>()->input(1);
}
// Insert Depend node and set it as output.
auto depend = NewValueNode(prim::kPrimDepend);
auto output = GetGraphOutput();
auto depend_cnode = func_graph_->NewCNode({depend, output, state});
depend_cnode->set_abstract(output->abstract());
func_graph_->set_output(depend_cnode);
@ -1374,12 +1381,6 @@ bool AutoMonad(const FuncGraphPtr &func_graph) {
bool fg_has_effects = AutoMonadConverter::Handle(fg, top_flag);
has_effects = has_effects || fg_has_effects;
}
// Clear isolate nodes after auto-monad finished.
auto manager = func_graph->manager();
if (manager) {
manager->ClearIsolateNodes();
}
return has_effects;
}
@ -1406,7 +1407,6 @@ bool ReAutoMonad(const FuncGraphPtr &func_graph) {
for (auto &fg : func_graph->func_graphs_used_total()) {
if (!fg->has_flag(mindspore::kFuncGraphFlagReAutoMonad)) {
fg->ClearOrderList();
fg->ClearIsolateNodes();
}
}
changed = AutoMonad(func_graph);
@ -1416,13 +1416,9 @@ bool ReAutoMonad(const FuncGraphPtr &func_graph) {
// After auto monad, Order List and Isolate nodes in graph and manager will be cleared.
} else {
func_graph->ClearOrderList();
func_graph->ClearIsolateNodes();
for (auto &fg : func_graph->func_graphs_used_total()) {
fg->ClearOrderList();
fg->ClearIsolateNodes();
}
MS_EXCEPTION_IF_NULL(func_graph->manager());
func_graph->manager()->ClearIsolateNodes();
}
return changed;
}

74
mindspore/ccsrc/pipeline/jit/static_analysis/evaluator.cc
View File

@ -1,5 +1,5 @@
/**
* Copyright 2019 Huawei Technologies Co., Ltd
* Copyright 2019-2021 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -83,11 +83,11 @@ EvalResultPtr BaseFuncGraphEvaluator::Eval(AnalysisEnginePtr engine, const Abstr
const auto &arg = args_spec_list[i];
const auto &node = parameters[i];
AnfNodeConfigPtr conf = engine->MakeConfig(node, graph_context_);
engine->cache().set_value(conf, std::make_shared<EvalResult>(arg, nullptr));
engine->analysis_cache().set_value(conf, std::make_shared<EvalResult>(arg, nullptr));
}
const AnfNodePtr &func_node = fg->get_return();
MS_LOG(DEBUG) << "Analysis FuncGraph begin, func graph: " << fg.get() << fg->ToString()
MS_LOG(DEBUG) << "Analysis FuncGraph begin, func graph: " << fg << "/" << fg->ToString()
<< ", context: " << graph_context_->ToString() << ", return node: " << func_node->DebugString()
<< ", current function call depth: " << engine->function_call_depth();
AbstractBasePtr ret_base = nullptr;
@ -97,37 +97,20 @@ EvalResultPtr BaseFuncGraphEvaluator::Eval(AnalysisEnginePtr engine, const Abstr
<< MsContext::GetInstance()->get_param<uint32_t>(MS_CTX_MAX_CALL_DEPTH)
<< ", please call 'context.set_context(max_call_depth=value)' to adjust this value.";
}
// Analysis for isolate nodes first, as some validation check in FuncGraph is isolate nodes;
for (const auto &node : fg->GetIsolateNodesInOrder()) {
AnfNodeConfigPtr node_conf = engine->MakeConfig(node, graph_context_);
MS_LOG(DEBUG) << "Analysis isolate_node begin, func graph: " << fg.get() << fg->ToString()
<< ", node_conf: " << node_conf->ToString();
auto isolate_base = engine->GetEvaluatedValue(node_conf)->abstract();
MS_LOG(DEBUG) << "Analysis isolate_node end, func graph: " << fg.get() << fg->ToString()
<< ", node_conf: " << node_conf->ToString() << ", abstract: " << isolate_base->ToString();
}
const auto &all_nodes = TopoSort(func_node, SuccIncoming, [&fg](const AnfNodePtr &node) -> IncludeType {
if (node->func_graph() != fg || node->isa<ValueNode>()) {
return EXCLUDE;
}
return FOLLOW;
});
bool isolate_node_propagate_flag = false;
for (const auto &node : all_nodes) {
AnfNodeConfigPtr node_conf = engine->MakeConfig(node, graph_context_);
MS_LOG(DEBUG) << "Analysis node begin, func graph: " << fg.get() << fg->ToString()
MS_LOG(DEBUG) << "Analysis node begin, func graph: " << fg << "/" << fg->ToString()
<< ", node_conf: " << node_conf->ToString();
auto node_eval_result = engine->GetEvaluatedValue(node_conf);
auto node_eval_result = engine->ObtainEvalResultWithCache(node_conf);
ret_base = node_eval_result->abstract();
MS_LOG(DEBUG) << "Analysis node end, func graph: " << fg.get() << fg->ToString()
MS_LOG(DEBUG) << "Analysis node end, func graph: " << fg << "/" << fg->ToString()
<< ", node_conf: " << node_conf->ToString() << ", abstract: " << ret_base->ToString();
if (node->isa<CNode>()) {
isolate_node_propagate_flag |= node_eval_result->HasIsolateNodesPropagateCNodeFlag();
MS_LOG(DEBUG) << "Check isolate_nodes flag for node: " << node->DebugString()
<< ", abstract: " << ret_base->ToString()
<< ", flag: " << node_eval_result->HasIsolateNodesPropagateCNodeFlag();
}
}
engine->DecreaseFunctionCallDepth();
@ -138,12 +121,7 @@ EvalResultPtr BaseFuncGraphEvaluator::Eval(AnalysisEnginePtr engine, const Abstr
if (fg->stub()) {
ret_base = std::make_shared<AbstractUndetermined>();
}
auto eval_result = std::make_shared<EvalResult>(ret_base, std::make_shared<AttrValueMap>());
if (isolate_node_propagate_flag) {
eval_result->SetIsolateNodesPropagateCNodeFlag(true);
eval_result->SetIsolateNodesPropagateFuncGraphFlag(true);
}
return eval_result;
return std::make_shared<EvalResult>(ret_base, nullptr);
}
AbstractBasePtrList FuncGraphEvaluator::NormalizeArgs(const AbstractBasePtrList &args_spec_list) const {
@ -280,15 +258,15 @@ EvalResultPtr Evaluator::Run(AnalysisEnginePtr engine, const ConfigPtrList &args
(void)std::transform(args_conf_list.begin(), args_conf_list.end(), std::back_inserter(args_spec_list),
[](const ConfigPtr &conf) -> AbstractBasePtr {
MS_EXCEPTION_IF_NULL(conf);
return conf->GetEvaluatedValue()->abstract();
return conf->ObtainEvalResult()->abstract();
});
args_spec_list = NormalizeArgs(args_spec_list);
args_spec_list = BroadenUndeterminedArgs(args_spec_list);
trace::TraceGraphEvalEnter(shared_from_base<Evaluator>(), out_conf);
MS_LOG(DEBUG) << EvalEntryLogging(shared_from_base<Evaluator>(), args_spec_list, out_conf);
MS_EXCEPTION_IF_NULL(cache_);
auto iter = cache_->find(args_spec_list);
if (iter == cache_->end()) {
MS_EXCEPTION_IF_NULL(evaluator_cache_map_);
auto iter = evaluator_cache_map_->find(args_spec_list);
if (iter == evaluator_cache_map_->end()) {
MS_LOG(DEBUG) << evaluator_name << " cache miss, call Eval().";
EvalResultPtr ret = Eval(engine, args_spec_list);
if (ret->abstract() == nullptr) {
@ -296,7 +274,7 @@ EvalResultPtr Evaluator::Run(AnalysisEnginePtr engine, const ConfigPtrList &args
MS_LOG(EXCEPTION) << "Evaluator " << evaluator_name << " result is nullptr.";
}
MS_LOG(DEBUG) << evaluator_name << " set cache. return: " << ret->abstract()->ToString() << ".";
(*cache_)[args_spec_list] = ret;
(*evaluator_cache_map_)[args_spec_list] = ret;
trace::TraceGraphEvalLeave(shared_from_base<Evaluator>());
return ret;
} else {
@ -315,7 +293,7 @@ EvalResultPtr TrivialPrimEvaluator::Run(AnalysisEnginePtr engine, const ConfigPt
(void)std::transform(args_conf_list.begin(), args_conf_list.end(), std::back_inserter(args_spec_list),
[is_py_eval](const ConfigPtr &conf) -> AbstractBasePtr {
MS_EXCEPTION_IF_NULL(conf);
auto abstract = conf->GetEvaluatedValue()->abstract();
auto abstract = conf->ObtainEvalResult()->abstract();
// broaden the ref_key, while infer python prim for cache
if (is_py_eval && abstract->isa<AbstractRef>()) {
auto abs_ref = abstract->cast<AbstractRefPtr>();
@ -333,7 +311,7 @@ EvalResultPtr TransitionPrimEvaluator::Run(AnalysisEnginePtr engine, const Confi
(void)std::transform(args_conf_list.begin(), args_conf_list.end(), std::back_inserter(args_spec_list),
[](const ConfigPtr &conf) -> AbstractBasePtr {
MS_EXCEPTION_IF_NULL(conf);
return conf->GetEvaluatedValue()->abstract();
return conf->ObtainEvalResult()->abstract();
});
if (args_conf_list.size() == 0) {
MS_LOG(EXCEPTION) << "Size should greater than 0";
@ -354,12 +332,12 @@ EvalResultPtr TrackedEvaluator::Run(AnalysisEnginePtr engine, const ConfigPtrLis
(void)std::transform(args_conf_list.begin(), args_conf_list.end(), std::back_inserter(args_spec_list),
[](const ConfigPtr &conf) -> AbstractBasePtr {
MS_EXCEPTION_IF_NULL(conf);
return conf->GetEvaluatedValue()->abstract();
return conf->ObtainEvalResult()->abstract();
});
EvalResultPtr ret = sub_evaluator_->Run(engine, args_conf_list, out_conf);
// Don't lookup from cache, as different out_conf with same node but different context
// may add different entry to anfnode_config_map_, like getattr primitive.
(*cache_)[args_spec_list] = ret;
(*evaluator_cache_map_)[args_spec_list] = ret;
return ret;
}
@ -369,11 +347,11 @@ EvalResultPtr PartialAppEvaluator::Run(AnalysisEnginePtr engine, const ConfigPtr
(void)std::transform(args_conf_list.begin(), args_conf_list.end(), std::back_inserter(args_spec_list),
[](const ConfigPtr &conf) -> AbstractBasePtr {
MS_EXCEPTION_IF_NULL(conf);
return conf->GetEvaluatedValue()->abstract();
return conf->ObtainEvalResult()->abstract();
});
MS_EXCEPTION_IF_NULL(cache_);
auto iter = cache_->find(args_spec_list);
if (iter != cache_->end()) {
MS_EXCEPTION_IF_NULL(evaluator_cache_map_);
auto iter = evaluator_cache_map_->find(args_spec_list);
if (iter != evaluator_cache_map_->end()) {
return iter->second;
}
@ -386,7 +364,7 @@ EvalResultPtr PartialAppEvaluator::Run(AnalysisEnginePtr engine, const ConfigPtr
[](const AbstractBasePtr &arg) -> ConfigPtr { return std::make_shared<VirtualConfig>(arg); });
EvalResultPtr ret = evaluator_->Run(engine, partial_args_conf_list, out_conf);
(*cache_)[args_spec_list] = ret;
(*evaluator_cache_map_)[args_spec_list] = ret;
return ret;
}
@ -395,11 +373,11 @@ EvalResultPtr JEvaluator::Run(AnalysisEnginePtr engine, const ConfigPtrList &arg
(void)std::transform(args_conf_list.begin(), args_conf_list.end(), std::back_inserter(args_spec_list),
[](const ConfigPtr &conf) -> AbstractBasePtr {
MS_EXCEPTION_IF_NULL(conf);
return conf->GetEvaluatedValue()->abstract();
return conf->ObtainEvalResult()->abstract();
});
MS_EXCEPTION_IF_NULL(cache_);
auto iter = cache_->find(args_spec_list);
if (iter != cache_->end()) {
MS_EXCEPTION_IF_NULL(evaluator_cache_map_);
auto iter = evaluator_cache_map_->find(args_spec_list);
if (iter != evaluator_cache_map_->end()) {
return iter->second;
}
@ -427,7 +405,7 @@ EvalResultPtr JEvaluator::Run(AnalysisEnginePtr engine, const ConfigPtrList &arg
AbstractBasePtrList jargs = {result->abstract(), bprop};
AbstractBasePtr jtuple = std::make_shared<AbstractTuple>(jargs);
auto infer_reuslt = std::make_shared<EvalResult>(jtuple, std::make_shared<AttrValueMap>());
(*cache_)[args_spec_list] = infer_reuslt;
(*evaluator_cache_map_)[args_spec_list] = infer_reuslt;
return infer_reuslt;
}

8
mindspore/ccsrc/pipeline/jit/static_analysis/evaluator.h
View File

@ -1,7 +1,7 @@
/**
* This is the C++ adaptation and derivative work of Myia (https://github.com/mila-iqia/myia/).
*
* Copyright 2019 Huawei Technologies Co., Ltd
* Copyright 2019-2021 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -40,7 +40,7 @@ using EvaluatorAttrMapPtr = std::shared_ptr<EvaluatorAttrMap>;
class Evaluator : public Base {
public:
explicit Evaluator(const std::string &id)
: cache_(std::make_shared<EvaluatorCacheMap>()),
: evaluator_cache_map_(std::make_shared<EvaluatorCacheMap>()),
attr_cache_(std::make_shared<EvaluatorAttrMap>()),
identifier_(id) {}
~Evaluator() override = default;
@ -86,10 +86,10 @@ class Evaluator : public Base {
virtual void set_bound_node(const AnfNodePtr &node) { bound_node_ = AnfNodeWeakPtr(node); }
EvaluatorCacheMapPtr &cache() { return cache_; }
EvaluatorCacheMapPtr &evaluator_cache_map() { return evaluator_cache_map_; }
EvaluatorAttrMapPtr &attr_cache() { return attr_cache_; }
EvaluatorCacheMapPtr cache_;
EvaluatorCacheMapPtr evaluator_cache_map_;
EvaluatorAttrMapPtr attr_cache_;
std::string identifier_;

47
mindspore/ccsrc/pipeline/jit/static_analysis/prim.cc
View File

@ -1,7 +1,7 @@
/**
* This is the C++ adaptation and derivative work of Myia (https://github.com/mila-iqia/myia/).
*
* Copyright 2019-2020 Huawei Technologies Co., Ltd
* Copyright 2019-2021 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -53,7 +53,7 @@ EvalResultPtr DoSignatureEvaluator::Run(AnalysisEnginePtr engine, const ConfigPt
AnfNodeConfigPtr out_conf) {
AbstractBasePtrList args_spec_list;
(void)std::transform(args_conf_list.begin(), args_conf_list.end(), std::back_inserter(args_spec_list),
[](const ConfigPtr &ref) -> AbstractBasePtr { return ref->GetEvaluatedValue()->abstract(); });
[](const ConfigPtr &ref) -> AbstractBasePtr { return ref->ObtainEvalResult()->abstract(); });
auto do_signature = prim_->cast<prim::DoSignaturePrimitivePtr>();
auto &func = do_signature->function();
if (func->isa<Primitive>()) {
@ -145,7 +145,7 @@ EvalResultPtr UnpackGraphEvaluator::Run(AnalysisEnginePtr engine, const ConfigPt
AnfNodePtrList args_inputs{out_node_inputs.begin() + 1, out_node_inputs.end()};
AbstractBasePtrList args_spec_list;
(void)std::transform(args_conf_list.begin(), args_conf_list.end(), std::back_inserter(args_spec_list),
[](const ConfigPtr &ref) -> AbstractBasePtr { return ref->GetEvaluatedValue()->abstract(); });
[](const ConfigPtr &ref) -> AbstractBasePtr { return ref->ObtainEvalResult()->abstract(); });
// get the forward graph
MS_EXCEPTION_IF_NULL(args_spec_list[0]);
auto fn = args_spec_list[0]->cast<AbstractFunctionPtr>();
@ -244,7 +244,7 @@ EvalResultPtr MixedPrecisionCastEvaluator::Run(AnalysisEnginePtr engine, const C
<< ", inputs size " << out_node_inputs.size();
}
(void)std::transform(args_conf_list.begin(), args_conf_list.end(), std::back_inserter(args_spec_list),
[](const ConfigPtr &ref) -> AbstractBasePtr { return ref->GetEvaluatedValue()->abstract(); });
[](const ConfigPtr &ref) -> AbstractBasePtr { return ref->ObtainEvalResult()->abstract(); });
ScopePtr scope = kDefaultScope;
if (out_conf != nullptr) {
@ -600,8 +600,8 @@ EvalResultPtr PythonPrimEvaluator::EvalPrim(const AnalysisEnginePtr &, const Abs
}
MS_LOG(DEBUG) << "Eval for:" << prim_py_->ToString();
const auto &iter = cache_->find(args);
if (iter != cache_->end()) {
const auto &iter = evaluator_cache_map_->find(args);
if (iter != evaluator_cache_map_->end()) {
return iter->second;
}
auto py_args = PreparePyInputs(prim_py_, args);
@ -614,7 +614,7 @@ EvalResultPtr PythonPrimEvaluator::EvalPrim(const AnalysisEnginePtr &, const Abs
MS_LOG(DEBUG) << "Python InferTensor result spec: " << res_spec->ToString() << ".";
auto infer_result = std::make_shared<EvalResult>(res_spec, std::make_shared<AttrValueMap>(added_attrs));
(*cache_)[args] = infer_result;
(*evaluator_cache_map_)[args] = infer_result;
return infer_result;
}
@ -936,7 +936,7 @@ class EmbedEvaluator : public SymbolicPrimEvaluator {
AnfNodeConfigPtr node_conf = dyn_cast<AnfNodeConfig>(args_conf_list[0]);
MS_EXCEPTION_IF_NULL(node_conf);
AbstractBasePtr x = node_conf->GetEvaluatedValue()->abstract();
AbstractBasePtr x = node_conf->ObtainEvalResult()->abstract();
x = SensitivityTransform(x);
SymbolicKeyInstancePtr key = std::make_shared<SymbolicKeyInstance>(node_conf->node(), x);
AbstractScalarPtr abs_scalar = std::make_shared<AbstractScalar>(key, std::make_shared<SymbolicKeyType>());
@ -976,7 +976,7 @@ class RefToEmbedEvaluator : public SymbolicPrimEvaluator {
MS_LOG(ERROR) << "Conf should be AnfNodeConfig";
return nullptr;
}
AbstractBasePtr abs = node_conf->GetEvaluatedValue()->abstract();
AbstractBasePtr abs = node_conf->ObtainEvalResult()->abstract();
AbstractRefPtr ref_abs = abs->cast<AbstractRefPtr>();
if (ref_abs == nullptr) {
MS_LOG(ERROR) << "The first parameter of RefToEmbed should be Ref, but " << abs->ToString();
@ -1040,7 +1040,7 @@ class GetAttrEvaluator : public TransitionPrimEvaluator {
}
// don't lookup from cache, as different out_conf with same node but different context
// may add different entry to anfnode_config_map, like getattr primitive;
(*cache_)[args_spec_list] = ret;
(*evaluator_cache_map_)[args_spec_list] = ret;
return ret;
}
};
@ -1126,7 +1126,7 @@ class CreateInstanceEvaluator : public TransitionPrimEvaluator {
AbstractBasePtr ret = ToAbstract(converted_ret, AnalysisContext::DummyContext(), out_conf);
auto infer_result = std::make_shared<EvalResult>(ret, std::make_shared<AttrValueMap>());
(*cache_)[args_spec_list] = infer_result;
(*evaluator_cache_map_)[args_spec_list] = infer_result;
return infer_result;
}
@ -1161,7 +1161,7 @@ class PartialEvaluator : public Evaluator {
MS_EXCEPTION_IF_NULL(out_conf);
MS_EXCEPTION_IF_NULL(out_conf->node());
auto arg0_value = args_conf_list[0]->GetEvaluatedValue()->abstract();
auto arg0_value = args_conf_list[0]->ObtainEvalResult()->abstract();
AbstractBasePtrList args_spec_list{arg0_value};
// Func in hypermap(partial(Func, arg0), arg1, arg2) may become Poly Node.
if (arg0_value->isa<AbstractError>()) {
@ -1169,7 +1169,7 @@ class PartialEvaluator : public Evaluator {
MS_LOG(DEBUG) << "AbstractError for node: " << out_conf->node()->DebugString()
<< " as func is: " << arg0_value->ToString();
auto eval_result = std::make_shared<EvalResult>(ret, std::make_shared<AttrValueMap>());
(*cache_)[args_spec_list] = eval_result;
(*evaluator_cache_map_)[args_spec_list] = eval_result;
return eval_result;
}
auto func = CheckArg<AbstractFunction>("partial", args_spec_list, 0);
@ -1182,11 +1182,9 @@ class PartialEvaluator : public Evaluator {
}
}
std::vector<EvalResultPtr> eval_result_list;
(void)std::transform(args_conf_list.cbegin() + 1, args_conf_list.cend(), std::back_inserter(eval_result_list),
[](const ConfigPtr &config) -> EvalResultPtr { return config->GetEvaluatedValue(); });
(void)std::transform(eval_result_list.cbegin(), eval_result_list.cend(), std::back_inserter(args_spec_list),
[](const EvalResultPtr &eval_result) -> AbstractBasePtr { return eval_result->abstract(); });
(void)std::transform(
args_conf_list.begin() + 1, args_conf_list.end(), std::back_inserter(args_spec_list),
[](const ConfigPtr &config) -> AbstractBasePtr { return config->ObtainEvalResult()->abstract(); });
AbstractBasePtrList args(args_spec_list.begin() + 1, args_spec_list.end());
auto cnode = out_conf->node()->cast<CNodePtr>();
@ -1195,25 +1193,16 @@ class PartialEvaluator : public Evaluator {
MS_LOG(EXCEPTION) << "Out_conf node: " << cnode->DebugString()
<< ", args_conf_list: " << mindspore::ToString(args_conf_list);
}
auto flag = std::any_of(eval_result_list.cbegin(), eval_result_list.cend(), [](const EvalResultPtr &eval_result) {
MS_LOG(DEBUG) << "Propagate isolate nodes flag from: " << eval_result->abstract()->ToString()
<< ", flag: " << eval_result->HasIsolateNodesPropagateCNodeFlag();
return eval_result->HasIsolateNodesPropagateCNodeFlag();
});
AbstractFuncAtomPtrList partial_funcs_list;
auto build_partial = [args, cnode, flag, &partial_funcs_list](const AbstractFuncAtomPtr &atom_func) {
auto build_partial = [args, cnode, &partial_funcs_list](const AbstractFuncAtomPtr &atom_func) {
auto new_func = std::make_shared<PartialAbstractClosure>(atom_func, args, cnode);
partial_funcs_list.push_back(new_func);
if (atom_func->HasIsolateNodesFlag() || flag) {
new_func->SetIsolateNodesFlag(true);
}
};
func->Visit(build_partial);
auto ret = AbstractFunction::MakeAbstractFunction(partial_funcs_list);
auto eval_result = std::make_shared<EvalResult>(ret, std::make_shared<AttrValueMap>());
(*cache_)[args_spec_list] = eval_result;
(*evaluator_cache_map_)[args_spec_list] = eval_result;
return eval_result;
}

232
mindspore/ccsrc/pipeline/jit/static_analysis/program_specialize.cc
View File

@ -1,7 +1,7 @@
/**
* This is the C++ adaptation and derivative work of Myia (https://github.com/mila-iqia/myia/).
*
* Copyright 2019 Huawei Technologies Co., Ltd
* Copyright 2019-2021 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -30,11 +30,11 @@
namespace mindspore {
namespace abstract {
namespace {
inline AbstractBasePtr GetEvaluatedValueWrap(const AnfNodeConfigPtr &conf) {
inline AbstractBasePtr GetEvaluatedValue(const AnfNodeConfigPtr &conf) {
if (conf->node()->intermediate_abstract()) {
return conf->node()->intermediate_abstract();
}
return conf->GetEvaluatedValue()->abstract();
return conf->ObtainEvalResult()->abstract();
}
AnfNodePtr BuildValueNode(const ValuePtr &v, const AbstractBasePtr &abs_base) {
@ -80,7 +80,7 @@ std::shared_ptr<FuncGraphSpecializer> ProgramSpecializer::GetFuncGraphSpecialize
if (iter != specializations_.end()) {
return iter->second;
}
if (context->func_graph()) {
if (context->func_graph() != nullptr) {
MS_LOG(EXCEPTION) << "Specialize inner error";
}
return nullptr;
@ -101,6 +101,9 @@ FuncGraphSpecializer::FuncGraphSpecializer(ProgramSpecializer *const s, const Fu
cloner_ = SpecializerClone(fg, std::make_shared<TraceSpecialize>(GetNextCounter()));
repl_node_ = cloner_->cloned_node();
specialized_func_graph_ = cloner_->cloned_func_graph()[fg];
todo_.push_back(fg->get_return());
auto ps = fg->parameters();
(void)todo_.insert(todo_.end(), ps.begin(), ps.end());
}
AnfNodePtr FuncGraphSpecializer::ReplicateDisconnectedNode(const AnfNodePtr &node) {
@ -128,24 +131,12 @@ AnfNodePtr FuncGraphSpecializer::ReplicateDisconnectedNode(const AnfNodePtr &nod
}
auto c_node = node->cast<CNodePtr>();
MS_EXCEPTION_IF_NULL(c_node);
auto c_new_node = new_node->cast<CNodePtr>();
MS_EXCEPTION_IF_NULL(c_new_node);
auto inputs = c_node->inputs();
std::vector<AnfNodePtr> new_inputs;
(void)std::transform(
inputs.begin(), inputs.end(), std::back_inserter(new_inputs), [this](const AnfNodePtr &inp) -> AnfNodePtr {
auto new_inp = ReplicateDisconnectedNode(inp);
// refer the comments in BuildReplacedNode.
if (inp->isa<CNode>()) {
auto c_inp = inp->cast<CNodePtr>();
MS_EXCEPTION_IF_NULL(c_inp);
auto c_new_inp = new_inp->cast<CNodePtr>();
MS_EXCEPTION_IF_NULL(c_new_inp);
MS_LOG(DEBUG) << "Replace inp node: " << inp->ToString() << " in order list, with " << new_inp->ToString();
c_new_inp->func_graph()->ReplaceInOrder(c_inp, c_new_inp);
}
return new_inp;
});
(void)std::transform(inputs.begin(), inputs.end(), std::back_inserter(new_inputs),
[this](const AnfNodePtr &inp) -> AnfNodePtr { return ReplicateDisconnectedNode(inp); });
auto c_new_node = new_node->cast<CNodePtr>();
MS_EXCEPTION_IF_NULL(c_new_node);
c_new_node->set_inputs(new_inputs);
}
@ -189,16 +180,7 @@ void FuncGraphSpecializer::Run() {
}
void FuncGraphSpecializer::FirstPass() {
// Process parameter;
for (const auto &node : func_graph_->parameters()) {
(void)marked_.insert(node);
ProcessNode(node);
}
ProcessIsolateNodes();
todo_.push_back(func_graph_->get_return());
while (!todo_.empty()) {
while (todo_.size()) {
AnfNodePtr node = todo_.back();
todo_.pop_back();
if (node->func_graph() == nullptr) {
@ -227,41 +209,13 @@ void FuncGraphSpecializer::FirstPass() {
// Specialize CNode in func graphs
void FuncGraphSpecializer::SecondPass() {
std::vector<CNodePtr> starts;
auto &isolate_nodes = specialized_func_graph_->isolate_nodes();
starts.reserve(isolate_nodes.size() + 1);
starts.push_back(specialized_func_graph_->get_return());
(void)std::transform(isolate_nodes.begin(), isolate_nodes.end(), std::back_inserter(starts),
[](auto &node) { return dyn_cast<CNode>(node); });
for (auto &node : BroadFirstSearchGraphCNodes(starts)) {
for (auto &node : BroadFirstSearchGraphCNodes({specialized_func_graph_->get_return()})) {
if (node->isa<CNode>()) {
ProcessCNode(node->cast<CNodePtr>());
}
}
}
static AnfNodePtr CreateNoBroadenDepend() {
PrimitivePtr prim = std::make_shared<Primitive>(prim::kPrimDepend->name(), prim::kPrimDepend->attrs());
prim->set_attr(ATTR_NO_BROADEN, prim::kValueOne);
return BuildValueNode(prim, FromValueInside(prim));
}
bool AllowDependIsolateNodes(const AnfNodePtr &node) {
auto abstract = node->abstract();
if (abstract->GetTypeTrack()->isa<EnvType>()) {
return false;
}
auto abstract_tuple = dyn_cast<abstract::AbstractTuple>(abstract);
if (abstract_tuple != nullptr) {
for (auto &abs : abstract_tuple->elements()) {
if (abs->GetTypeTrack()->isa<EnvType>()) {
return false;
}
}
}
return true;
}
void FuncGraphSpecializer::ProcessNode(const AnfNodePtr &node) {
MS_EXCEPTION_IF_NULL(node);
ScopeGuard scope_guard(node->scope());
@ -275,7 +229,7 @@ void FuncGraphSpecializer::ProcessNode(const AnfNodePtr &node) {
<< ", specialized_func_graph_: " << specialized_func_graph_->ToString();
return;
}
new_node->set_abstract(GetEvaluatedValueWrap(conf));
new_node->set_abstract(GetEvaluatedValue(conf));
if (new_node->isa<CNode>() && new_node->abstract()->isa<PartialAbstractClosure>()) {
auto partial_abstract = dyn_cast<PartialAbstractClosure>(new_node->abstract());
if (partial_abstract->node() == node) {
@ -286,7 +240,7 @@ void FuncGraphSpecializer::ProcessNode(const AnfNodePtr &node) {
MS_LOG(DEBUG) << "Set new_node: " << new_node->ToString() << ", abstract as: " << new_node->abstract()->ToString();
if (node->isa<CNode>()) {
auto attrs = conf->GetEvaluatedValue()->attribute();
auto attrs = conf->ObtainEvalResult()->attribute();
auto c_old = node->cast<CNodePtr>();
auto c_new = new_node->cast<CNodePtr>();
auto new_inputs = c_new->inputs();
@ -294,33 +248,19 @@ void FuncGraphSpecializer::ProcessNode(const AnfNodePtr &node) {
for (size_t i = 0; i < old_inputs.size(); ++i) {
auto node_input = old_inputs[i];
AnfNodeConfigPtr iconf = MakeConfig(node_input);
auto eval_result = iconf->GetEvaluatedValue();
AbstractBasePtr ival = eval_result->abstract();
AbstractBasePtr ival = GetEvaluatedValue(iconf);
// First try to check if node_input can be replaced by a ValueNode. If cannot, then try to check if
// can be replaced by another CNode from anfnode_config_map, otherwise use the replicated node.
AnfNodePtr replace_node = BuildPossibleValueNode(iconf->node(), ival, attrs);
if (replace_node == nullptr) {
replace_node = BuildReplacedNode(iconf).second;
replace_node = BuildReplacedNode(iconf);
MS_EXCEPTION_IF_NULL(replace_node);
replace_node->set_abstract(ival);
MS_LOG(DEBUG) << "Set replaced: " << replace_node->ToString() << ", to abstract: " << ival->ToString();
} else if (node_input->isa<CNode>() && eval_result->HasIsolateNodesPropagateCNodeFlag()) {
// Handle isolate nodes
auto inp_c_node = node_input->cast<CNodePtr>();
auto collected = CollectCNodeWithIsolateNodes(inp_c_node, eval_result, c_new->func_graph());
if (AllowDependIsolateNodes(collected)) {
auto depend_ops = CreateNoBroadenDepend();
AnfNodePtr new_cnode = specialized_func_graph_->NewCNode({depend_ops, replace_node, collected});
new_cnode->set_abstract(ival);
replace_node = new_cnode;
MS_LOG(DEBUG) << "Build possible depend node for node: " << node_input->DebugString()
<< ", ival: " << ival->ToString() << ", replace_node: " << replace_node->DebugString();
}
} else {
MS_LOG(DEBUG) << "Not set replace value node for node: " << node_input->DebugString()
<< ", ival: " << ival->ToString() << ", replace_node: " << replace_node->DebugString();
MS_LOG(DEBUG) << "Build possible value node for node: " << node_input->DebugString()
<< ", ival: " << ival->ToString() << ", replace_node: " << replace_node->ToString();
}
if (new_inputs[i] != replace_node) {
new_inputs[i] = replace_node;
MS_LOG(DEBUG) << "Set new_input[" << i << "] = " << replace_node->DebugString();
@ -330,112 +270,17 @@ void FuncGraphSpecializer::ProcessNode(const AnfNodePtr &node) {
}
}
AnfNodePtr FuncGraphSpecializer::CollectCNodeWithIsolateNodes(const CNodePtr &c_node,
const EvalResultPtr &c_node_eval_result,
const FuncGraphPtr &new_fg) {
auto c_node_inputs = c_node->inputs();
auto inp0 = c_node_inputs[0];
auto inp0_conf = MakeConfig(inp0);
auto inp0_eval_result = inp0_conf->GetEvaluatedValue();
auto inp0_abstract = inp0_eval_result->abstract();
auto inp0_abs_func = inp0_abstract->cast<AbstractFunctionPtr>();
if (inp0_abs_func == nullptr) {
MS_LOG_EXCEPTION << "inp0 should be AbstractFunction, but: " << inp0_abstract->ToString();
}
if (c_node_eval_result->HasIsolateNodesPropagateFuncGraphFlag() || inp0_abs_func->HasIsolateNodesFlag()) {
auto c_node_conf = MakeConfig(c_node);
auto replace_node = BuildReplacedNode(c_node_conf).second;
MS_EXCEPTION_IF_NULL(replace_node);
replace_node->set_abstract(inp0_abstract);
MS_LOG(DEBUG) << "Build possible depend node for node: " << c_node->DebugString()
<< ", depend node: " << replace_node->DebugString();
return replace_node;
}
// Search inputs from 1 to find CNodeWithIsolateNode if that input is CNode and can Built PossibleValueNode.
std::vector<AnfNodePtr> collected_nodes;
for (std::size_t i = 1; i < c_node_inputs.size(); ++i) {
auto inp_i = c_node_inputs[i];
if (inp_i->isa<CNode>()) {
auto inp_i_conf = MakeConfig(inp_i);
auto inp_i_eval_result = inp_i_conf->GetEvaluatedValue();
auto inp_i_abstract = inp_i_eval_result->abstract();
if (inp_i_eval_result->HasIsolateNodesPropagateCNodeFlag()) {
static auto attrs = std::make_shared<AttrValueMap>();
AnfNodePtr replace_node = BuildPossibleValueNode(inp_i, inp_i_abstract, attrs);
if (replace_node == nullptr) {
replace_node = BuildReplacedNode(inp_i_conf).second;
MS_EXCEPTION_IF_NULL(replace_node);
replace_node->set_abstract(inp_i_abstract);
MS_LOG(DEBUG) << "Set replaced: " << replace_node->DebugString() << ", to replace: " << c_node->DebugString();
} else {
auto inp_i_c_node = inp_i->cast<CNodePtr>();
AnfNodePtr new_node = GetReplicatedNode(inp_i_c_node);
auto collected = CollectCNodeWithIsolateNodes(inp_i_c_node, inp_i_eval_result, new_node->func_graph());
replace_node = collected;
}
collected_nodes.push_back(replace_node);
}
}
}
// Build depend node;
if (collected_nodes.empty()) {
MS_LOG_EXCEPTION << "cannot find where IsolateNodes from, node: " << c_node->DebugString()
<< ", abstract: " << c_node_eval_result->abstract()->ToString()
<< ", flag: " << c_node_eval_result->HasIsolateNodesPropagateCNodeFlag();
}
if (collected_nodes.size() == 1) {
auto new_cnode = collected_nodes[0];
MS_LOG(DEBUG) << "Build possible depend node for node: " << c_node->DebugString()
<< ", depend node: " << new_cnode->DebugString();
return new_cnode;
}
AbstractBasePtrList tuple_abstract;
std::transform(collected_nodes.cbegin(), collected_nodes.cend(), std::back_inserter(tuple_abstract),
[](const auto &collected_node) { return collected_node->abstract(); });
auto make_tuple_ops = BuildValueNode(prim::kPrimMakeTuple, FromValueInside(prim::kPrimMakeTuple));
collected_nodes.insert(collected_nodes.begin(), make_tuple_ops);
AnfNodePtr new_cnode = new_fg->NewCNode(collected_nodes);
new_cnode->set_abstract(std::make_shared<AbstractTuple>(tuple_abstract));
MS_LOG(DEBUG) << "Build possible depend node for node: " << c_node->DebugString()
<< ", depend node: " << new_cnode->DebugString(2);
return new_cnode;
}
void FuncGraphSpecializer::ProcessIsolateNodes() {
// Process isolate nodes, take the isolate cnode as one because it may be forward to a new cnode.
for (const auto &node : func_graph_->isolate_nodes()) {
ScopeGuard scope_guard(node->scope());
auto conf = MakeConfig(node);
// First of node_pair is the original node or the forwarded node, second is the replaced node.
const auto &node_pair = BuildReplacedNode(conf);
auto &replace_node = node_pair.first;
MS_EXCEPTION_IF_NULL(replace_node);
replace_node->set_abstract(GetEvaluatedValueWrap(conf));
MS_LOG(DEBUG) << "BuildReplacedNode for isolate node, new_node: " << replace_node->DebugString()
<< ", old node: " << node->DebugString();
// Only the isolated node is forwarded, mark node as processed. Otherwise node is pushed to todo_ in
// BuildReplacednode and will be processed as normal node.
if (node != node_pair.first) {
(void)marked_.insert(node);
}
}
}
std::pair<AnfNodePtr, AnfNodePtr> FuncGraphSpecializer::BuildReplacedNode(const AnfNodeConfigPtr &conf) {
AnfNodePtr FuncGraphSpecializer::BuildReplacedNode(const AnfNodeConfigPtr &conf) {
MS_EXCEPTION_IF_NULL(conf);
auto conf_iter = engine_->anfnode_config_map().find(conf);
AnfNodeConfigPtr new_conf = conf;
while (conf_iter != engine_->anfnode_config_map().end()) {
MS_LOG(DEBUG) << "Origin conf: , node(" << new_conf->node()->DebugString() << ")";
MS_LOG(DEBUG) << "Origin conf: node(" << new_conf->node()->DebugString() << ")";
new_conf = conf_iter->second;
MS_EXCEPTION_IF_NULL(new_conf);
const auto &forward_node = new_conf->node();
MS_LOG(DEBUG) << "Replaced conf: , node(" << forward_node->DebugString() << ")";
MS_LOG(DEBUG) << "Replaced conf: node(" << forward_node->DebugString() << ")";
const auto &replicated_forward_node = ReplicateDisconnectedNode(forward_node);
if (replicated_forward_node && replicated_forward_node->isa<CNode>()) {
// The AnfNode in order_list can be:
@ -476,7 +321,7 @@ std::pair<AnfNodePtr, AnfNodePtr> FuncGraphSpecializer::BuildReplacedNode(const
MS_LOG(DEBUG) << "Set repl: graph(nullptr), node(" << repl->DebugString()
<< ") to replace origin: " << new_conf->node()->DebugString();
}
return std::make_pair(new_conf->node(), repl);
return repl;
}
namespace {
@ -515,6 +360,7 @@ AnfNodePtr FuncGraphSpecializer::BuildSpecializedNode(const AnfNodePtr &node, co
<< ", abstract: " << abs->ToString();
}
}
// Set the flag, so this MetaFuncGraph will be Re-AutoMonaded.
if (func->isa<MetaFuncGraphAbstractClosure>()) {
auto specialized_fg = GetValueNode<FuncGraphPtr>(repl);
@ -522,7 +368,6 @@ AnfNodePtr FuncGraphSpecializer::BuildSpecializedNode(const AnfNodePtr &node, co
specialized_fg->set_flag(mindspore::kFuncGraphFlagReAutoMonad, true);
}
}
return repl;
}
@ -614,7 +459,7 @@ AnfNodePtr FuncGraphSpecializer::BuildSpecializedParameterNode(const CNodePtr &n
MS_LOG(EXCEPTION) << "Size of cnode: " << cnode->DebugString()
<< " is not equal to 2 added to size of args: " << mindspore::ToString(partial_closure->args());
}
static auto attrs = std::make_shared<AttrValueMap>();
auto attrs = std::make_shared<AttrValueMap>();
for (size_t i = 0; i < partial_closure->args().size(); i++) {
auto old_node = cnode->input(i + 2);
auto possibile_value_node = BuildPossibleValueNode(old_node, partial_closure->args()[i], attrs);
@ -636,8 +481,8 @@ AnfNodePtr FuncGraphSpecializer::BuildSpecializedParameterNode(const CNodePtr &n
const EvaluatorCacheMapPtr &FuncGraphSpecializer::GetEvalCache(const EvaluatorPtr &eval) {
auto cache_iter = evalcaches_.find(eval);
if (cache_iter == evalcaches_.end()) {
evalcaches_[eval] = eval->cache();
return eval->cache();
evalcaches_[eval] = eval->evaluator_cache_map();
return eval->evaluator_cache_map();
}
return cache_iter->second;
}
@ -693,7 +538,7 @@ void FuncGraphSpecializer::ProcessCNode(const CNodePtr &new_node) {
std::vector<AnfNodePtr> args(new_inputs.begin() + 1, new_inputs.end());
// CNode(CNode(Partial, f, arg1), arg2, ...) --> CNode(f, arg1, arg2, ...)
while (IsPrimitiveCNode(func, prim::kPrimPartial)) {
auto &inputs = func->cast<CNodePtr>()->inputs();
std::vector<AnfNodePtr> inputs = func->cast<CNodePtr>()->inputs();
// First element is partial, second is func so arg is start from 2
(void)args.insert(args.begin(), inputs.begin() + 2, inputs.end());
func = inputs[1];
@ -788,7 +633,7 @@ SpecializeStatusCode FuncGraphSpecializer::FindUniqueArgvals(const AbstractFunct
MS_EXCEPTION_IF_NULL(eval);
MS_EXCEPTION_IF_NULL(result);
EvaluatorCacheMap evaluator_cache_map = *eval->cache();
EvaluatorCacheMap evaluator_cache_map = *eval->evaluator_cache_map();
if (evaluator_cache_map.find(argvals) != evaluator_cache_map.end()) {
*result = std::make_pair(argvals, evaluator_cache_map[argvals]->abstract());
return kSpecializeSuccess;
@ -848,22 +693,6 @@ static PrimitivePtr BuildPrimtiveValueWithAttributes(const PrimitivePtr &prim, c
return prim;
}
// Return true if this node can be replaced by value.
static bool CanReplaceByValue(const AnfNodePtr &node) {
auto cnode = dyn_cast<CNode>(node);
if (cnode == nullptr || cnode->inputs().empty()) {
return true;
}
auto &input0 = cnode->inputs().at(0);
// Keep parameter not be replaced by value.
if (input0->isa<Parameter>()) {
return false;
}
// Keep 'depend' node not be replaced by value.
auto prim = GetValueNode<PrimitivePtr>(input0);
return !IsPrimitiveEquals(prim, prim::kPrimDepend);
}
AnfNodePtr FuncGraphSpecializer::BuildPossibleValueNode(const AnfNodePtr &origin_node, const AbstractBasePtr &ival,
const AttrValueMapPtr &attrs) {
MS_EXCEPTION_IF_NULL(origin_node);
@ -904,7 +733,8 @@ AnfNodePtr FuncGraphSpecializer::BuildPossibleValueNode(const AnfNodePtr &origin
if (val->isa<AnyValue>()) {
return nullptr;
}
if (!CanReplaceByValue(origin_node)) {
// keep primitive 'depend' not to be optimized
if (IsPrimitiveCNode(origin_node, prim::kPrimDepend)) {
return nullptr;
}
return BuildValueNode(val, ival);

13
mindspore/ccsrc/pipeline/jit/static_analysis/program_specialize.h
View File

@ -1,7 +1,7 @@
/**
* This is the C++ adaptation and derivative work of Myia (https://github.com/mila-iqia/myia/).
*
* Copyright 2019 Huawei Technologies Co., Ltd
* Copyright 2019-2021 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -98,8 +98,6 @@ class FuncGraphSpecializer : public std::enable_shared_from_this<FuncGraphSpecia
void ProcessNode(const AnfNodePtr &node);
void ProcessCNode(const CNodePtr &new_node);
void ProcessIsolateNodes();
AnfNodeConfigPtr MakeConfig(const AnfNodePtr &node);
inline void AddTodoItem(const AnfNodePtr &node) { todo_.push_back(node); }
// Get node replicated by Cloner.
@ -114,12 +112,9 @@ class FuncGraphSpecializer : public std::enable_shared_from_this<FuncGraphSpecia
// Build a value node if ival is constant and not any-value
AnfNodePtr BuildPossibleValueNode(const AnfNodePtr &origin_node, const AbstractBasePtr &ival,
const AttrValueMapPtr &attrs);
// Build a replaceable node for iconf->node; it may be a replicated forward CNode in static analysis or just a
// replicated node. First of returned pair is the origin node or the forward cnode, second is the replaced node.
std::pair<AnfNodePtr, AnfNodePtr> BuildReplacedNode(const AnfNodeConfigPtr &conf);
// Collect CNodes which have IsolateNodes that will be replaced by a ValuedNode.
AnfNodePtr CollectCNodeWithIsolateNodes(const CNodePtr &c_node, const EvalResultPtr &c_node_eval_result,
const FuncGraphPtr &new_fg);
// Build a replaceable node for iconf->node; it may be a replicated forwarded CNode in static analysis or just a
// replicated node.
AnfNodePtr BuildReplacedNode(const AnfNodeConfigPtr &conf);
// Build a specialized node from given argvals;
AnfNodePtr BuildSpecializedNode(const AnfNodePtr &node, const AbstractBasePtr &abs,
const AbstractBasePtrList &argvals);

96
mindspore/ccsrc/pipeline/jit/static_analysis/static_analysis.cc
View File

@ -1,7 +1,7 @@
/**
* This is the C++ adaptation and derivative work of Myia (https://github.com/mila-iqia/myia/).
*
* Copyright 2019-2020 Huawei Technologies Co., Ltd
* Copyright 2019-2021 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -58,7 +58,7 @@ void AnalysisCache::set_value(const AnfNodeConfigPtr &conf, const EvalResultPtr
MS_LOG(DEBUG) << "AnalysisCache set for NodeConfig: " << conf->node()->DebugString()
<< ", Context: " << conf->context()->ToString() << ", Value: " << result->abstract()->ToString()
<< ", Pointer: " << result->abstract().get();
cache_[conf] = result;
analysis_cache_map_[conf] = result;
// Set intermediate abstract value.
if (IsIntermediateAbstract(result->abstract())) {
@ -77,8 +77,8 @@ void AnalysisCache::set_value(const AnfNodeConfigPtr &conf, const EvalResultPtr
}
EvalResultPtr AnalysisCache::GetValue(const AnfNodeConfigPtr &conf) {
auto value = cache_.find(conf);
if (value == cache_.end()) {
auto value = analysis_cache_map_.find(conf);
if (value == analysis_cache_map_.end()) {
return nullptr;
}
return value->second;
@ -124,7 +124,7 @@ AnalysisResult AnalysisEngine::Run(const FuncGraphPtr &func_graph, const Abstrac
AnalysisResult result;
MS_EXCEPTION_IF_NULL(output_conf);
result.inferred = output_conf->GetEvaluatedValue();
result.inferred = output_conf->ObtainEvalResult();
result.context = root_context;
return result;
}
@ -136,25 +136,24 @@ AnalysisContextPtr AnalysisEngine::Run(const FuncGraphPtr &func_graph, const Ana
return eval->graph_context();
}
EvalResultPtr AnalysisEngine::GetEvaluatedValue(const AnfNodeConfigPtr &conf) {
EvalResultPtr AnalysisEngine::ObtainEvalResultWithCache(const AnfNodeConfigPtr &conf) {
MS_EXCEPTION_IF_NULL(conf);
auto value = cache_.GetValue(conf);
if (value != nullptr) {
MS_LOG(DEBUG) << "Evaluate cache hit for NodeConfig: " << conf->ToString() << ", Value: " << value->abstract().get()
<< ", " << value->abstract()->ToString() << ", flag: " << value->HasIsolateNodesPropagateCNodeFlag();
return value;
EvalResultPtr result = analysis_cache_.GetValue(conf);
if (result != nullptr) {
MS_LOG(DEBUG) << "Evaluate cache hit for NodeConfig: " << conf->ToString()
<< ", Value: " << result->abstract().get() << ", " << result->abstract()->ToString();
return result;
}
MS_LOG(DEBUG) << "Evaluate cache miss for NodeConfig: " << conf->ToString();
value = Eval(conf);
if (value == nullptr) {
result = Eval(conf);
if (result == nullptr) {
MS_LOG(EXCEPTION) << "Evaluate for NodeConfig " << conf->ToString() << " get nullptr";
}
MS_LOG(DEBUG) << "Evaluate node on demond for NodeConfig: " << conf->ToString()
<< ", Value: " << value->abstract().get() << ", " << value->abstract()->ToString()
<< ", flag: " << value->HasIsolateNodesPropagateCNodeFlag();
cache_.set_value(conf, value);
return value;
<< ", result: " << result->abstract().get() << ", " << result->abstract()->ToString();
analysis_cache_.set_value(conf, result);
return result;
}
EvalResultPtr AnalysisEngine::Eval(const AnfNodeConfigPtr &conf) {
@ -198,8 +197,7 @@ EvalResultPtr AnalysisEngine::Eval(const AnfNodeConfigPtr &conf) {
<< " NodeInfo: " << trace::GetDebugInfo(node->debug_info());
}
#endif
MS_LOG(DEBUG) << "End Eval NodeConfig " << conf->ToString() << ", res: " << eval_result->abstract()->ToString()
<< ", flag: " << eval_result->HasIsolateNodesPropagateCNodeFlag();
MS_LOG(DEBUG) << "End Eval NodeConfig " << conf->ToString() << ", res: " << eval_result->abstract()->ToString();
return eval_result;
}
@ -251,20 +249,6 @@ AbstractBasePtr AnalysisEngine::EvalValueNode(const ValueNodePtr &value_node, co
return out;
}
static bool CheckIsolateNodesPropagateFlag(const AbstractFunctionPtr &abs_func, const ConfigPtrList &conf_list) {
if (abs_func->HasIsolateNodesFlag()) {
MS_LOG(DEBUG) << "Propagate isolate nodes flag from: " << abs_func->ToString();
return true;
}
auto flag = std::any_of(conf_list.cbegin(), conf_list.cend(), [](const ConfigPtr &conf) {
auto eval_result = conf->GetEvaluatedValue();
MS_LOG(DEBUG) << "Propagate isolate nodes flag from: " << eval_result->abstract()->ToString()
<< ", flag: " << eval_result->HasIsolateNodesPropagateCNodeFlag();
return eval_result->HasIsolateNodesPropagateCNodeFlag();
});
return flag;
}
EvalResultPtr AnalysisEngine::EvalCNode(const CNodePtr &cnode, const AnfNodeConfigPtr &conf) {
MS_EXCEPTION_IF_NULL(conf);
MS_EXCEPTION_IF_NULL(cnode);
@ -280,10 +264,10 @@ EvalResultPtr AnalysisEngine::EvalCNode(const CNodePtr &cnode, const AnfNodeConf
AnfNodeConfigPtr func_conf = MakeConfig(func_node, context);
MS_EXCEPTION_IF_NULL(func_conf);
// Keep it in a local variable, otherwise smart pointer will free it.
auto maybe_func_eval_result = func_conf->GetEvaluatedValue();
auto maybe_func_eval_result = func_conf->ObtainEvalResult();
AbstractBasePtr maybe_func = maybe_func_eval_result->abstract();
if (maybe_func == nullptr) {
MS_LOG(EXCEPTION) << "func_conf.GetEvaluatedValue() return null, func_conf: " << func_conf->ToString()
MS_LOG(EXCEPTION) << "No abstract, func_conf: " << func_conf->ToString()
<< " NodeInfo: " << trace::GetDebugInfo(cnode->debug_info());
}
if (maybe_func->BuildType()->type_id() == kObjectTypeUndeterminedType) {
@ -292,8 +276,7 @@ EvalResultPtr AnalysisEngine::EvalCNode(const CNodePtr &cnode, const AnfNodeConf
}
AbstractFunctionPtr func = dyn_cast<AbstractFunction>(maybe_func);
if (func == nullptr) {
MS_LOG(EXCEPTION) << "func_conf.GetEvaluatedValue() return not AbstractFunction: " << maybe_func->ToString()
<< ", func_conf: " << func_conf->ToString()
MS_LOG(EXCEPTION) << "Not AbstractFunction: " << maybe_func->ToString() << ", func_conf: " << func_conf->ToString()
<< " NodeInfo: " << trace::GetDebugInfo(cnode->debug_info());
}
@ -313,21 +296,6 @@ EvalResultPtr AnalysisEngine::EvalCNode(const CNodePtr &cnode, const AnfNodeConf
func->Visit(build_evaluator);
auto eval_result = ExecuteEvaluators(infs, conf, args_conf_list);
auto flag = CheckIsolateNodesPropagateFlag(func, args_conf_list);
if (flag != eval_result->HasIsolateNodesPropagateCNodeFlag()) {
MS_LOG(DEBUG) << "Different propagate isolate nodes flag from: " << eval_result->abstract()->ToString()
<< ", cnode flag: " << eval_result->HasIsolateNodesPropagateCNodeFlag()
<< ", funcgraph flag: " << eval_result->HasIsolateNodesPropagateFuncGraphFlag()
<< ", check flag:" << flag;
// This eval_result may be fetch from an Evaluator's cache based on args_spec_list equality.
// But args may be come from different CNode, so propagate flag is not same,
// a new copy of eval_result should be used.
auto new_eval_result = eval_result->Clone();
// FuncGraph flag should be used for HOF call or used FuncGraph propagate.
flag = flag | new_eval_result->HasIsolateNodesPropagateFuncGraphFlag();
new_eval_result->SetIsolateNodesPropagateCNodeFlag(flag);
eval_result = new_eval_result;
}
return eval_result;
}
@ -349,25 +317,25 @@ void AnalysisEngine::ClearEvaluatorCache() {
for (std::pair<AbstractFunctionPtr, EvaluatorPtr> element : constructors_) {
EvaluatorPtr evaluator = element.second;
MS_EXCEPTION_IF_NULL(evaluator);
MS_EXCEPTION_IF_NULL(evaluator->cache());
evaluator->cache()->clear();
MS_EXCEPTION_IF_NULL(evaluator->evaluator_cache_map());
evaluator->evaluator_cache_map()->clear();
}
for (auto &element : prim_constructors_) {
EvaluatorPtr evaluator = element.second;
MS_EXCEPTION_IF_NULL(evaluator);
MS_EXCEPTION_IF_NULL(evaluator->cache());
evaluator->cache()->clear();
MS_EXCEPTION_IF_NULL(evaluator->evaluator_cache_map());
evaluator->evaluator_cache_map()->clear();
}
for (auto &element : prim_py_evaluators_) {
EvaluatorPtr evaluator = element.second;
MS_EXCEPTION_IF_NULL(evaluator);
MS_EXCEPTION_IF_NULL(evaluator->cache());
evaluator->cache()->clear();
MS_EXCEPTION_IF_NULL(evaluator->evaluator_cache_map());
evaluator->evaluator_cache_map()->clear();
}
}
void AnalysisEngine::Clear() {
cache_.Clear();
analysis_cache_.Clear();
anfnode_config_map_.clear();
eval_trace_.clear();
constructors_.clear();
@ -586,7 +554,7 @@ EvalResultPtr AnalysisEngine::ForwardConfig(const AnfNodeConfigPtr &orig_conf, c
}
}
forward_count_++;
auto res = GetEvaluatedValue(new_conf);
auto res = ObtainEvalResultWithCache(new_conf);
forward_count_--;
return res;
}
@ -651,7 +619,7 @@ EvaluatorPtr AnalysisEngine::HandleNestedRecursion(const std::vector<EvaluatorPt
for (auto u_eval : undetermined_evals) {
MS_LOG(DEBUG) << u_eval.evaluator_->ToString() << "check undetermined.";
auto &alternate_evaluator = multi_poss_[u_eval.evaluator_];
auto &eval_cache = alternate_evaluator->cache();
auto &eval_cache = alternate_evaluator->evaluator_cache_map();
const auto &alt_eval_args = EvaluatorArgs(alternate_evaluator, args_spec_list);
if ((!undetermined_evals.count(alt_eval_args)) &&
(((!continued_evals_.count(u_eval)) && (eval_cache->find(args_spec_list) != eval_cache->end())) ||
@ -698,7 +666,7 @@ EvalResultPtr AnalysisEngine::ExecuteMultipleEvaluators(const std::vector<Evalua
(void)std::transform(args_conf_list.begin(), args_conf_list.end(), std::back_inserter(args_spec_list),
[](const ConfigPtr &conf) -> AbstractBasePtr {
MS_EXCEPTION_IF_NULL(conf);
return conf->GetEvaluatedValue()->abstract();
return conf->ObtainEvalResult()->abstract();
});
for (auto eval : evaluators) {
SetUndeterminedFlag(eval);
@ -741,9 +709,9 @@ EvalResultPtr AnalysisEngine::ExecuteMultipleEvaluators(const std::vector<Evalua
return ProcessEvalResults(out_specs);
}
EvalResultPtr AnfNodeConfig::GetEvaluatedValue() {
EvalResultPtr AnfNodeConfig::ObtainEvalResult() {
AnfNodeConfigPtr self = shared_from_base<AnfNodeConfig>();
return engine_.lock()->GetEvaluatedValue(self);
return engine_.lock()->ObtainEvalResultWithCache(self);
}
abstract::AbstractBasePtr MakeAbstractClosure(const FuncGraphPtr &func_graph,

58
mindspore/ccsrc/pipeline/jit/static_analysis/static_analysis.h
View File

@ -1,7 +1,7 @@
/**
* This is the C++ adaptation and derivative work of Myia (https://github.com/mila-iqia/myia/).
*
* Copyright 2019 Huawei Technologies Co., Ltd
* Copyright 2019-2021 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -46,9 +46,6 @@ namespace abstract {
using AttrValueMap = std::unordered_map<std::string, ValuePtr>;
using AttrValueMapPtr = std::shared_ptr<AttrValueMap>;
inline const int kIsolateNodesPropagateCNodeFlag = 1;
inline const int kIsolateNodesPropagateFuncGraphFlag = 2;
// the class to save evaluated result: abstract value and modified attribute
class EvalResult : public Base {
public:
@ -58,43 +55,10 @@ class EvalResult : public Base {
AbstractBasePtr abstract() { return abstract_; }
AttrValueMapPtr attribute() { return attribute_; }
std::shared_ptr<EvalResult> Clone() const {
auto cloned = std::make_shared<EvalResult>(abstract_, attribute_);
cloned->SetIsolateNodesPropagateCNodeFlag(HasIsolateNodesPropagateCNodeFlag());
cloned->SetIsolateNodesPropagateFuncGraphFlag(HasIsolateNodesPropagateFuncGraphFlag());
return cloned;
}
// The related AbstractBase is evaluated from CNode which input has isolate nodes.
// This flag is propagated to all user node.
// When a node A can be specialized to a ValueNode, we should check if that node A has this flag,
// if it has, then the original FuncGraph call should be depended, so it's side effect will not
// be lost.
bool HasIsolateNodesPropagateCNodeFlag() const {
auto iter = eval_attr_.find(kIsolateNodesPropagateCNodeFlag);
if (iter != eval_attr_.end()) {
return GetValue<bool>(iter->second);
}
return false;
}
void SetIsolateNodesPropagateCNodeFlag(bool flag) { eval_attr_[kIsolateNodesPropagateCNodeFlag] = MakeValue(flag); }
// FuncGraph itself may not have IsoloateNodes, but the used FuncGraph or HOF call may have IsolateNodes;
bool HasIsolateNodesPropagateFuncGraphFlag() const {
auto iter = eval_attr_.find(kIsolateNodesPropagateFuncGraphFlag);
if (iter != eval_attr_.end()) {
return GetValue<bool>(iter->second);
}
return false;
}
void SetIsolateNodesPropagateFuncGraphFlag(bool flag) {
eval_attr_[kIsolateNodesPropagateFuncGraphFlag] = MakeValue(flag);
}
private:
AbstractBasePtr abstract_;
// Attribute related to PrimEvaluator;
AttrValueMapPtr attribute_;
std::unordered_map<int, ValuePtr> eval_attr_;
};
using EvalResultPtr = std::shared_ptr<EvalResult>;
@ -104,7 +68,7 @@ class Config : public Base {
Config() = default;
~Config() override = default;
MS_DECLARE_PARENT(Config, Base);
virtual EvalResultPtr GetEvaluatedValue() = 0;
virtual EvalResultPtr ObtainEvalResult() = 0;
};
// Config will be stored in AnalysisCache
@ -132,7 +96,7 @@ class AnfNodeConfig : public Config {
~AnfNodeConfig() override = default;
MS_DECLARE_PARENT(AnfNodeConfig, Config);
EvalResultPtr GetEvaluatedValue() override;
EvalResultPtr ObtainEvalResult() override;
AnalysisContextPtr context() const { return context_; }
@ -182,7 +146,7 @@ class VirtualConfig : public Config {
~VirtualConfig() override = default;
MS_DECLARE_PARENT(VirtualConfig, Config);
EvalResultPtr GetEvaluatedValue() override {
EvalResultPtr ObtainEvalResult() override {
return std::make_shared<EvalResult>(abstract_, std::make_shared<AttrValueMap>());
}
@ -195,12 +159,12 @@ class AnalysisCache {
public:
AnalysisCache() = default;
~AnalysisCache() = default;
void Clear() { cache_.clear(); }
void Clear() { analysis_cache_map_.clear(); }
void set_value(const AnfNodeConfigPtr &conf, const EvalResultPtr &arg);
EvalResultPtr GetValue(const AnfNodeConfigPtr &conf);
private:
std::unordered_map<AnfNodeConfigPtr, EvalResultPtr, AnfNodeConfigHasher, AnfNodeConfigEqual> cache_;
std::unordered_map<AnfNodeConfigPtr, EvalResultPtr, AnfNodeConfigHasher, AnfNodeConfigEqual> analysis_cache_map_;
};
using PrimEvaluatorMap = std::unordered_map<PrimitivePtr, EvaluatorPtr, PrimitiveHasher, PrimitiveEqual>;
@ -222,7 +186,9 @@ struct PartialAppHasher {
class AnalysisEngine : public std::enable_shared_from_this<AnalysisEngine> {
public:
AnalysisEngine(const PrimEvaluatorMap &prim_evaluator_map, const FuncGraphManagerPtr &func_graph_manager)
: cache_(AnalysisCache()), prim_constructors_(prim_evaluator_map), func_graph_manager_(func_graph_manager) {
: analysis_cache_(AnalysisCache()),
prim_constructors_(prim_evaluator_map),
func_graph_manager_(func_graph_manager) {
function_call_depth_ = 0;
forward_count_ = 0;
}
@ -231,7 +197,7 @@ class AnalysisEngine : public std::enable_shared_from_this<AnalysisEngine> {
// func_graph: The func_graph to analyze.
// args_spec_list: The abstracted arguments for the func_graph. Must be a tuple of AbstractBase.
AnalysisResult Run(const FuncGraphPtr &func_graph, const AbstractBasePtrList &args_spec_list);
EvalResultPtr GetEvaluatedValue(const AnfNodeConfigPtr &conf);
EvalResultPtr ObtainEvalResultWithCache(const AnfNodeConfigPtr &conf);
// Return the Evaluator for the given function.
EvaluatorPtr GetEvaluatorFor(const AbstractFunctionPtr &fn);
@ -241,7 +207,7 @@ class AnalysisEngine : public std::enable_shared_from_this<AnalysisEngine> {
EvalResultPtr Execute(const AbstractFunctionPtr &fn, const AbstractBasePtrList &args_spec_list);
void Clear();
void ClearEvaluatorCache();
AnalysisCache &cache() { return cache_; }
AnalysisCache &analysis_cache() { return analysis_cache_; }
AnfNodeConfigPtr MakeConfig(const AnfNodePtr &node, const AnalysisContextPtr &context) {
return std::make_shared<AnfNodeConfig>(shared_from_this(), node, context);
}
@ -262,7 +228,7 @@ class AnalysisEngine : public std::enable_shared_from_this<AnalysisEngine> {
EvalResultPtr ForwardConfig(const AnfNodeConfigPtr &orig_conf, const AnfNodeConfigPtr new_conf);
const PrimEvaluatorMap &PrimConstructors() const { return prim_constructors_; }
AnalysisCache cache_;
AnalysisCache analysis_cache_;
std::unordered_map<PrimitivePyPtr, EvaluatorPtr> prim_py_evaluators_;
void ResetFunctionCallDepth() { function_call_depth_ = 0; }

13
mindspore/core/abstract/abstract_function.h
View File

@ -1,7 +1,7 @@
/**
* This is the C++ adaptation and derivative work of Myia (https://github.com/mila-iqia/myia/).
*
* Copyright 2019 Huawei Technologies Co., Ltd
* Copyright 2019-2021 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -58,11 +58,6 @@ class AbstractFuncUnion : public AbstractFunction {
bool operator==(const AbstractFunction &other) const override;
std::size_t hash() const override;
AbstractFunctionPtr Copy() const override { MS_LOG(EXCEPTION) << "Cannot Copy from AbstractFuncUnion"; }
bool HasIsolateNodesFlag() const override {
bool flag = std::any_of(func_list_.cbegin(), func_list_.cend(),
[](const AbstractFunctionPtr &func) { return func->HasIsolateNodesFlag(); });
return flag;
}
private:
AbstractFuncAtomPtrList func_list_;
@ -131,8 +126,6 @@ class FuncGraphAbstractClosure : public AbstractFuncAtom {
std::string ToString() const override;
bool HasIsolateNodesFlag() const override { return !func_graph_->isolate_nodes().empty(); }
private:
FuncGraphPtr func_graph_;
AnalysisContextPtr context_;
@ -202,16 +195,12 @@ class PartialAbstractClosure : public AbstractFuncAtom {
std::size_t hash() const override;
std::string ToString() const override;
bool HasIsolateNodesFlag() const override { return isolate_nodes_flag_; }
void SetIsolateNodesFlag(bool flag) { isolate_nodes_flag_ = flag; }
private:
AbstractFuncAtomPtr fn_;
AbstractBasePtrList args_spec_list_;
// The CNode which this PartialAbstractClosure evaluated from.
AnfNodeWeakPtr node_;
// If the bound fn_ has isolate ndoes or arguments evaluated from function has isolate nodes.
bool isolate_nodes_flag_{false};
};
using PartialAbstractClosurePtr = std::shared_ptr<PartialAbstractClosure>;

4
mindspore/core/abstract/abstract_value.h
View File

@ -1,7 +1,7 @@
/**
* This is the C++ adaptation and derivative work of Myia (https://github.com/mila-iqia/myia/).
*
* Copyright 2019-2020 Huawei Technologies Co., Ltd
* Copyright 2019-2021 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -207,8 +207,6 @@ class AbstractFunction : public AbstractBase {
virtual AnfNodePtr tracking_id() const { return nullptr; }
virtual void set_tracking_id(AnfNodePtr) {}
virtual AnalysisContextPtr context() const { return nullptr; }
// Function which itself has IsolateNodes, not include used function or HOF.
virtual bool HasIsolateNodesFlag() const { return false; }
};
using AbstractFunctionPtrList = std::vector<AbstractFunctionPtr>;

4
mindspore/core/abstract/param_validator.cc
View File

@ -157,8 +157,8 @@ void CheckShapeAllPositive(const std::string &op, const ShapeVector &shape) {
void CheckShapeAnyAndPositive(const std::string &op, const ShapeVector &shape) {
for (size_t i = 0; i < shape.size(); ++i) {
if ((shape[i] < 0) && (shape[i] != Shape::SHP_ANY)) {
MS_LOG(EXCEPTION) << op << " shape element [" << i << "] must be positive integer or SHP_ANY, but got "
<< shape[i];
MS_EXCEPTION(ValueError) << op << " shape element [" << i << "] must be positive integer or SHP_ANY, but got "
<< shape[i];
}
}
}

4
mindspore/core/ir/anf.h
View File

@ -1,7 +1,7 @@
/**
* This is the C++ adaptation and derivative work of Myia (https://github.com/mila-iqia/myia/).
*
* Copyright 2019 Huawei Technologies Co., Ltd
* Copyright 2019-2021 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -65,7 +65,7 @@ using CNodePtrList = std::vector<CNodePtr>;
class FuncGraph;
using FuncGraphSet = OrderedSet<FuncGraphPtr>;
using FuncGraphPtrList = std::vector<FuncGraphPtr>;
using FuncGraphVector = std::vector<FuncGraphPtr>;
class Primitive;
using PrimitivePtr = std::shared_ptr<Primitive>;

40
mindspore/core/ir/func_graph.cc
View File

@ -1,7 +1,7 @@
/**
* This is the C++ adaptation and derivative work of Myia (https://github.com/mila-iqia/myia/).
*
* Copyright 2019-2020 Huawei Technologies Co., Ltd
* Copyright 2019-2021 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -602,7 +602,7 @@ void FuncGraph::EraseUnusedNodeInOrder() {
// Erase unused cnode.
for (auto it = order_.begin(); it != order_.end();) {
if (!all_nodes.contains(*it)) {
MS_LOG(DEBUG) << "Remove node " << (*it)->ToString() << " in graph " << ToString() << " order.";
MS_LOG(DEBUG) << "Remove node: " << (*it)->ToString() << " in graph " << ToString() << " order.";
it = order_.erase(it);
continue;
}
@ -616,7 +616,7 @@ void FuncGraph::EraseUnusedNodeInOrder(const AnfNodePtr &node) {
auto cnode = node->cast<CNodePtr>();
if (cnode) {
order_.erase(cnode);
MS_LOG(DEBUG) << "Remove the node" << node->DebugString() << " from order list.";
MS_LOG(DEBUG) << "Remove node: " << node->DebugString() << " from order list.";
}
}
}
@ -648,40 +648,6 @@ void FuncGraph::ReplaceInOrder(const AnfNodePtr &old_node, const AnfNodePtr &new
// Remove old node from order list.
// Unused children nodes can be cleared by EraseUnusedNodeInOrder().
order_.erase(iter);
// Replace isolate node if it is.
ReplaceIsolateNode(old_node, new_node);
}
void FuncGraph::ReplaceIsolateNode(const AnfNodePtr &old_node, const AnfNodePtr &new_node) {
if (isolate_nodes_.erase(old_node) == 0) {
// Skip if old node is not an isloate node.
return;
}
if (!new_node->isa<CNode>()) {
// Isolate node can not replaced by a non-cnode.
LOG(WARNING) << "Try replace isolate node: " << old_node->DebugString() << " with: " << new_node->DebugString();
return;
}
// Replace old node with the new one.
isolate_nodes_.insert(new_node);
// Replace isloate node in manager.
auto graph_manager = manager();
if (graph_manager != nullptr) {
graph_manager->ReplaceIsolateNode(old_node, new_node);
}
}
const std::vector<AnfNodePtr> FuncGraph::GetIsolateNodesInOrder() const {
if (isolate_nodes_.empty()) {
return {};
}
if (isolate_nodes_.size() == 1) {
return std::vector<AnfNodePtr>(isolate_nodes_.cbegin(), isolate_nodes_.cend());
}
std::vector<AnfNodePtr> ordered_isolate_nodes;
std::copy_if(order_.cbegin(), order_.cend(), std::back_inserter(ordered_isolate_nodes),
[&](const auto &node) { return isolate_nodes_.find(node) != isolate_nodes_.end(); });
return ordered_isolate_nodes;
}
static std::vector<AnfNodePtr> MakeInputNodes(const PrimitivePtr &primitive, const std::vector<AnfNodePtr> &inputs) {

106
mindspore/core/ir/func_graph.h
View File

@ -1,7 +1,7 @@
/**
* This is the C++ adaptation and derivative work of Myia (https://github.com/mila-iqia/myia/).
*
* Copyright 2019-2020 Huawei Technologies Co., Ltd
* Copyright 2019-2021 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -94,8 +94,8 @@ class AbstractFunction;
using AbstractFunctionPtr = std::shared_ptr<AbstractFunction>;
} // namespace abstract
// ANF transform class
// either a primitive or a func_graph
// ANF transform class.
// Either a primitive or a func_graph.
class FuncGraphTransform {
public:
enum Type { kGtPrimitive, kGtFuncGraph };
@ -156,11 +156,11 @@ class FuncGraph : public FuncGraphBase, public EffectInfoHolder {
~FuncGraph() override = default;
MS_DECLARE_PARENT(FuncGraph, FuncGraphBase);
// get the graph's abstract
// Get the graph's abstract.
abstract::AbstractFunctionPtr abstract();
abstract::AbstractBasePtr ToAbstract() override;
// return the graph's output, or nullptr if not yet deduced
// Return the graph's output, or nullptr if not yet deduced.
AnfNodePtr output() const;
void set_output(const AnfNodePtr &value, bool force_new_ret = false);
@ -169,28 +169,28 @@ class FuncGraph : public FuncGraphBase, public EffectInfoHolder {
void add_parameter(const ParameterPtr &p);
void append_parameter(const ParameterPtr &p) { parameters_.push_back(p); }
void set_parameters(const std::vector<AnfNodePtr> &params) { parameters_ = params; }
// add a weight parameter with specific name
// Add a weight parameter with specific name.
ParameterPtr AddWeightParameter(const std::string &name);
// create a cnode with given inputs, bound to this graph
// Create a cnode with given inputs, bound to this graph.
virtual CNodePtr NewCNode(const std::vector<AnfNodePtr> &inputs = std::vector<AnfNodePtr>());
virtual CNodePtr NewCNode(const PrimitivePtr &primitive, const std::vector<AnfNodePtr> &prim_inputs);
// create a cnode with given inputs, bound to this graph and push back to order list.
// Create a cnode with given inputs, bound to this graph and push back to order list.
CNodePtr NewCNodeInOrder(const std::vector<AnfNodePtr> &inputs = std::vector<AnfNodePtr>());
CNodePtr NewCNodeInOrder(const PrimitivePtr &primitive, const std::vector<AnfNodePtr> &prim_inputs);
// create a cnode with given inputs, bound to this graph and push back to front of order list.
// Create a cnode with given inputs, bound to this graph and push back to front of order list.
CNodePtr NewCNodeInFront(const std::vector<AnfNodePtr> &inputs = std::vector<AnfNodePtr>());
// create a cnode with given inputs, put it to order list before the position node.
// Create a cnode with given inputs, put it to order list before the position node.
CNodePtr NewCNodeBefore(const AnfNodePtr &position, const std::vector<AnfNodePtr> &inputs);
// create a cnode with given inputs, put it to order list after the position node.
// Create a cnode with given inputs, put it to order list after the position node.
CNodePtr NewCNodeAfter(const AnfNodePtr &position, const std::vector<AnfNodePtr> &inputs);
virtual ParameterPtr add_weight(const tensor::MetaTensorPtr &meta_tensor);
// Functions for handling variable argument, keyword-only arguments and variable keyword argument
// Functions for handling variable argument, keyword-only arguments and variable keyword argument.
AnfNodePtr GetDefaultValueByName(const std::string &name);
void set_param_default_value(const std::string &name, const AnfNodePtr &node) {
parameter_default_value_[name] = node;
@ -253,56 +253,56 @@ class FuncGraph : public FuncGraphBase, public EffectInfoHolder {
}
this->debug_info_ = info;
}
// clear all info from manager
// Clear all info from manager.
void ClearAllManagerInfo();
// get all nodes belonging to this func graph
// Get all nodes belonging to this func graph.
const AnfNodeSet &nodes();
void CopyNodes(const FuncGraphPtr &source);
void ClearNodes();
void AddNode(AnfNodePtr node);
void DropNode(AnfNodePtr node);
// get all value_nodes belonging to this func graph
// Get all value_nodes belonging to this func graph.
const AnfNodeCounterMap &value_nodes();
void CopyValueNodes(const FuncGraphPtr &source);
void ClearValueNodes();
void AddValueNode(AnfNodePtr node, int count = 1);
void DropValueNode(AnfNodePtr node);
// get all free vars directly used in this func graph
// Get all free vars directly used in this func graph.
const AnfNodeCounterMap &free_variables();
void CopyFreeVariables(const FuncGraphPtr &source);
void ClearFreeVariables();
bool AddFreeVariable(AnfNodePtr node, int count = 1);
bool DropFreeVariable(AnfNodePtr node);
// get all vars required by this func graph
// Get all vars required by this func graph.
const BaseRefCounterMap &free_variables_total();
// Return the set of graphs free_variables_total belong to.
std::vector<AnfNodePtr> free_variables_nodes();
// get all vars that are func graphs
// Get all vars that are func graphs
std::vector<FuncGraphPtr> free_variables_func_graphs();
// get all value nodes of func graph directly used by this func graph
// Get all value nodes of func graph directly used by this func graph.
const FuncGraphCounterMap &func_graphs_used();
void CopyFuncGraphsUsed(const FuncGraphPtr &source);
void ClearFuncGraphsUsed();
bool AddFuncGraphUsed(FuncGraphPtr fg, int count = 1);
bool DropFuncGraphUsed(FuncGraphPtr fg);
// get all value nodes in the inputs of J directly used by this func graph
// Get all value nodes in the inputs of J directly used by this func graph.
const std::unordered_map<AnfNodePtr, int> &j_value_nodes();
void CopyJValueNodes(const FuncGraphPtr &source);
void ClearJValueNodes();
void AddJValueNode(const AnfNodePtr &value_node, int count = 1);
void DropJValueNode(const AnfNodePtr &value_node);
// get all func graphs nested used by this func graph
// Get all func graphs nested used by this func graph.
const FuncGraphSet &func_graphs_used_total();
// get all user value nodes of this func graph, by CNode and its input's index
// Get all user value nodes of this func graph, by CNode and its input's index.
const CNodeIndexCounterMap &func_graph_cnodes_index();
void CopyFuncGraphCNodesIndex(const FuncGraphPtr &source);
void ClearFuncGraphCNodesIndex();
@ -318,10 +318,10 @@ class FuncGraph : public FuncGraphBase, public EffectInfoHolder {
// Return the scope of this graph, scope have graph self but children not have.
const FuncGraphSet &scope();
// Return whether this graph is recursive
// Return whether this graph is recursive.
bool recursive();
// Return graphs which forms a recursive loop
// Return graphs which forms a recursive loop.
std::shared_ptr<std::list<FuncGraphPtr>> recursive_graphs();
std::size_t hash() const override { return std::hash<const FuncGraph *>{}(this); }
@ -353,7 +353,7 @@ class FuncGraph : public FuncGraphBase, public EffectInfoHolder {
std::unordered_map<std::string, ValuePtr> attrs_;
std::vector<BaseShapePtr> joined_shapes_;
std::unordered_map<std::string, FuncGraphTransform> transforms_;
// parameter default value
// Parameter default value.
std::map<std::string, AnfNodePtr> parameter_default_value_;
size_t seen_;
@ -377,21 +377,6 @@ class FuncGraph : public FuncGraphBase, public EffectInfoHolder {
// Clear cnode order list.
void ClearOrderList() { order_.clear(); }
// Gets nodes that not related to output, e.g. side-effect calls.
const std::set<AnfNodePtr> &isolate_nodes() const { return isolate_nodes_; }
// Add an isolate node.
void AddIsolateNode(const AnfNodePtr &node) { isolate_nodes_.insert(node); }
// Replace an isolate node.
void ReplaceIsolateNode(const AnfNodePtr &old_node, const AnfNodePtr &new_node);
// Clear isolate nodes.
void ClearIsolateNodes() { isolate_nodes_.clear(); }
// Get isolate nodes with order as OrderList.
const std::vector<AnfNodePtr> GetIsolateNodesInOrder() const;
bool stub() const { return stub_; }
void set_stub(bool stub) { stub_ = stub; }
static void set_drawer(Drawer drawer) { drawer_ = drawer; }
@ -402,54 +387,51 @@ class FuncGraph : public FuncGraphBase, public EffectInfoHolder {
void set_stage(int64_t stage) { stage_ = stage; }
private:
// graph is manipulated by manager and others
// Graph is manipulated by manager and others.
friend FuncGraphManager;
// all nodes of the function
// All nodes of the function.
AnfNodeSet nodes_;
// all value nodes of the function
// All value nodes of the function.
AnfNodeCounterMap value_nodes_;
// all func graph value nodes of the function
// All func graph value nodes of the function.
FuncGraphCounterMap func_graphs_used_;
// all free variables of the function
// All free variables of the function.
AnfNodeCounterMap free_variables_;
// all value nodes calling J in the function
// All value nodes calling J in the function.
std::unordered_map<AnfNodePtr, int> j_value_nodes_;
// all user value nodes of this func graph, recording by CNode and its input's index
// All user value nodes of this func graph, recording by CNode and its input's index.
CNodeIndexCounterMap func_graph_cnodes_index_;
// parameters of this function
// Parameters of this function.
std::vector<AnfNodePtr> parameters_;
// global parameters used by this function.
// Global parameters used by this function.
std::vector<AnfNodePtr> used_global_parameters_;
// isolate nodes, i.e. nodes that not related to output.
std::set<AnfNodePtr> isolate_nodes_;
// whether there is a *args and **kwargs, and count kwonlyargs'number
// Whether there is a *args and **kwargs, and count kwonlyargs'number.
bool has_vararg_;
bool has_kwarg_;
int kwonlyargs_count_;
// the hyper param is placed on the top graph,
// and positioned in the end of the param list, so we record the number to trace the position
// Hyper param is placed on the top graph,
// and positioned in the end of the param list, so we record the number to trace the position.
size_t hyper_param_count_;
// the argument input list for the graph used to generate this graph
// Argument input list for the graph used to generate this graph.
bool is_generated_;
bool is_bprop_;
// the cnode that calls 'return' primitive
// we use shared pointer to manage it.
// CNode that calls 'return' primitive.
// We use shared pointer to manage it.
CNodePtr return_;
// back-ref to its manager
// hold a weak ref to FuncGraphManager as FuncGraphManager also hold many ref to FuncGraph.
// Back-ref to its manager.
// Hold a weak ref to FuncGraphManager as FuncGraphManager also hold many ref to FuncGraph.
// Otherwise, FuncGraph and FuncGraphManager will make a reference cycles.
// Notes: Normally, there will be a global FuncGraphManager, it will hold all FuncGraphs.
// In some ut test cases, they may use local FuncGraphManager in function which
@ -464,12 +446,12 @@ class FuncGraph : public FuncGraphBase, public EffectInfoHolder {
const std::vector<AnfNodePtr> &kwarg_keys_tuple_nodes,
const std::vector<AnfNodePtr> &kwarg_values_tuple_nodes);
// CNode order which relates to origin code order
// CNode order which relates to origin code order.
OrderedSet<CNodePtr> order_;
bool stub_;
inline static Drawer drawer_ = nullptr;
// Design switch_layer_input as a ptr to
// share between derived backpropagator and cloned graphs
// share between derived backpropagator and cloned graphs.
std::shared_ptr<bool> switch_layer_input_;
int64_t stage_;
std::unordered_map<AbstractBasePtrList, FuncGraphPtr, abstract::AbstractBasePtrListHasher,

18
mindspore/core/ir/func_graph_cloner.cc
View File

@ -1,5 +1,5 @@
/**
* Copyright 2019-2020 Huawei Technologies Co., Ltd
* Copyright 2019-2021 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -30,7 +30,7 @@
// namespace to support intermediate representation definition
namespace mindspore {
Cloner::Cloner(const FuncGraphPtrList &func_graphs, bool clone_all_valuenodes, bool clone_all_child_graphs,
Cloner::Cloner(const FuncGraphVector &func_graphs, bool clone_all_valuenodes, bool clone_all_child_graphs,
bool clone_all_used_graphs, const TraceInfoPtr &relation, const TraceInfoPtr &target_relation)
: clone_all_valuenodes_(clone_all_valuenodes),
clone_all_child_graphs_(clone_all_child_graphs),
@ -473,7 +473,6 @@ void Cloner::CloneAllNodes(const FuncGraphPtr &func_graph, const FuncGraphPtr &t
// Only func_graph is inlined, it cannot be found in repl;
if (repl_func_graph_.find(func_graph) != repl_func_graph_.end()) {
CloneOrderList(func_graph, target_func_graph);
CloneIsolateNodes(func_graph, target_func_graph);
}
}
@ -499,15 +498,6 @@ void Cloner::CloneOrderList(const FuncGraphPtr &func_graph, const FuncGraphPtr &
}
}
void Cloner::CloneIsolateNodes(const FuncGraphPtr &func_graph, const FuncGraphPtr &target_func_graph) {
for (auto &node : func_graph->isolate_nodes()) {
auto it = repl_node_.find(node);
if (it != repl_node_.end()) {
target_func_graph->AddIsolateNode(it->second);
}
}
}
void Cloner::Run() {
if (todo_.empty()) {
return;
@ -515,7 +505,7 @@ void Cloner::Run() {
if (type_ < kLifting) {
// Basic and Inline Clone
FuncGraphPtrList func_graphs;
FuncGraphVector func_graphs;
(void)std::transform(todo_.begin(), todo_.end(), std::back_inserter(func_graphs),
[](const CloneInfo &item) -> FuncGraphPtr { return item.origin; });
manager_ = Manage(func_graphs, false);
@ -654,7 +644,7 @@ FuncGraphPtr LiftingClone(const FuncGraphPtr &func_graph) {
ClonerPtr SpecializerClone(const FuncGraphPtr &func_graph, const TraceInfoPtr &relation) {
MS_EXCEPTION_IF_NULL(func_graph);
FuncGraphPtrList func_graphs = {func_graph};
FuncGraphVector func_graphs = {func_graph};
ClonerPtr cloner =
std::make_shared<Cloner>(func_graphs, false, false, false, std::make_shared<TraceCopy>(), relation);
#ifdef ENABLE_PROFILE

5
mindspore/core/ir/func_graph_cloner.h
View File

@ -1,5 +1,5 @@
/**
* Copyright 2019 Huawei Technologies Co., Ltd
* Copyright 2019-2021 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -44,7 +44,7 @@ struct CloneInfo {
class Cloner {
public:
explicit Cloner(const FuncGraphPtrList &func_graphs = {}, bool clone_all_valuenodes = false,
explicit Cloner(const FuncGraphVector &func_graphs = {}, bool clone_all_valuenodes = false,
bool clone_all_child_graphs = true, bool clone_all_used_graphs = false,
const TraceInfoPtr &relation = std::make_shared<TraceCopy>(),
const TraceInfoPtr &target_relation = nullptr);
@ -84,7 +84,6 @@ class Cloner {
bool CheckStatus(const FuncGraphPtr &func_graph, bool is_inline);
void CloneAllNodes(const FuncGraphPtr &func_graph, const FuncGraphPtr &target_func_graph);
void CloneOrderList(const FuncGraphPtr &func_graph, const FuncGraphPtr &target_func_graph);
void CloneIsolateNodes(const FuncGraphPtr &func_graph, const FuncGraphPtr &target_func_graph);
void CloneFuncGraphValueNodes(const FuncGraphPtr &func_graph, const FuncGraphPtr &target_func_graph);
void CloneFuncGraphDefaultValues(const FuncGraphPtr &func_graph, const FuncGraphPtr &target_func_graph);
void InlineCloneParameters(const FuncGraphPtr &func_graph, const AnfNodePtrList &params);

40
mindspore/core/ir/manager.cc
View File

@ -1,7 +1,7 @@
/**
* This is the C++ adaptation and derivative work of Myia (https://github.com/mila-iqia/myia/).
*
* Copyright 2019-2020 Huawei Technologies Co., Ltd
* Copyright 2019-2021 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -188,7 +188,7 @@ bool FuncGraphManager::func_graph_j_total(const FuncGraphPtr &fg) const {
return j_total_->j_total_analysis()[fg];
}
// add a func graph to this manager, optionally as a root func graph.
// Add a func graph to this manager, optionally as a root func graph.
void FuncGraphManager::AddFuncGraph(FuncGraphPtr func_graph, bool is_root) {
MS_EXCEPTION_IF_NULL(func_graph);
if (is_root) {
@ -198,26 +198,23 @@ void FuncGraphManager::AddFuncGraph(FuncGraphPtr func_graph, bool is_root) {
return;
}
// Add func_graph as a managed graph.
AddIntoManaged(func_graph);
// New nodes to be acquired.
std::vector<AnfNodePtr> new_nodes = func_graph->parameters();
new_nodes.emplace_back(func_graph->get_return());
auto &isolate_nodes = func_graph->isolate_nodes();
new_nodes.insert(new_nodes.end(), isolate_nodes.begin(), isolate_nodes.end());
// Add func_graph as a managed graph.
AddIntoManaged(func_graph);
// Acquire all nodes from func_graph.
AcquireNodes(new_nodes);
}
// clear the all information in manager
// Clear the all information in manager
void FuncGraphManager::Clear() {
func_graphs_.clear();
all_nodes_.clear();
node_users_.clear();
roots_.clear();
isolate_nodes_.clear();
signals_->InvalidateComputer();
}
@ -282,8 +279,6 @@ void FuncGraphManager::AddIntoManaged(const FuncGraphPtr &fg) {
FuncGraphManagerPtr this_manager = shared_from_this();
fg->set_manager(this_manager);
}
const auto &fg_isolate_nodes = fg->isolate_nodes();
isolate_nodes_.insert(fg_isolate_nodes.begin(), fg_isolate_nodes.end());
func_graphs_.add(fg);
}
@ -641,29 +636,6 @@ void FuncGraphManager::CommitChanges(const std::vector<Change> &changes) {
MaybeDropFuncGraphs(*drop_func_graphs);
}
void FuncGraphManager::ReplaceIsolateNode(const AnfNodePtr &old_node, const AnfNodePtr &new_node) {
MS_EXCEPTION_IF_NULL(old_node);
MS_EXCEPTION_IF_NULL(new_node);
if (isolate_nodes_.erase(old_node) == 0) {
return;
}
if (!new_node->isa<CNode>()) {
MS_LOG(EXCEPTION) << "Replace isolate node: " << old_node->DebugString()
<< " with non-cnode: " << new_node->DebugString();
}
isolate_nodes_.insert(new_node);
}
void FuncGraphManager::ClearIsolateNodes() {
// If FuncGraph A has IsolateNode which input is FuncGraph B, B had been add to FuncGraph A's valuenode
// by AddFuncGraph api, so if that isolate node is totoaly unused after AutoMonad, FuncGraph B should
// be removed from FuncGraph A's valuenode, otherwise it will confuse FVTotalComputer.
std::vector<AnfNodePtr> isolate_nodes_vec(isolate_nodes_.cbegin(), isolate_nodes_.cend());
auto drop_func_graphs = MaybeDropNodes(isolate_nodes_vec);
MaybeDropFuncGraphs(*drop_func_graphs);
isolate_nodes_.clear();
}
void FuncGraphTransaction::SetParameters(FuncGraphPtr fg, const std::vector<AnfNodePtr> &params) {
changes_.emplace_back(Change::kTxSetParams, ArgsOfSetParams{fg, params});
}

18
mindspore/core/ir/manager.h
View File

@ -1,7 +1,7 @@
/**
* This is the C++ adaptation and derivative work of Myia (https://github.com/mila-iqia/myia/).
*
* Copyright 2019-2020 Huawei Technologies Co., Ltd
* Copyright 2019-2021 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -351,15 +351,6 @@ class FuncGraphManager : public std::enable_shared_from_this<FuncGraphManager> {
IncludeType Limit(const AnfNodePtr &node);
// Gets isolate nodes that not related to output, e.g. side-effect calls.
const std::set<AnfNodePtr> &isolate_nodes() const { return isolate_nodes_; }
// Replace node in isolate node list.
void ReplaceIsolateNode(const AnfNodePtr &old_node, const AnfNodePtr &new_node);
// Clear all isolate nodes.
void ClearIsolateNodes();
// Static Analysis
NodeUsersMap node_users_;
AnfNodeSet all_nodes_; // managed nodes
@ -379,8 +370,8 @@ class FuncGraphManager : public std::enable_shared_from_this<FuncGraphManager> {
void DropEdge(AnfNodePtr node, int index, AnfNodePtr input);
void MoveAllNodes(FuncGraphPtr source, FuncGraphPtr target);
FuncGraphSet roots_; // managed roots
FuncGraphSet func_graphs_; // managed func graphs
FuncGraphSet roots_; // Managed roots.
FuncGraphSet func_graphs_; // Managed func graphs.
std::shared_ptr<Signals> signals_;
@ -393,9 +384,6 @@ class FuncGraphManager : public std::enable_shared_from_this<FuncGraphManager> {
std::shared_ptr<RecursiveComputer> recursive_;
std::shared_ptr<FuncGraphJTotalComputer> j_total_;
// Isolate Nodes
std::set<AnfNodePtr> isolate_nodes_;
bool is_manage_;
std::function<IncludeType(AnfNodePtr)> limit_;
};

4
mindspore/lite/tools/converter/anf_transform.cc
View File

@ -301,7 +301,7 @@ FuncGraphPtr AnfTransform::TransformSingleFuncGraph(const FuncGraphPtr &old_grap
return new_graph;
}
STATUS AnfTransform::GetAllFuncGraph(const FuncGraphPtr &main_graph, FuncGraphPtrList *subgraphs,
STATUS AnfTransform::GetAllFuncGraph(const FuncGraphPtr &main_graph, FuncGraphVector *subgraphs,
std::vector<ValueNodePtr> *vnodes) {
auto nodes = TopoSort(main_graph->get_return());
for (auto &node : nodes) {
@ -324,7 +324,7 @@ FuncGraphPtr AnfTransform::Transform(const FuncGraphPtr &main_graph, const conve
}
// transform sub_graph
FuncGraphPtrList subgraphs{};
FuncGraphVector subgraphs{};
std::vector<ValueNodePtr> vnodes{};
int ret = GetAllFuncGraph(main_graph, &subgraphs, &vnodes);
if (ret != RET_OK) {

3
mindspore/lite/tools/converter/anf_transform.h
View File

@ -36,8 +36,7 @@ class AnfTransform {
FuncGraphPtr Transform(const FuncGraphPtr &old_graph, const converter::Flags *config = nullptr);
private:
STATUS GetAllFuncGraph(const FuncGraphPtr &main_graph, FuncGraphPtrList *subgraphs,
std::vector<ValueNodePtr> *vnodes);
STATUS GetAllFuncGraph(const FuncGraphPtr &main_graph, FuncGraphVector *subgraphs, std::vector<ValueNodePtr> *vnodes);
FuncGraphPtr TransformSingleFuncGraph(const FuncGraphPtr &old_graph, const converter::Flags *config = nullptr);
std::unique_ptr<quant::Quantizer> mQuantizer = nullptr;

4
tests/st/ops/cpu/test_dot_op.py
View File

@ -174,8 +174,8 @@ def test_dot_008():
network = NetDot()
try:
network(x2_tensor, x1_tensor)
except ValueError as e:
assert ValueError == type(e)
except IndexError as e:
assert IndexError == type(e)
@pytest.mark.level0

2
tests/ut/python/nn/test_nn_embedding.py
View File

@ -82,7 +82,7 @@ def test_check_multifield_embedding_false_type_field_id():
@non_graph_engine
def test_check_multifield_embedding_false_input_shape():
with pytest.raises(ValueError):
with pytest.raises(IndexError):
compile_multi_field_embedding((8,), (8, 200), (8, 200),
dtype.int16, dtype.float32, dtype.int16)

8
tests/ut/python/nn/test_ssim.py
View File

@ -84,7 +84,7 @@ def test_ssim_different_shape():
img1 = Tensor(np.random.random(shape_1))
img2 = Tensor(np.random.random(shape_2))
net = SSIMNet()
with pytest.raises(TypeError):
with pytest.raises(ValueError):
_executor.compile(net, img1, img2)
@ -108,9 +108,9 @@ def test_ssim_invalid_5d_input():
invalid_img2 = Tensor(np.random.random(invalid_shape))
net = SSIMNet()
with pytest.raises(TypeError):
with pytest.raises(ValueError):
_executor.compile(net, invalid_img1, img2)
with pytest.raises(TypeError):
with pytest.raises(ValueError):
_executor.compile(net, img1, invalid_img2)
with pytest.raises(TypeError):
with pytest.raises(ValueError):
_executor.compile(net, invalid_img1, invalid_img2)

3
tests/ut/python/pipeline/infer/test_auto_monad.py
View File

@ -186,6 +186,7 @@ def test_user_defined_bad_bprop():
# shoul compile success and Print in presented in the final function graph.
@pytest.mark.skip(reason="isolated nodes exception")
def test_unused_var():
class UnusedVar(nn.Cell):
def __init__(self):
@ -211,6 +212,7 @@ def test_unused_var():
# shoul compile success and Print in presented in the final function graph.
@pytest.mark.skip(reason="isolated nodes exception")
def test_hof_unused_var():
class UnusedVar(nn.Cell):
def __init__(self):
@ -239,6 +241,7 @@ def test_hof_unused_var():
# shoul compile success and Print in presented in the final function graph.
@pytest.mark.skip(reason="isolated nodes exception")
def test_partial_hof_unused_var():
class UnusedVar(nn.Cell):
def __init__(self):