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

Fix some typo errors in pipeline module 

Signed-off-by: leonwanghui <leon.wanghui@huawei.com>
This commit is contained in:
leonwanghui 2020-04-04 13:00:18 +08:00
parent fe49b39c9a
commit ad76e1c42a
22 changed files with 149 additions and 142 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
mindspore/ccsrc/ir/func_graph.cc
View File

@ -64,14 +64,14 @@ AbstractFunctionPtr FuncGraph::abstract() {
for (auto& p : parameters_) {
MS_EXCEPTION_IF_NULL(p);
if (p->abstract() == nullptr) {
MS_LOG(ERROR) << "error!!";
MS_LOG(ERROR) << "Error!!";
return nullptr;
}
args_spec_list.push_back(p->abstract());
}
if (nullptr == output()) {
MS_LOG(ERROR) << "error func graph no output";
MS_LOG(ERROR) << "Error func graph no output";
return nullptr;
}
@ -543,6 +543,7 @@ void FuncGraph::GenerateKwargReplNode(const FuncGraphPtr& specialized_graph,
TraceManager::EndTrace();
}
}
bool FuncGraph::NeedGenerate(const std::vector<abstract::AbstractKeywordArgPtr>& kwarg_list) {
// if the function does not have any vararg/kwarg/kwonly/default value/kw args input
// return the original graph
@ -556,6 +557,7 @@ bool FuncGraph::NeedGenerate(const std::vector<abstract::AbstractKeywordArgPtr>&
}
return true;
}
void FuncGraph::GenerateDefaultValue(const FuncGraphPtr& specialized_graph,
const std::vector<AnfNodePtr>& specialized_parameter_list,
std::unordered_map<AnfNodePtr, AnfNodePtr>* repl_nodes) {
@ -664,7 +666,7 @@ void FuncGraph::EraseUnusedNodeInOrder() {
auto mng = manager_.lock();
if (mng) {
auto nodes = mng->nodes()[shared_from_base<FuncGraph>()];
// Erase unusued cnode.
// Erase unused cnode.
for (auto it = order_.begin(); it != order_.end();) {
if (nodes.count(*it)) {
(void)it++;
@ -695,7 +697,7 @@ void FuncGraph::CheckOrder() {
if (found == it) {
DumpCNodeList();
MS_LOG(EXCEPTION) << "The cnode " << (*it)->DebugString() << " order in " << ToString()
<< " doesn't obey the input denpency, "
<< " doesn't obey the input dependency, "
<< "as input " << input_node->DebugString() << " is not ahead of itself.";
}
}
@ -842,5 +844,5 @@ void FuncGraph::SetEffectDepends(const std::vector<AnfNodePtr>& depend_inputs) {
}
const PrimitivePtr FuncGraphTransform::func_graph_prim_ = std::make_shared<Primitive>("FuncGraph");
const char kFuncGraphFlagUndetermin[] = "Undeterminate";
const char kFuncGraphFlagUndetermined[] = "Undeterminate";
} // namespace mindspore

4
mindspore/ccsrc/ir/func_graph.h
View File

@ -96,7 +96,7 @@ class FuncGraphBase : public Value {
MS_DECLARE_PARENT(FuncGraphBase, Value);
};
extern const char kFuncGraphFlagUndetermin[];
extern const char kFuncGraphFlagUndetermined[];
class FuncGraph : public FuncGraphBase {
public:
@ -200,7 +200,7 @@ class FuncGraph : public FuncGraphBase {
// get all func graphs directly used by this func graph
const FuncGraphCounterMap &func_graphs_used();
// get all func graphs nestedly used by this func graph
// get all func graphs nested used by this func graph
const FuncGraphSet &func_graphs_used_total();
// get all users of this func graph

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

@ -183,7 +183,7 @@ bool SymbolResolveAction(const ResourcePtr& res) {
FuncGraphPtr func_graph = res->func_graph();
auto succ = parse::ResolveFuncGraph(func_graph, res);
// Remove usued nodes in cnode order list.
// Remove unused nodes in cnode order list.
func_graph->EraseUnusedNodeInOrder();
func_graph->ReleaseFullOrderToEffectOrder();
for (auto fg : func_graph->func_graphs_used_total()) {

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

@ -40,7 +40,7 @@ using ExecutorInfoPtr = std::shared_ptr<ExecutorInfo>;
inline std::string GetPhasePrefix(const std::string& phase) {
auto pos = phase.find('.');
if (pos == std::string::npos) {
MS_LOG(EXCEPTION) << "phase has no . for prefix" << phase;
MS_LOG(EXCEPTION) << "Phase has no . for prefix" << phase;
}
return phase.substr(0, pos);
}

21
mindspore/ccsrc/pipeline/parse/data_converter.cc
View File

@ -39,7 +39,7 @@ using TensorPtr = mindspore::tensor::TensorPtr;
namespace {
bool ConvertTuple(const py::object& obj, ValuePtr* const data, bool use_signature) {
MS_LOG(DEBUG) << "converting python tuple";
MS_LOG(DEBUG) << "Converting python tuple";
py::tuple tuple = obj.cast<py::tuple>();
std::vector<ValuePtr> value_list;
for (size_t it = 0; it < tuple.size(); ++it) {
@ -56,7 +56,7 @@ bool ConvertTuple(const py::object& obj, ValuePtr* const data, bool use_signatur
}
bool ConvertList(const py::object& obj, ValuePtr* const data, bool use_signature) {
MS_LOG(DEBUG) << "converting python list";
MS_LOG(DEBUG) << "Converting python list";
py::list list = obj.cast<py::list>();
std::vector<ValuePtr> value_list;
@ -73,7 +73,7 @@ bool ConvertList(const py::object& obj, ValuePtr* const data, bool use_signature
}
bool ConvertCellList(const py::object& obj, ValuePtr* const data, bool use_signature) {
MS_LOG(DEBUG) << "converting cell list";
MS_LOG(DEBUG) << "Converting cell list";
py::sequence list = obj;
std::vector<ValuePtr> value_list;
for (size_t it = 0; it < list.size(); ++it) {
@ -89,7 +89,7 @@ bool ConvertCellList(const py::object& obj, ValuePtr* const data, bool use_signa
}
bool ConvertDict(const py::object& obj, ValuePtr* data, bool use_signature) {
MS_LOG(DEBUG) << "converting python dict";
MS_LOG(DEBUG) << "Converting python dict";
py::dict dict_values = obj.cast<py::dict>();
std::vector<std::pair<std::string, ValuePtr>> key_values;
@ -110,14 +110,14 @@ bool ConvertDict(const py::object& obj, ValuePtr* data, bool use_signature) {
}
void ConvertNameSpace(const py::object& obj, ValuePtr* const data) {
MS_LOG(DEBUG) << "converting python module";
MS_LOG(DEBUG) << "Converting python module";
py::module mod = python_adapter::GetPyModule(PYTHON_MOD_PARSE_MODULE);
py::object module_namespace = python_adapter::CallPyModFn(mod, PYTHON_MOD_GET_MODULE_NAMESPACE, obj);
*data = std::make_shared<NameSpace>(RESOLVE_NAMESPACE_NAME_MODULE, py::cast<py::module>(module_namespace));
}
void ConvertDataClass(py::object obj, ValuePtr* const data) {
MS_LOG(DEBUG) << "converting dataclass";
MS_LOG(DEBUG) << "Converting dataclass";
// Maybe the obj is dataclass define
auto desc = py::cast<std::string>(python_adapter::CallPyObjMethod(obj, PYTHON_GET_OBJ_DESC, obj));
// desc has format "<class xxxx>", strip the '<' and '>' by offset 1;
@ -247,7 +247,7 @@ bool ConvertOtherObj(py::object obj, ValuePtr* const data) {
bool ConvertData(const py::object& obj, ValuePtr* const data, bool use_signature) {
// check parameter valid
if (data == nullptr) {
MS_LOG(ERROR) << " data is null pointer";
MS_LOG(ERROR) << "Data is null pointer";
return false;
}
@ -386,9 +386,9 @@ py::object CreatePythonObject(const py::object& type, const py::tuple& params) {
py::module mod = python_adapter::GetPyModule(PYTHON_MOD_PARSE_MODULE);
py::object obj;
if (params.size() == 0) {
obj = python_adapter::CallPyModFn(mod, PYTHON_MOD_CRETAE_OBJ_INSTANCE, type);
obj = python_adapter::CallPyModFn(mod, PYTHON_MOD_CREATE_OBJ_INSTANCE, type);
} else {
obj = python_adapter::CallPyModFn(mod, PYTHON_MOD_CRETAE_OBJ_INSTANCE, type, params);
obj = python_adapter::CallPyModFn(mod, PYTHON_MOD_CREATE_OBJ_INSTANCE, type, params);
}
return obj;
}
@ -421,6 +421,7 @@ ValuePtr PyDataToValue(const py::object& obj) {
(void)ConvertData(to_convert, &value);
return value;
}
void ClearObjectCache() {
object_map_.clear();
object_graphs_map_.clear();
@ -445,7 +446,7 @@ ClassPtr ParseDataClass(const py::object& cls_obj) {
for (auto& item : names) {
TypePtr type_value = item.second.cast<TypePtr>();
MS_EXCEPTION_IF_NULL(type_value);
MS_LOG(DEBUG) << "(name: " << py::cast<std::string>(item.first) << ", type: " << type_value->ToString() << ")";
MS_LOG(DEBUG) << "(Name: " << py::cast<std::string>(item.first) << ", type: " << type_value->ToString() << ")";
attributes.push_back(std::make_pair(py::cast<std::string>(item.first), type_value));
}

4
mindspore/ccsrc/pipeline/parse/function_block.cc
View File

@ -254,7 +254,7 @@ void FunctionBlock::Mature() {
matured_ = true;
}
// Force the conditon node to bool using bool operation
// Force the conditIon node to bool using bool operation
CNodePtr FunctionBlock::ForceToBoolNode(const AnfNodePtr& cond) {
TraceManager::DebugTrace(std::make_shared<TraceForceBool>(cond->debug_info()));
CNodePtr op_apply_node = func_graph()->NewCNode({MakeResolveOperation(NAMED_PRIMITIVE_BOOL), cond});
@ -347,7 +347,7 @@ void FunctionBlock::InsertDependItemsBeforeReturn() {
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";
MS_LOG(EXCEPTION) << "Length of inputs of output node is less than 2";
}
old_ret = return_node->input(1);
} else {

50
mindspore/ccsrc/pipeline/parse/parse.cc
View File

@ -294,14 +294,14 @@ FunctionBlockPtr Parser::ParseStatement(const FunctionBlockPtr &block, const py:
TraceManager::EndTrace();
return stmt_block;
} else {
errcode_ = PARSE_NODE_METHOD_UNSUPPORT;
errcode_ = PARSE_NODE_METHOD_UNSUPPORTED;
py::list location = ast_->CallParserObjMethod(PYTHON_PARSE_GET_LOCATION, node);
if (location.size() < 2) {
MS_LOG(EXCEPTION) << "List size should not be less than 2.";
}
auto filename = location[0].cast<std::string>();
auto line_no = location[1].cast<int>();
MS_LOG(EXCEPTION) << "unsupported syntax '" << node_name << "' at " << filename << ":" << line_no;
MS_LOG(EXCEPTION) << "Unsupported syntax '" << node_name << "' at " << filename << ":" << line_no;
}
}
@ -324,11 +324,11 @@ AnfNodePtr Parser::ParseExprNode(const FunctionBlockPtr &block, const py::object
TraceManager::EndTrace();
return expr_node;
} else {
errcode_ = PARSE_NODE_METHOD_UNSUPPORT;
errcode_ = PARSE_NODE_METHOD_UNSUPPORTED;
py::list ret = ast_->CallParserObjMethod(PYTHON_PARSE_GET_LOCATION, node);
auto filename = ret[0].cast<std::string>();
auto line_no = ret[1].cast<int>();
MS_LOG(EXCEPTION) << "unsupported syntax '" << node_name << "' at " << filename << ":" << line_no;
MS_LOG(EXCEPTION) << "Unsupported syntax '" << node_name << "' at " << filename << ":" << line_no;
}
}
@ -339,7 +339,7 @@ FunctionBlockPtr Parser::ParseExpr(const FunctionBlockPtr &block, const py::obje
// Expr only have value , no target
py::tuple expand_info = ast_->CallParserObjMethod(PYTHON_PARSE_EXPAND_EXPR_STATEMENT, node);
// refer pypthon 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
@ -453,8 +453,8 @@ AnfNodePtr Parser::ParseNum(const FunctionBlockPtr &, const py::object &node) {
return NewValueNode(data);
} else {
// no else actually
MS_LOG(ERROR) << "unsupported Num type : " << (std::string)py::str(obj) << GetLocation(node)->ToString();
errcode_ = PARSE_NODE_TYPE_UNKONW;
MS_LOG(ERROR) << "Unsupported Num type : " << (std::string)py::str(obj) << GetLocation(node)->ToString();
errcode_ = PARSE_NODE_TYPE_UNKOWN;
return nullptr;
}
}
@ -478,8 +478,8 @@ AnfNodePtr Parser::ParseNameConstant(const FunctionBlockPtr &, const py::object
return NewValueNode(kNone);
} else {
// no else actually
MS_LOG(ERROR) << "unsupported NameConstant type: " << (std::string)py::str(obj) << GetLocation(node)->ToString();
errcode_ = PARSE_NODE_TYPE_UNKONW;
MS_LOG(ERROR) << "Unsupported NameConstant type: " << (std::string)py::str(obj) << GetLocation(node)->ToString();
errcode_ = PARSE_NODE_TYPE_UNKOWN;
return nullptr;
}
}
@ -497,7 +497,7 @@ AnfNodePtr Parser::ParseCall(const FunctionBlockPtr &block, const py::object &no
// process function call
py::object function_ast_node = python_adapter::GetPyObjAttr(node, "func");
AnfNodePtr call_function_anf_node = ParseExprNode(block, function_ast_node);
// function call arguments should be passed in as groups and upacked later using unpack call
// function call arguments should be passed in as groups and unpacked later using unpack call
py::list args = python_adapter::GetPyObjAttr(node, "args");
std::vector<AnfNodePtr> packed_arguments;
std::vector<AnfNodePtr> group_arguments;
@ -614,7 +614,7 @@ AnfNodePtr Parser::ParseAttribute(const FunctionBlockPtr &block, const py::objec
py::object value_body = python_adapter::GetPyObjAttr(node, "value");
AnfNodePtr value_node = ParseExprNode(block, value_body);
if (value_node == nullptr) {
MS_LOG(WARNING) << "Parse Attribut failed";
MS_LOG(WARNING) << "Parse attribute failed";
return nullptr;
}
@ -637,7 +637,7 @@ AnfNodePtr Parser::ParseCompare(const FunctionBlockPtr &block, const py::object
// 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();
MS_LOG(ERROR) << "MindSpore does not support comparison with operators more than one now, ops size =" << ops.size();
return nullptr;
}
@ -817,7 +817,7 @@ AnfNodePtr Parser::ParseIndex(const FunctionBlockPtr &block, const py::object &n
// process a UnaryOp, +a, -b
AnfNodePtr Parser::ParseUnaryOp(const FunctionBlockPtr &block, const py::object &node) {
MS_LOG(DEBUG) << "process ast UnaryOp";
MS_LOG(DEBUG) << "Process ast UnaryOp";
py::object op = python_adapter::GetPyObjAttr(node, "op");
MS_EXCEPTION_IF_NULL(block);
@ -831,7 +831,7 @@ AnfNodePtr Parser::ParseUnaryOp(const FunctionBlockPtr &block, const py::object
// process a dict ast node expression
AnfNodePtr Parser::ParseDict(const FunctionBlockPtr &block, const py::object &node) {
MS_LOG(DEBUG) << "process ast Dict";
MS_LOG(DEBUG) << "Process ast Dict";
py::list keys = node.attr("keys");
py::list values = node.attr("values");
std::vector<AnfNodePtr> key_nodes;
@ -849,7 +849,7 @@ AnfNodePtr Parser::ParseDict(const FunctionBlockPtr &block, const py::object &no
// process a augment assign such as a += b;
FunctionBlockPtr Parser::ParseAugAssign(const FunctionBlockPtr &block, const py::object &node) {
MS_LOG(DEBUG) << "process ast AugAssign";
MS_LOG(DEBUG) << "Process ast AugAssign";
py::object op = python_adapter::GetPyObjAttr(node, "op");
MS_EXCEPTION_IF_NULL(block);
@ -864,10 +864,10 @@ FunctionBlockPtr Parser::ParseAugAssign(const FunctionBlockPtr &block, const py:
} else if (ast_->IsClassMember(target_node)) {
read_node = ParseAttribute(block, target_node);
} else {
MS_LOG(EXCEPTION) << "not supported augassign";
MS_LOG(EXCEPTION) << "Not supported augassign";
}
if (read_node == nullptr) {
MS_LOG(EXCEPTION) << "can not get target node ";
MS_LOG(EXCEPTION) << "Can not get target node ";
}
py::object value = python_adapter::GetPyObjAttr(node, "value");
@ -879,7 +879,7 @@ FunctionBlockPtr Parser::ParseAugAssign(const FunctionBlockPtr &block, const py:
// process global declaration such as 'global x';
FunctionBlockPtr Parser::ParseGlobal(const FunctionBlockPtr &block, const py::object &node) {
MS_LOG(DEBUG) << "process ast Global";
MS_LOG(DEBUG) << "Process ast Global";
MS_EXCEPTION_IF_NULL(block);
py::list vars = python_adapter::GetPyObjAttr(node, "names");
for (auto &item : vars) {
@ -890,7 +890,7 @@ FunctionBlockPtr Parser::ParseGlobal(const FunctionBlockPtr &block, const py::ob
// process a if statement
FunctionBlockPtr Parser::ParseIf(const FunctionBlockPtr &block, const py::object &node) {
MS_LOG(DEBUG) << "process ast If";
MS_LOG(DEBUG) << "Process ast If";
py::object test_node = python_adapter::GetPyObjAttr(node, "test");
AnfNodePtr condition_node = ParseExprNode(block, test_node);
MS_EXCEPTION_IF_NULL(block);
@ -934,7 +934,7 @@ FunctionBlockPtr Parser::ParseIf(const FunctionBlockPtr &block, const py::object
}
FunctionBlockPtr Parser::ParseWhile(const FunctionBlockPtr &block, const py::object &node) {
MS_LOG(DEBUG) << "process ast While";
MS_LOG(DEBUG) << "Process ast While";
MS_EXCEPTION_IF_NULL(block);
MS_LOG(INFO) << "Parse while statement";
TraceManager::DebugTrace(std::make_shared<TraceWhileHeader>(block->func_graph()->debug_info()));
@ -999,7 +999,7 @@ FunctionBlockPtr Parser::GenerateBlockInFor(const TraceInfoPtr &trace_info) {
// x, it = next(it)
// body
FunctionBlockPtr Parser::ParseFor(const FunctionBlockPtr &block, const py::object &node) {
MS_LOG(DEBUG) << "process ast For";
MS_LOG(DEBUG) << "Process ast For";
MS_EXCEPTION_IF_NULL(block);
AnfNodePtr op_iter = block->MakeResolveOperation(NAMED_PRIMITIVE_ITER);
AnfNodePtr op_next = block->MakeResolveOperation(NAMED_PRIMITIVE_NEXT);
@ -1054,7 +1054,7 @@ FunctionBlockPtr Parser::ParseFor(const FunctionBlockPtr &block, const py::objec
return after_block;
}
AnfNodePtr Parser::ParseIfExp(const FunctionBlockPtr &block, const py::object &node) {
MS_LOG(DEBUG) << "process ast IfExp";
MS_LOG(DEBUG) << "Process ast IfExp";
MS_EXCEPTION_IF_NULL(block);
py::object test_node = python_adapter::GetPyObjAttr(node, "test");
AnfNodePtr condition_node = ParseExprNode(block, test_node);
@ -1163,7 +1163,7 @@ void Parser::HandleAssignSubscript(const FunctionBlockPtr &block, const py::obje
void Parser::WriteAssignVars(const FunctionBlockPtr &block, const py::object &targ, const AnfNodePtr &value_node) {
MS_EXCEPTION_IF_NULL(value_node);
MS_LOG(DEBUG) << "process WriteAssignVars";
MS_LOG(DEBUG) << "Process WriteAssignVars";
auto ast_type = AstSubType(py::cast<int32_t>(ast_->CallParserObjMethod(PYTHON_PARSE_GET_AST_TYPE, targ)));
if (ast_type == AST_SUB_TYPE_NAME) {
HandleAssignName(block, targ, value_node);
@ -1174,7 +1174,7 @@ void Parser::WriteAssignVars(const FunctionBlockPtr &block, const py::object &ta
} else if (ast_->IsClassMember(targ)) {
HandleAssignClassMember(block, targ, value_node);
} else {
MS_LOG(EXCEPTION) << "not supported assign type: " << ast_type
MS_LOG(EXCEPTION) << "Not supported assign type: " << ast_type
<< " NodeInfo: " << trace::GetDebugInfo(value_node->debug_info());
}
}
@ -1340,7 +1340,7 @@ bool ParseAst::UpdateFuncGraphFlags(const FuncGraphPtr &func_graph) {
py::dict flags = python_adapter::GetPyObjAttr(obj_, PYTHON_EXTERN_MINDSPORE_FLAG);
for (auto &item : flags) {
if (!py::isinstance<py::str>(item.first) || !py::isinstance<py::bool_>(item.second)) {
MS_LOG(ERROR) << "type error in flags dict convert";
MS_LOG(ERROR) << "Type error in flags dict convert";
return false;
}
auto name = py::cast<std::string>(item.first);

6
mindspore/ccsrc/pipeline/parse/parse.h
View File

@ -40,8 +40,8 @@ enum ParseStatusCode : int {
PARSE_PARAMETER_INVALID, // parameter is invalid
PARSE_NO_RETURN, // function no return node
PARSE_NODE_TYPE_NO_MATCH, // ast node type is error
PARSE_NODE_TYPE_UNKONW, // node type is unkonw
PARSE_NODE_METHOD_UNSUPPORT, // no method to parse the node
PARSE_NODE_TYPE_UNKOWN, // node type is unkown
PARSE_NODE_METHOD_UNSUPPORTED, // no method to parse the node
PARSE_DONT_RESOLVE_SYMBOL, // can't resolve the string
PARSE_NOT_SUPPORTED_COMPARE_EXPR, // the comparison is not supported
PARSE_FAILURE = 0xFF
@ -102,7 +102,7 @@ class Parser {
AnfNodePtr ParseCall(const FunctionBlockPtr &block, const py::object &node);
// process the if expression
AnfNodePtr ParseIfExp(const FunctionBlockPtr &block, const py::object &node);
// process calss type define
// process class type define
AnfNodePtr ParseAttribute(const FunctionBlockPtr &block, const py::object &node);
// process a compare expression
AnfNodePtr ParseCompare(const FunctionBlockPtr &block, const py::object &node);

4
mindspore/ccsrc/pipeline/parse/parse_base.h
View File

@ -45,7 +45,7 @@ enum AstSubType : int {
// define the parse target type
enum ParseTargetTypeDef {
PARSE_TARGET_FUNCTION = 0, // funciton
PARSE_TARGET_FUNCTION = 0, // function
PARSE_TARGET_METHOD = 1, // method
PARSE_TARGET_OBJECT_INSTANCE = 2, // object instance
PARSE_TARGET_UNKNOW = 0xFF // ERROR TYPE
@ -59,7 +59,7 @@ const char PYTHON_MOD_RESOLVE_GET_OBJ_KEY[] = "get_object_key";
const char PYTHON_MOD_PARSE_CHECK_IS_CLASS_MEMBER[] = "is_class_member";
const char PYTHON_MOD_RESOLVE_GET_OBJ_TYPE[] = "get_obj_type";
const char PYTHON_MOD_GET_CLASS_INSTANCE_TYPE[] = "get_class_instance_type";
const char PYTHON_MOD_CRETAE_OBJ_INSTANCE[] = "create_obj_instance";
const char PYTHON_MOD_CREATE_OBJ_INSTANCE[] = "create_obj_instance";
const char PYTHON_MOD_GET_DATACLASS_ATTRS[] = "get_dataclass_attributes";
const char PYTHON_MOD_GET_DATACLASS_METHODS[] = "get_dataclass_methods";
const char PYTHON_MOD_GET_MODULE_NAMESPACE[] = "get_module_namespace";

2
mindspore/ccsrc/pipeline/parse/python_adapter.cc
View File

@ -50,6 +50,7 @@ void SetPythonPath(const std::string& path) {
(void)sys_path.attr("append")(path.c_str());
}
}
std::shared_ptr<py::scoped_interpreter> set_python_scoped() {
// if start process from python, no need set the python scope.
if (!python_env_) {
@ -79,6 +80,7 @@ py::object GetPyObjAttr(const py::object& obj, const std::string& attr) {
}
return py::none();
}
py::object GetPyFn(const std::string& module, const std::string& name) {
(void)python_adapter::set_python_scoped();
if (!module.empty() && !name.empty()) {

6
mindspore/ccsrc/pipeline/parse/resolve.cc
View File

@ -53,6 +53,7 @@ abstract::AbstractBasePtr ClassType::ToAbstract() {
ret_val->set_value_desc(ToString());
return ret_val;
}
// call python PYTHON_MOD_RESOLVE_FUNCTION interface to resolve the symbol in corresponding namespace
bool SymbolResolver::Resolve() {
py::module mod = python_adapter::GetPyModule(PYTHON_MOD_PARSE_MODULE);
@ -127,7 +128,7 @@ bool ResolveObjectToNode(const FuncGraphPtr& func_graph, const py::object& obj,
MS_LOG(ERROR) << "Resolve parameter object failed, got nullptr";
return false;
}
MS_LOG(DEBUG) << "add param graph:" << func_graph->ToString() << ", " << param->DebugString();
MS_LOG(DEBUG) << "Add param graph:" << func_graph->ToString() << ", " << param->DebugString();
output = param;
} else if (py::hasattr(obj, "__parameter_tuple__")) {
@ -160,6 +161,7 @@ bool ResolveObjectToNode(const FuncGraphPtr& func_graph, const py::object& obj,
*node = output;
return true;
}
// transform the ValueTuple or ValueList of graph node to make tuple of const graph node
bool TransformVectorGraphValueNode(const FuncGraphManagerPtr& manager, const AnfNodePtr& node,
const ValueNodePtr& value_node, AnfNodePtr* const transformed) {
@ -175,7 +177,7 @@ bool TransformVectorGraphValueNode(const FuncGraphManagerPtr& manager, const Anf
continue;
}
if (has_graph_in_list) {
MS_LOG(EXCEPTION) << "list has graph in it , but not all is graph";
MS_LOG(EXCEPTION) << "List has graph in it, but not all is graph";
}
}
// The celllist or ordered_cell will be parsed as valuetuple of const graph in it,

4
mindspore/ccsrc/pipeline/pass.cc
View File

@ -195,13 +195,13 @@ void ReclaimOptimizer() {
bool OptPassGroup(const ResourcePtr& res, const std::string& name) {
if (res->func_graph() == nullptr) {
MS_LOG(ERROR) << "opt passes int error";
MS_LOG(ERROR) << "Opt passes int error";
return false;
}
abstract::AbstractBasePtrList args = res->args_spec();
FuncGraphPtr func_graph = res->func_graph();
MS_LOG(DEBUG) << "start " << name << " func graph:" << func_graph->ToString() << ", "
MS_LOG(DEBUG) << "Start " << name << " func graph:" << func_graph->ToString() << ", "
<< func_graph->get_return()->DebugString(true);
InitOpt(res);
if (g_pass_opts.find(name) != g_pass_opts.end()) {

70
mindspore/ccsrc/pipeline/pipeline.cc
View File

@ -98,7 +98,7 @@ py::tuple GenerateKey(const std::string& name, const std::unordered_map<std::str
}
if (g_args_cache.count(args_spec) == 0) {
static int key = 0;
MS_LOG(INFO) << "start new args and compile key:" << key;
MS_LOG(INFO) << "Start new args and compile key:" << key;
g_args_cache[args_spec] = key++;
}
py::tuple argSpec = py::tuple(2);
@ -110,7 +110,7 @@ py::tuple GenerateKey(const std::string& name, const std::unordered_map<std::str
py::bool_ VerifyInputSignature(const py::list input_signature, const py::tuple inputs) {
MS_LOG(DEBUG) << "Verify args size:" << inputs.size();
if (inputs.size() != input_signature.size()) {
MS_LOG(ERROR) << "signature size not equal to args size";
MS_LOG(ERROR) << "Signature size not equal to args size";
return false;
}
@ -148,7 +148,7 @@ py::bool_ VerifyInputSignature(const py::list input_signature, const py::tuple i
ExecutorPy::ExecutorPy() {}
ResourcePtr ExecutorPy::GetResource(const std::string& phase) {
MS_LOG(DEBUG) << "phase size:" << info_.size();
MS_LOG(DEBUG) << "Phase size:" << info_.size();
if (info_.count(phase) == 0) {
return nullptr;
}
@ -157,14 +157,14 @@ ResourcePtr ExecutorPy::GetResource(const std::string& phase) {
FuncGraphPtr ExecutorPy::GetFuncGraph(const std::string& phase) {
if (info_.count(phase) == 0) {
MS_LOG(EXCEPTION) << "no phase in executor:" << GetPhasePrefix(phase);
MS_LOG(EXCEPTION) << "No phase in executor:" << GetPhasePrefix(phase);
}
return info_[phase]->func_graph;
}
std::size_t ExecutorPy::ArgListSize(const std::string& phase) {
if (info_.count(phase) == 0) {
MS_LOG(EXCEPTION) << "no phase in executor:" << GetPhasePrefix(phase);
MS_LOG(EXCEPTION) << "No phase in executor:" << GetPhasePrefix(phase);
}
return info_[phase]->arg_list_size;
}
@ -243,7 +243,7 @@ void ExecutorPy::DelNetRes(const std::string& id) {
auto tmp_info = info_;
for (auto& item : tmp_info) {
if (item.first.find(id) != string::npos) {
MS_LOG(INFO) << "delete network res:" << item.first;
MS_LOG(INFO) << "Delete network res:" << item.first;
(void)info_.erase(item.first);
flag = true;
}
@ -262,7 +262,7 @@ void ExecutorPy::DelNetRes(const std::string& id) {
}
void ExecutorPy::ClearRes() {
MS_LOG(INFO) << "clean executor Resrouce!";
MS_LOG(INFO) << "Clean executor resource!";
executor_ = nullptr;
}
@ -278,27 +278,27 @@ void ExecutorPy::SaveCompiledGraph(const std::string& phase_s) {
MS_EXCEPTION_IF_NULL(parallel::ParallelContext::GetInstance());
std::string parallel_mode = parallel::ParallelContext::GetInstance()->parallel_mode();
MS_LOG(INFO) << "save compiled func graph(" << func_graph->ToString() << ") phase(" << phase_s << ")!";
MS_LOG(INFO) << "Save compiled func graph(" << func_graph->ToString() << ") phase(" << phase_s << ")!";
info_[phase_s]->func_graph = func_graph;
if ((func_graph != nullptr) &&
((parallel_mode == parallel::AUTO_PARALLEL) || (parallel_mode == parallel::SEMI_AUTO_PARALLEL))) {
MS_LOG(DEBUG) << "save model parallel parameter layout graph!";
MS_LOG(DEBUG) << "Save model parallel parameter layout graph!";
func_graph = info_[phase_s]->resource->results()[kStepParallelGraph].cast<FuncGraphPtr>();
ExecutorInfoPtr excutor_info = std::make_shared<ExecutorInfo>();
ExecutorInfoPtr executor_info = std::make_shared<ExecutorInfo>();
std::string layout_graph = phase_s + kStepParallelGraph;
excutor_info->func_graph = func_graph;
info_[layout_graph] = excutor_info;
executor_info->func_graph = func_graph;
info_[layout_graph] = executor_info;
} else {
MS_LOG(DEBUG) << "save model parallel parameter layout graph null!";
MS_LOG(DEBUG) << "Save model parallel parameter layout graph null!";
}
MS_LOG(INFO) << "end save compiled func graph!";
MS_LOG(INFO) << "End save compiled func graph!";
}
bool ExecutorPy::ChangeExportGeirUseVmFlag(bool use_vm, const std::string& phase_s) const {
std::string phase_prefix = GetPhasePrefix(phase_s);
if (use_vm && phase_prefix == "export") {
MS_LOG(INFO) << "use ge backend to export geir";
MS_LOG(INFO) << "Use ge backend to export geir";
use_vm = false;
}
return use_vm;
@ -316,7 +316,7 @@ void ExecutorPy::GetGeBackendPolicy() const {
bool ExecutorPy::CompileInner(const py::object& obj, const py::tuple& args, const py::object& phase, bool use_vm) {
MS_LOG(DEBUG) << "Start ExecutorPy compile!";
if ((!py::isinstance<py::str>(phase))) {
MS_LOG(ERROR) << "arg phase must be string.";
MS_LOG(ERROR) << "Arg phase must be string.";
return false;
}
// check the arg valid?
@ -327,7 +327,7 @@ bool ExecutorPy::CompileInner(const py::object& obj, const py::tuple& args, cons
#ifdef ENABLE_GE
GetGeBackendPolicy();
#endif
ExecutorInfoPtr excutor_info = std::make_shared<ExecutorInfo>();
ExecutorInfoPtr executor_info = std::make_shared<ExecutorInfo>();
std::string phase_s = py::cast<std::string>(phase);
MS_LOG(INFO) << "ExecutorPy compile phase:" << phase_s << "!";
ResourcePtr resource = std::make_shared<Resource>(obj);
@ -353,16 +353,16 @@ bool ExecutorPy::CompileInner(const py::object& obj, const py::tuple& args, cons
ValuePtr converted = nullptr;
bool succ = parse::ConvertData(args[i], &converted);
if (!succ) {
MS_LOG(EXCEPTION) << "args convert error";
MS_LOG(EXCEPTION) << "Args convert error";
}
bool broaden = true;
args_spec.push_back(abstract::FromValue(converted, broaden));
}
resource->set_args_spec(args_spec);
excutor_info->arg_list_size = size;
excutor_info->resource = resource;
info_[phase_s] = excutor_info;
executor_info->arg_list_size = size;
executor_info->resource = resource;
info_[phase_s] = executor_info;
pip->Run();
// save the run graph func to MsPipeLine
@ -439,7 +439,7 @@ std::string GetMsIrFile(void) {
char real_path[PATH_MAX] = {0};
if (realpath(path, real_path) == nullptr) {
MS_LOG(ERROR) << "MS IR Path error, " << path;
MS_LOG(ERROR) << "MS IR path error, " << path;
return file;
}
file = real_path;
@ -485,7 +485,7 @@ void RunPipelineAction(const ActionItem& action, pipeline::ResourcePtr resource,
#endif
void Pipeline::Run() {
MS_LOG(INFO) << "pipeline run";
MS_LOG(INFO) << "Pipeline run";
MS_EXCEPTION_IF_NULL(resource_);
FuncGraphPtr user_graph = nullptr;
@ -507,7 +507,7 @@ void Pipeline::Run() {
MS_LOG(DEBUG) << "Action " << action.first << " end.";
};
if (!result) {
MS_LOG(EXCEPTION) << "pipeline running to end, failed in step:" << action.first;
MS_LOG(EXCEPTION) << "Pipeline running to end, failed in step:" << action.first;
}
if (MsContext::GetInstance()->save_graphs_flag() && resource_->func_graph() != nullptr) {
auto graph = resource_->func_graph();
@ -555,7 +555,7 @@ void Pipeline::Run() {
if (MsContext::GetInstance()->save_graphs_flag() && (user_graph != nullptr)) {
std::string user_graph_file = GetFilePathName("ModelDigraph.dot");
MS_LOG(DEBUG) << "save user graph to: " << user_graph_file;
MS_LOG(DEBUG) << "Save user graph to: " << user_graph_file;
draw::DrawUserFuncGraph(user_graph_file, user_graph);
#ifdef ENABLE_DUMP_IR
@ -572,7 +572,7 @@ void Pipeline::Run() {
ChangeFileMode(filename, S_IRUSR);
#endif
}
MS_LOG(INFO) << "end";
MS_LOG(INFO) << "End";
}
void ExecutorPy::ProcessVmArg(const py::tuple& args, const std::string& phase, VectorRef* arg_list) {
@ -582,7 +582,7 @@ void ExecutorPy::ProcessVmArg(const py::tuple& args, const std::string& phase, V
py::object arg = args[i];
auto ms_context = MsContext::GetInstance();
if (ms_context->backend_policy() == kMsConvert && py::isinstance<py::array>(arg)) {
MS_LOG(EXCEPTION) << "args[" << i << "] is numpy array, not tensor";
MS_LOG(EXCEPTION) << "Args[" << i << "] is numpy array, not tensor";
}
(*arg_list).push_back(arg);
}
@ -642,9 +642,9 @@ py::object ExecutorPy::Run(const py::tuple& args, const py::object& phase) {
MS_LOG(EXCEPTION) << "Can't find run graph func for " << phase_s;
}
MS_LOG(DEBUG) << "eval run" << backend;
MS_LOG(DEBUG) << "Eval run" << backend;
BaseRef value = (*run)(arg_list);
MS_LOG(DEBUG) << "run end";
MS_LOG(DEBUG) << "Run end";
return BaseRefToPyData(value);
}
@ -704,9 +704,9 @@ bool InitExecDatasetVm(const std::string& queue_name, int64_t size, int64_t batc
p_init->set_attr("shapes", MakeValue(int_shapes));
p_init->set_attr("input_indexes", MakeValue(int_input_indexes));
const std::vector<std::string> emply_str_list;
p_init->set_attr("input_names", MakeValue(emply_str_list));
p_init->set_attr("output_names", MakeValue(emply_str_list));
const std::vector<std::string> empty_str_list;
p_init->set_attr("input_names", MakeValue(empty_str_list));
p_init->set_attr("output_names", MakeValue(empty_str_list));
FuncGraphPtr func_graph = std::make_shared<FuncGraph>();
auto app_init = std::make_shared<CNode>(AnfNodePtrList{NewValueNode(p_init)}, func_graph);
@ -730,7 +730,7 @@ bool InitExecDatasetVm(const std::string& queue_name, int64_t size, int64_t batc
if (!(*runner.run)) {
// empty function
MS_LOG(EXCEPTION) << "Backend " << backend->name() << " unsupports tdt dataset.";
MS_LOG(EXCEPTION) << "Backend " << backend->name() << " unsupported tdt dataset.";
}
// launch init dataset runner without inputs and outputs
@ -758,7 +758,7 @@ void InitHccl() {
auto runtime_instance = device::KernelRuntimeManager::Instance().GetKernelRuntime(device_name, device_id);
MS_EXCEPTION_IF_NULL(runtime_instance);
if (!runtime_instance->Init()) {
MS_LOG(ERROR) << "kernel runtime init error.";
MS_LOG(ERROR) << "Kernel runtime init error.";
return;
}
}
@ -795,7 +795,7 @@ void InitGe() {
auto ms_context = MsContext::GetInstance();
MS_EXCEPTION_IF_NULL(ms_context);
if (!ms_context->OpenTsd()) {
MS_LOG(EXCEPTION) << "open tsd failed";
MS_LOG(EXCEPTION) << "Open tsd failed";
}
(void)ms_context->InitGe();
}

16
mindspore/ccsrc/pipeline/pipeline_ge.cc
View File

@ -210,7 +210,7 @@ bool AddDFGraph(const std::map<std::string, ExecutorInfoPtr>& info, const py::di
(void)convertor.GenerateCheckpointGraph();
if (convertor.ErrCode() != 0) {
DfGraphManager::GetInstance().ClearGraph();
MS_LOG(ERROR) << "convert df graph failed, err:" << convertor.ErrCode();
MS_LOG(ERROR) << "Convert df graph failed, err:" << convertor.ErrCode();
return false;
}
@ -238,7 +238,7 @@ bool AddDFGraph(const std::map<std::string, ExecutorInfoPtr>& info, const py::di
FuncGraphPtr BuildDFGraph(const std::map<std::string, ExecutorInfoPtr>& info, const py::dict& init_params,
const std::string& phase, const py::object& broadcast_params) {
if (info.count(phase) == 0) {
MS_LOG(EXCEPTION) << "no phase in executor:" << GetPhasePrefix(phase);
MS_LOG(EXCEPTION) << "No phase in executor:" << GetPhasePrefix(phase);
}
FuncGraphPtr anf_graph = info.at(phase)->func_graph;
@ -389,7 +389,7 @@ std::shared_ptr<py::object> DoExecGraph(const FuncGraphPtr& graph, const std::ve
const std::string& phase) {
std::vector<GeTensorPtr> ge_tensors = TransformUtil::ConvertInputTensors(inputs, kOpFormat_NCHW);
if (ge_tensors.size() != inputs.size()) {
MS_LOG(ERROR) << "args convert to ge tensor error";
MS_LOG(ERROR) << "Args convert to ge tensor error";
return nullptr;
}
@ -444,7 +444,7 @@ void ProcessGeArg(const std::map<std::string, ExecutorInfoPtr>& info, const py::
std::size_t size = args.size();
if (info.count(phase) == 0) {
MS_LOG(EXCEPTION) << "no phase in executor:" << GetPhasePrefix(phase);
MS_LOG(EXCEPTION) << "No phase in executor:" << GetPhasePrefix(phase);
}
auto arg_size = info.at(phase)->arg_list_size;
@ -459,12 +459,12 @@ void ProcessGeArg(const std::map<std::string, ExecutorInfoPtr>& info, const py::
ValuePtr converted = nullptr;
bool succ = parse::ConvertData(args[i], &converted);
if (!succ) {
MS_LOG(EXCEPTION) << "args convert error";
MS_LOG(EXCEPTION) << "Args convert error";
}
if (converted->isa<tensor::Tensor>()) {
(*inputs).push_back(converted->cast<tensor::TensorPtr>());
} else {
MS_LOG(EXCEPTION) << "args, " << converted->ToString() << " is not tensor";
MS_LOG(EXCEPTION) << "Args " << converted->ToString() << " is not tensor";
}
}
}
@ -481,7 +481,7 @@ py::object ExecDFGraph(const std::map<std::string, ExecutorInfoPtr>& info, const
}
if (info.count(phase) == 0) {
MS_LOG(EXCEPTION) << "has no phase:" << phase;
MS_LOG(EXCEPTION) << "There is no phase:" << phase;
}
FuncGraphPtr anf_graph = info.at(phase)->func_graph;
@ -511,7 +511,7 @@ py::object ExecDFGraph(const std::map<std::string, ExecutorInfoPtr>& info, const
if (ret != nullptr) {
return *ret;
} else {
MS_LOG(EXCEPTION) << "exec graph failed";
MS_LOG(EXCEPTION) << "Exec graph failed";
}
}
void ExportDFGraph(const std::string& file_name, const std::string& phase) {

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

@ -189,7 +189,7 @@ Resource::~Resource() {
// If exit normally, these global variables will be cleaned
// in Resource::Clean call by MsPipeline::Compile, but if exit with MS_LOGEXCEPTION,
// these global variables may not being cleaned, it may
// cause segmentfault when free python object inside these global varaibles
// cause segmentfault when free python object inside these global variables
// after python interpreter got freed, so these global variables
// are cleaned here.
// So if exit normally, these global variable will be cleaned twice,

2
mindspore/ccsrc/pipeline/static_analysis/abstract_value.cc
View File

@ -443,7 +443,7 @@ bool AbstractTensor::operator==(const AbstractTensor &other) const {
auto v1 = GetValueTrack();
auto v2 = other.GetValueTrack();
if (v1 == nullptr || v2 == nullptr) {
MS_LOG(EXCEPTION) << "the value of AbstractTensor is nullptr";
MS_LOG(EXCEPTION) << "The value of AbstractTensor is nullptr";
}
bool is_value_equal = (v1 == v2);

4
mindspore/ccsrc/pipeline/static_analysis/abstract_value.h
View File

@ -77,7 +77,7 @@ class AbstractBase : public Base {
}
protected:
// default implementation, it can be overrided by subclass;
// default implementation, it can be overwritten by subclass;
virtual ValuePtr RealBuildValue() const { return kAnyValue; }
private:
@ -495,7 +495,7 @@ class AbstractNone : public AbstractBase {
};
using AbstractNonePtr = std::shared_ptr<AbstractNone>;
// the un assgined state value for variable, which means the variable is not assigned
// the un assigned state value for variable, which means the variable is not assigned
class AbstractNull : public AbstractBase {
public:
AbstractNull() : AbstractBase(kNullObj) { set_type(std::make_shared<TypeNull>()); }

2
mindspore/ccsrc/pipeline/static_analysis/evaluator.cc
View File

@ -116,7 +116,7 @@ AbstractBasePtrList FuncGraphEvaluator::NormalizeArgs(const AbstractBasePtrList
return broaded_list;
}
if (func_graph_->has_flag(kFuncGraphFlagUndetermin)) {
if (func_graph_->has_flag(kFuncGraphFlagUndetermined)) {
if (parent_context_) {
MS_LOG(DEBUG) << "Undeterminate FuncGraphEvaluator " << ToString()
<< ", context: " << parent_context_->ToString();

10
mindspore/ccsrc/pipeline/static_analysis/param_validator.cc
View File

@ -56,7 +56,7 @@ TypePtr CheckTensorDType(const AbstractTensorPtr &tensor, const TypePtrList &acc
}
TypePtr ele_type = tensor->element()->BuildType();
if (ele_type == nullptr) {
MS_LOG(EXCEPTION) << "abstract tensor element type nullptr";
MS_LOG(EXCEPTION) << "Abstract tensor element type nullptr";
}
return CheckType(ele_type, accepts, error_message_prefix);
}
@ -64,7 +64,7 @@ TypePtr CheckTensorDType(const AbstractTensorPtr &tensor, const TypePtrList &acc
TypePtr CheckTensorsDTypeSame(const AbstractTensorPtrList &tensor_list, const TypePtrList &accepts,
const std::string &error_message_prefix) {
if (tensor_list.empty()) {
MS_LOG(EXCEPTION) << "array list is empty";
MS_LOG(EXCEPTION) << "Array list is empty";
}
auto sample_tensor = tensor_list[0];
@ -78,7 +78,7 @@ TypePtr CheckTensorsDTypeSame(const AbstractTensorPtrList &tensor_list, const Ty
auto aType = tensor_list[index]->element()->BuildType();
loginfoBuffer << " " << aType->ToString();
if (sample_type->type_id() != aType->type_id()) {
MS_LOG(EXCEPTION) << "expected type " << sample_type->ToString() << ", but got " << aType->ToString()
MS_LOG(EXCEPTION) << "Expected type " << sample_type->ToString() << ", but got " << aType->ToString()
<< ", index " << index;
}
}
@ -89,11 +89,11 @@ TypePtr CheckTensorsDTypeSame(const AbstractTensorPtrList &tensor_list, const Ty
TypePtr CheckScalarType(const AbstractScalarPtr &scalar, const TypePtrList &accepts,
const std::string &error_message_prefix) {
if (scalar == nullptr) {
MS_LOG(EXCEPTION) << "scalar nullptr";
MS_LOG(EXCEPTION) << "Scalar nullptr";
}
auto type = scalar->BuildType();
if (type == nullptr) {
MS_LOG(EXCEPTION) << "scalar value nullptr";
MS_LOG(EXCEPTION) << "Scalar value nullptr";
}
return CheckType(type, accepts, error_message_prefix);

46
mindspore/ccsrc/pipeline/static_analysis/prim.cc
View File

@ -182,30 +182,30 @@ AbstractBasePtr DoSignatureEvaluator::Run(AnalysisEnginePtr engine, const Config
static AbstractBasePtrList GetUnpackGraphSpecArgsList(AbstractBasePtrList args_spec_list, bool need_unpack) {
// arg[0] is the func graph to unpack, ignore it
AbstractBasePtrList sepcialize_args_before_unpack(args_spec_list.begin() + 1, args_spec_list.end());
AbstractBasePtrList graph_sepcialize_args;
AbstractBasePtrList specialize_args_before_unpack(args_spec_list.begin() + 1, args_spec_list.end());
AbstractBasePtrList graph_specialize_args;
if (need_unpack) {
for (size_t index = 0; index < sepcialize_args_before_unpack.size(); index++) {
MS_EXCEPTION_IF_NULL(sepcialize_args_before_unpack[index]);
if (sepcialize_args_before_unpack[index]->isa<AbstractTuple>()) {
AbstractTuplePtr arg_tuple = sepcialize_args_before_unpack[index]->cast<AbstractTuplePtr>();
for (size_t index = 0; index < specialize_args_before_unpack.size(); index++) {
MS_EXCEPTION_IF_NULL(specialize_args_before_unpack[index]);
if (specialize_args_before_unpack[index]->isa<AbstractTuple>()) {
AbstractTuplePtr arg_tuple = specialize_args_before_unpack[index]->cast<AbstractTuplePtr>();
std::transform(arg_tuple->elements().begin(), arg_tuple->elements().end(),
std::back_inserter(graph_sepcialize_args), [](AbstractBasePtr abs) { return abs; });
} else if (sepcialize_args_before_unpack[index]->isa<AbstractDictionary>()) {
AbstractDictionaryPtr arg_dict = sepcialize_args_before_unpack[index]->cast<AbstractDictionaryPtr>();
std::back_inserter(graph_specialize_args), [](AbstractBasePtr abs) { return abs; });
} else if (specialize_args_before_unpack[index]->isa<AbstractDictionary>()) {
AbstractDictionaryPtr arg_dict = specialize_args_before_unpack[index]->cast<AbstractDictionaryPtr>();
auto dict_elems = arg_dict->elements();
(void)std::transform(
dict_elems.begin(), dict_elems.end(), std::back_inserter(graph_sepcialize_args),
dict_elems.begin(), dict_elems.end(), std::back_inserter(graph_specialize_args),
[](const AbstractAttribute &item) { return std::make_shared<AbstractKeywordArg>(item.first, item.second); });
} else {
MS_LOG(EXCEPTION) << "UnpackGraph require args should be tuple or dict, but got "
<< sepcialize_args_before_unpack[index]->ToString();
<< specialize_args_before_unpack[index]->ToString();
}
}
} else {
graph_sepcialize_args = sepcialize_args_before_unpack;
graph_specialize_args = specialize_args_before_unpack;
}
return graph_sepcialize_args;
return graph_specialize_args;
}
AbstractBasePtr UnpackGraphEvaluator::Run(AnalysisEnginePtr engine, const ConfigPtrList &args_conf_list,
@ -239,14 +239,14 @@ AbstractBasePtr UnpackGraphEvaluator::Run(AnalysisEnginePtr engine, const Config
MS_EXCEPTION_IF_NULL(real_fn);
FuncGraphPtr forward_graph = real_fn->func_graph();
MS_EXCEPTION_IF_NULL(forward_graph);
AbstractBasePtrList graph_sepcialize_args =
AbstractBasePtrList graph_specialize_args =
GetUnpackGraphSpecArgsList(args_spec_list, unpack_graph->need_unpack_args());
AbstractBasePtrList graph_sepcialize_args_without_sens;
(void)std::transform(graph_sepcialize_args.begin(),
graph_sepcialize_args.end() - (unpack_graph->with_sens_in_args() ? 1 : 0),
std::back_inserter(graph_sepcialize_args_without_sens), [](AbstractBasePtr abs) { return abs; });
auto new_graph = forward_graph->GenerateGraph(graph_sepcialize_args_without_sens);
AbstractBasePtrList graph_specialize_args_without_sens;
(void)std::transform(graph_specialize_args.begin(),
graph_specialize_args.end() - (unpack_graph->with_sens_in_args() ? 1 : 0),
std::back_inserter(graph_specialize_args_without_sens), [](AbstractBasePtr abs) { return abs; });
auto new_graph = forward_graph->GenerateGraph(graph_specialize_args_without_sens);
engine->func_graph_manager()->AddFuncGraph(new_graph);
ScopePtr scope = kDefaultScope;
if (out_conf != nullptr) {
@ -635,8 +635,8 @@ AbstractBasePtr GetEvaluatedValueForClassAttrOrMethod(const AnalysisEnginePtr &e
MS_LOG(EXCEPTION) << "Attribute type error";
}
std::string item_name = item_v->cast<StringImmPtr>()->value();
MS_LOG(DEBUG) << "Resovle name: " << cls->tag().name();
MS_LOG(DEBUG) << "Resovle item: " << item_name;
MS_LOG(DEBUG) << "Resolve name: " << cls->tag().name();
MS_LOG(DEBUG) << "Resolve item: " << item_name;
AbstractBasePtr attr = cls->GetAttribute(item_name);
if (attr != nullptr) {
@ -720,7 +720,7 @@ class EmbedEvaluator : public SymbolicPrimEvaluator {
~EmbedEvaluator() override = default;
MS_DECLARE_PARENT(EmbedEvaluator, SymbolicPrimEvaluator);
AbstractBasePtr EvalPrim(const ConfigPtrList &args_conf_list) override {
// arg: free variable to be embeded
// arg: free variable to be embedded
if (args_conf_list.size() != 1) {
MS_LOG(EXCEPTION) << "EmbedEvaluator requires 1 parameter, but got " << args_conf_list.size();
}
@ -939,7 +939,7 @@ class PartialEvaluator : public Evaluator {
AbstractBasePtr Run(AnalysisEnginePtr engine, const ConfigPtrList &args_conf_list,
AnfNodeConfigPtr out_conf = nullptr) override {
if (args_conf_list.size() == 0) {
MS_LOG(EXCEPTION) << "args size should be greater than 0";
MS_LOG(EXCEPTION) << "Args size should be greater than 0";
}
auto arg0_value = args_conf_list[0]->GetEvaluatedValue();
AbstractBasePtrList args_spec_list{arg0_value};

10
mindspore/ccsrc/pipeline/static_analysis/program_specialize.cc
View File

@ -190,7 +190,7 @@ void FuncGraphSpecializer::FirstPass() {
}
if (node->func_graph() != func_graph_) {
if (parent_ == nullptr) {
MS_LOG(EXCEPTION) << "parent must not null NodeInfo: " << trace::GetDebugInfo(node->debug_info());
MS_LOG(EXCEPTION) << "Parent must not null NodeInfo: " << trace::GetDebugInfo(node->debug_info());
}
parent_->AddTodoItem(node);
parent_->FirstPass();
@ -365,16 +365,16 @@ AnfNodePtr FuncGraphSpecializer::BuildSpecializedNodeInner(const AbstractBasePtr
}
if (!eval->isa<BaseFuncGraphEvaluator>()) {
MS_LOG(EXCEPTION) << "eval is not BaseGraphEvaluator, but " << eval->ToString();
MS_LOG(EXCEPTION) << "Eval is not BaseGraphEvaluator, but " << eval->ToString();
}
auto real_eval = dyn_cast<BaseFuncGraphEvaluator>(eval);
if (func->context() != nullptr) {
if (!IsVisible(func_graph_, func->context()->func_graph())) {
MS_LOG(EXCEPTION) << "func is not visible NodeInfo: " << trace::GetDebugInfo(func_graph_->debug_info());
MS_LOG(EXCEPTION) << "Func is not visible NodeInfo: " << trace::GetDebugInfo(func_graph_->debug_info());
}
} else {
MS_LOG(EXCEPTION) << "func context is nullptr NodeInfo: " << trace::GetDebugInfo(func_graph_->debug_info());
MS_LOG(EXCEPTION) << "Func context is nullptr NodeInfo: " << trace::GetDebugInfo(func_graph_->debug_info());
}
AnalysisContextPtr context = real_eval->MakeContext(engine_, argvals);
MS_LOG(DEBUG) << "Specialize function graph: " << context->func_graph()->ToString() << ", args: " << argvals.size()
@ -556,7 +556,7 @@ SpecializeStatusCode FuncGraphSpecializer::FindUniqueArgvals(const AbstractFunct
if (!result->first.empty()) {
return kSpecializeSuccess;
}
MS_LOG(DEBUG) << "Find POLY code, it may be unused code or unresoved polymorphism.";
MS_LOG(DEBUG) << "Find POLY code, it may be unused code or unresolved polymorphism.";
return kSpecializeFindUniqueArgvalPoly;
}
}

12
mindspore/ccsrc/pipeline/static_analysis/static_analysis.cc
View File

@ -89,7 +89,7 @@ std::size_t AnfNodeConfigHasher::operator()(const AnfNodeConfigPtr conf) const {
MS_EXCEPTION_IF_NULL(conf->node());
std::size_t hash_value = hash_combine(conf->node()->hash(), conf->context()->hash());
if (conf->context() != nullptr && conf->context()->func_graph() != nullptr) {
MS_LOG(DEBUG) << "NodeConfgHasher Node: " << conf->node()->DebugString()
MS_LOG(DEBUG) << "NodeConfigHasher Node: " << conf->node()->DebugString()
<< ", Graph: " << conf->context()->func_graph()->ToString() << " ### , hash value: " << hash_value;
} else {
MS_LOG(DEBUG) << "NodeConfigHasher Node: " << conf->node()->DebugString() << " ### , hash value: " << hash_value;
@ -456,13 +456,13 @@ AbstractBasePtr AnalysisEngine::ExecuteMultipleEvaluators(const std::vector<Eval
for (auto eval : evaluators) {
auto fg_eval = eval->cast<FuncGraphEvaluatorPtr>();
if (fg_eval) {
auto undetermin_fgs = fg_eval->func_graph()->recursive_graphs();
if (undetermin_fgs) {
for (auto undetermin_fg : *undetermin_fgs) {
MS_LOG(DEBUG) << "Set graph undetermin: " << undetermin_fg->ToString();
auto undetermined_fgs = fg_eval->func_graph()->recursive_graphs();
if (undetermined_fgs) {
for (auto undetermined_fg : *undetermined_fgs) {
MS_LOG(DEBUG) << "Set graph undetermined: " << undetermined_fg->ToString();
// As the current evaluator has multiple possibles, all the func_graphs which
// are recursive with the current func_graph are undetermined in control flow.
undetermin_fg->set_flags(kFuncGraphFlagUndetermin, true);
undetermined_fg->set_flags(kFuncGraphFlagUndetermined, true);
}
}
}