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

!109 Fix some typo errors in session and device module 

Merge pull request !109 from leonwanghui/typo-fix
This commit is contained in:
mindspore-ci-bot 2020-04-03 10:23:53 +08:00 committed by Gitee
parent 9be1a01db6 fdb47860cc
commit 3289d7bb69
16 changed files with 184 additions and 182 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
mindspore/ccsrc/device/cpu/cpu_kernel_runtime.cc
View File

@ -66,7 +66,7 @@ void CPUKernelRuntime::AssignValueNodeAddress(session::KernelGraph *kernel_graph
address->ptr_ = resource_manager_.MemMalloc(tensor_size);
if (!address->SyncHostToDevice(data_shape, LongToSize(tensor->data().nbytes()), tensor->data_type(),
tensor->data_c(false))) {
MS_LOG(EXCEPTION) << "value node sync host to device failed!";
MS_LOG(EXCEPTION) << "Value node sync host to device failed!";
}
}
address->ref_count_ = INIT_NODE_REF;
@ -141,7 +141,7 @@ BaseRef CPUKernelRuntime::CreatTensorForOutput(const AnfNodePtr &input_node, siz
MS_EXCEPTION_IF_NULL(node);
size_t output_size = AnfAlgo::GetOutputTensorNum(node);
if (index >= output_size) {
MS_LOG(EXCEPTION) << "invalid input index " << index;
MS_LOG(EXCEPTION) << "Invalid input index " << index;
}
auto address = AnfAlgo::GetMutableOutputAddr(node, index);
MS_EXCEPTION_IF_NULL(address);
@ -157,7 +157,7 @@ BaseRef CPUKernelRuntime::CreatTensorForOutput(const AnfNodePtr &input_node, siz
type_id = kNumberTypeFloat32;
}
if (type_id != kNumberTypeInt32 && type_id != kNumberTypeFloat32) {
MS_LOG(EXCEPTION) << "check output type failed.";
MS_LOG(EXCEPTION) << "Check output type failed.";
}
tensor::TensorPtr tensor = std::make_shared<tensor::Tensor>(type_id, temp_shape);
MS_EXCEPTION_IF_NULL(tensor);
@ -181,7 +181,7 @@ void CPUKernelRuntime::BindInputOutput(const session::KernelGraph *kernel_graph,
// bind input ptr
auto &input_nodes = kernel_graph->inputs();
if (input_nodes.size() != inputs.size()) {
MS_LOG(EXCEPTION) << "input size not equal to input node size!";
MS_LOG(EXCEPTION) << "Input size not equal to input node size!";
}
std::unordered_map<AnfNode *, tensor::TensorPtr> input_map;
@ -203,7 +203,7 @@ void CPUKernelRuntime::BindInputOutput(const session::KernelGraph *kernel_graph,
address->ptr_ = resource_manager_.MemMalloc(tensor_size);
if (!address->SyncHostToDevice(data_shape, LongToSize(tensor->data().nbytes()), tensor->data_type(),
tensor->data_c(false))) {
MS_LOG(EXCEPTION) << "parameter node sync host to device failed!";
MS_LOG(EXCEPTION) << "Parameter node sync host to device failed!";
}
tensor->set_dirty(true);
}

4
mindspore/ccsrc/device/cpu/cpu_resource_manager.cc
View File

@ -44,7 +44,7 @@ void CPUResourceManager::MemPlan(const session::KernelGraph *graph) {
mem_size_ = graph_mem_size;
dynamic_malloc_ = false;
} else {
MS_LOG(INFO) << "switch to dynamic malloc";
MS_LOG(INFO) << "Switch to dynamic malloc";
dynamic_malloc_ = true;
}
}
@ -63,7 +63,7 @@ void *CPUResourceManager::MemMalloc(size_t mem_size) {
dynamic_mem_[ptr] = mem_size;
return ptr;
} else {
MS_LOG(EXCEPTION) << "malloc memory failed: size " << mem_size;
MS_LOG(EXCEPTION) << "Malloc memory failed: size " << mem_size;
}
}

14
mindspore/ccsrc/device/cpu/cpu_session.cc
View File

@ -31,12 +31,12 @@ GraphId CPUSession::CompileGraph(const AnfNodePtrList &lst, const AnfNodePtrList
auto graph_id = graph_sum_;
auto graph = ConstructKernelGraph(lst, outputs);
MS_EXCEPTION_IF_NULL(graph);
MS_LOG(INFO) << "set kernel info";
MS_LOG(INFO) << "Set kernel info";
SetKernelInfo(graph.get());
predictmodel::StepConvertGraph(graph);
MS_LOG(INFO) << "build kernel";
MS_LOG(INFO) << "Build kernel";
BuildKernel(graph.get());
MS_LOG(INFO) << "assign kernel address";
MS_LOG(INFO) << "Assign kernel address";
runtime_.AssignKernelAddress(graph.get());
return graph_id;
}
@ -44,18 +44,18 @@ GraphId CPUSession::CompileGraph(const AnfNodePtrList &lst, const AnfNodePtrList
void CPUSession::RunGraph(const GraphId &graph_id, const std::vector<tensor::TensorPtr> &inputs, VectorRef *outputs) {
auto &kernel_graph = graphs_[graph_id];
MS_EXCEPTION_IF_NULL(kernel_graph);
MS_LOG(INFO) << "bind input output address";
MS_LOG(INFO) << "Bind input output address";
runtime_.BindInputOutput(kernel_graph.get(), inputs, outputs);
MS_LOG(INFO) << "run graph start";
MS_LOG(INFO) << "Run graph start";
predictmodel::StepConvertWeight(inputs);
auto execution_order = kernel_graph->execution_order();
Reorder(&execution_order);
kernel_graph->set_execution_order(execution_order);
bool ret = runtime_.Run(kernel_graph.get());
if (!ret) {
MS_LOG(EXCEPTION) << "run graph failed";
MS_LOG(EXCEPTION) << "Run graph failed";
}
MS_LOG(INFO) << "run graph end";
MS_LOG(INFO) << "Run graph end";
}
void CPUSession::SetKernelInfo(const KernelGraph *kernel_graph) {

12
mindspore/ccsrc/device/kernel_adjust.cc
View File

@ -50,7 +50,7 @@ void KernelAdjust::Reorder(const std::shared_ptr<session::KernelGraph> &kernel_g
std::vector<CNodePtr> momentum_list;
std::vector<CNodePtr> other_list;
for (const auto &cnode : origin_cnode_list) {
if (kOptOpeatorSet.find(AnfAlgo::GetCNodeName(cnode)) != kOptOpeatorSet.end()) {
if (kOptOperatorSet.find(AnfAlgo::GetCNodeName(cnode)) != kOptOperatorSet.end()) {
momentum_list.emplace_back(cnode);
} else {
other_list.emplace_back(cnode);
@ -119,7 +119,7 @@ void KernelAdjust::CreateSwitchOpParameters(const std::shared_ptr<session::Kerne
MS_EXCEPTION_IF_NULL(tensor_ptr);
mindspore::abstract::AbstractBasePtr paremeter_abstract_ptr = tensor_ptr->ToAbstract();
if (paremeter_abstract_ptr == nullptr) {
MS_LOG(EXCEPTION) << "create abstract brfore insert switch op failed!";
MS_LOG(EXCEPTION) << "create abstract before insert switch op failed!";
}
ParameterPtr loop_count = std::make_shared<Parameter>(kernel_graph_ptr);
@ -372,7 +372,7 @@ bool KernelAdjust::StepLoadCtrlInputs(const std::shared_ptr<session::Context> &c
auto tensor = inputs[i];
size_t deal_index = input_nodes.size() - input_ctrl_size + i;
if (deal_index >= input_nodes.size()) {
MS_LOG(EXCEPTION) << "deak_index[" << deal_index << "] outof range";
MS_LOG(EXCEPTION) << "deal_index[" << deal_index << "] out of range";
}
auto input_node = input_nodes[deal_index];
bool need_sync = false;
@ -440,7 +440,7 @@ void KernelAdjust::LoadSwitchInputs(std::vector<tensor::TensorPtr> *inputs) {
void KernelAdjust::Profiling(const std::shared_ptr<session::KernelGraph> &kernel_graph_ptr) {
if (!ascend::ProfilingManager::GetInstance().IsProfiling()) {
MS_LOG(INFO) << "no need to profiling";
MS_LOG(INFO) << "No need to profiling";
return;
}
ProfilingTraceInfo profiling_trace_info;
@ -453,10 +453,10 @@ void KernelAdjust::Profiling(const std::shared_ptr<session::KernelGraph> &kernel
void KernelAdjust::InsertProfilingKernel(const std::shared_ptr<session::KernelGraph> &kernel_graph_ptr,
const ProfilingTraceInfo &profiling_trace_info) {
MS_LOG(INFO) << "[profiling] insert profiling kernel start";
MS_LOG(INFO) << "[profiling] Insert profiling kernel start";
MS_EXCEPTION_IF_NULL(kernel_graph_ptr);
if (!profiling_trace_info.IsValid()) {
MS_LOG(WARNING) << "profiling trace point not found";
MS_LOG(WARNING) << "Profiling trace point not found";
return;
}
std::vector<CNodePtr> new_cnode_list;

12
mindspore/ccsrc/device/kernel_runtime.cc
View File

@ -241,7 +241,7 @@ void KernelRuntime::AssignStaticMemoryInput(const session::KernelGraph *graph) {
auto output_size = AnfAlgo::GetOutputTensorNum(item);
for (size_t index = 0; index < output_size; index++) {
TypeId output_type_id = AnfAlgo::GetOutputDeviceDataType(item, index);
// if graph output is a weight and doesn't link to any cnode,it's data type will be unkonwn
// if graph output is a weight and doesn't link to any cnode, it's data type will be unknown
if (output_type_id == kTypeUnknown) {
MS_LOG(WARNING) << "It is not suggested to use a lonely weight parameter as the output of graph";
output_type_id = AnfAlgo::GetOutputInferDataType(item, index);
@ -372,7 +372,7 @@ void KernelRuntime::AssignNodeOutputMem(int flag, const AnfNodePtr &node, int in
continue;
}
if (AnfAlgo::OutputAddrExist(node, i)) {
MS_LOG(INFO) << "already malloc index:" << i;
MS_LOG(INFO) << "Already malloc index:" << i;
continue;
}
auto ptr = CalDeviceMem(node, output_sizes[i], flag, i);
@ -392,7 +392,7 @@ void KernelRuntime::AssignValueNodeTensor(const ValueNodePtr &value_node, const
MS_EXCEPTION_IF_NULL(node_value);
auto tensor = node_value->cast<TensorPtr>();
if (tensor == nullptr) {
MS_LOG(WARNING) << "tensor is null";
MS_LOG(WARNING) << "Tensor is null";
return;
}
size_t tensor_size = tensor->data().nbytes();
@ -595,7 +595,7 @@ void KernelRuntime::GenLaunchArgs(const mindspore::kernel::KernelMod &kernel_mod
void KernelRuntime::GenAddrCleanLaunchArgs(const CNodePtr &cnode, AddressPtrList *kernel_inputs) {
if (cnode->inputs().size() != 2) {
MS_LOG(EXCEPTION) << "atomic Addr clean Node Input nodes not equal 2.";
MS_LOG(EXCEPTION) << "Atomic Addr clean Node Input nodes not equal 2.";
}
auto pre_node = cnode->inputs()[1];
// set clean output address
@ -721,11 +721,11 @@ uint8_t *KernelRuntime::MallocDynamicMem(size_t size, bool communication_mem) {
bool KernelRuntime::LaunchKernel(const session::KernelGraph *graph) {
MS_EXCEPTION_IF_NULL(graph);
if (!LaunchKernelMod(*graph)) {
MS_LOG(ERROR) << "LaunchKernelMod failed.";
MS_LOG(ERROR) << "LaunchKernelMod failed!";
return false;
}
if (!SyncStream()) {
MS_LOG(ERROR) << "SyncStream failed.";
MS_LOG(ERROR) << "SyncStream failed!";
return false;
}
return true;

2
mindspore/ccsrc/device/kernel_runtime_manager.cc
View File

@ -67,7 +67,7 @@ KernelRuntime *KernelRuntimeManager::GetKernelRuntime(const std::string &device_
MS_EXCEPTION_IF_NULL(kernel_runtime);
runtime_map_[runtime_key] = kernel_runtime;
} else {
MS_LOG(EXCEPTION) << "no kernel runtime creator for " << device_name << " with device id " << device_id;
MS_LOG(EXCEPTION) << "No kernel runtime creator for " << device_name << " with device id " << device_id;
}
return kernel_runtime.get();

36
mindspore/ccsrc/session/anf_runtime_algorithm.cc
View File

@ -65,7 +65,7 @@ KernelWithIndex AnfRuntimeAlgorithm::VisitKernel(const AnfNodePtr &anf_node, siz
return VisitKernel(node, 0);
} else if (IsPrimitive(input0, prim::kPrimTupleGetItem)) {
if (cnode->inputs().size() != kTupleGetItemInputSize) {
MS_LOG(EXCEPTION) << "the node tuple_get_item must have 2 inputs!";
MS_LOG(EXCEPTION) << "The node tuple_get_item must have 2 inputs!";
}
auto input2 = cnode->input(kInputNodeOutputIndexInTupleGetItem);
MS_EXCEPTION_IF_NULL(input2);
@ -102,7 +102,7 @@ KernelWithIndex AnfRuntimeAlgorithm::VisitKernelWithReturnType(const AnfNodePtr
MS_EXCEPTION_IF_NULL(input0);
if (IsPrimitive(input0, prim::kPrimTupleGetItem)) {
if (cnode->inputs().size() != kTupleGetItemInputSize) {
MS_LOG(EXCEPTION) << "the node tuple_get_item must have 2 inputs!";
MS_LOG(EXCEPTION) << "The node tuple_get_item must have 2 inputs!";
}
auto input2 = cnode->input(kInputNodeOutputIndexInTupleGetItem);
MS_EXCEPTION_IF_NULL(input2);
@ -188,7 +188,7 @@ std::string AnfRuntimeAlgorithm::GetNodeDebugString(const AnfNodePtr &node) {
void AnfRuntimeAlgorithm::SetNodeAttr(const std::string &key, const ValuePtr &value, const AnfNodePtr &node) {
MS_EXCEPTION_IF_NULL(node);
if (!node->isa<CNode>()) {
MS_LOG(EXCEPTION) << "only cnode has attr,but this anf is " << node->DebugString();
MS_LOG(EXCEPTION) << "Only cnode has attr, but this anf is " << node->DebugString();
}
auto primitive = AnfAlgo::GetCNodePrimitive(node);
MS_EXCEPTION_IF_NULL(primitive);
@ -204,7 +204,7 @@ void AnfRuntimeAlgorithm::CopyNodeAttr(const std::string &old_key, const std::st
MS_EXCEPTION_IF_NULL(from);
MS_EXCEPTION_IF_NULL(to);
if (!from->isa<CNode>() || !to->isa<CNode>()) {
MS_LOG(EXCEPTION) << "only cnode has attr,but this from_anf is " << from->DebugString() << " ,to_node is "
MS_LOG(EXCEPTION) << "Only cnode has attr, but this from_anf is " << from->DebugString() << " ,to_node is "
<< to->DebugString();
}
auto from_primitive = AnfAlgo::GetCNodePrimitive(from);
@ -218,7 +218,7 @@ void AnfRuntimeAlgorithm::CopyNodeAttrs(const AnfNodePtr &from, const AnfNodePtr
MS_EXCEPTION_IF_NULL(from);
MS_EXCEPTION_IF_NULL(to);
if (!from->isa<CNode>() || !to->isa<CNode>()) {
MS_LOG(EXCEPTION) << "only cnode has attr,but this from_anf is " << from->DebugString() << ",to_node is "
MS_LOG(EXCEPTION) << "Only cnode has attr, but this from_anf is " << from->DebugString() << ",to_node is "
<< from->DebugString();
}
auto from_primitive = AnfAlgo::GetCNodePrimitive(from);
@ -231,7 +231,7 @@ void AnfRuntimeAlgorithm::CopyNodeAttrs(const AnfNodePtr &from, const AnfNodePtr
void AnfRuntimeAlgorithm::EraseNodeAttr(const std::string &key, const AnfNodePtr node) {
MS_EXCEPTION_IF_NULL(node);
if (!node->isa<CNode>()) {
MS_LOG(EXCEPTION) << "only cnode has attr,but this anf is " << node->DebugString();
MS_LOG(EXCEPTION) << "Only cnode has attr, but this anf is " << node->DebugString();
}
auto primitive = AnfAlgo::GetCNodePrimitive(node);
MS_EXCEPTION_IF_NULL(primitive);
@ -241,7 +241,7 @@ void AnfRuntimeAlgorithm::EraseNodeAttr(const std::string &key, const AnfNodePtr
bool AnfRuntimeAlgorithm::HasNodeAttr(const std::string &key, const AnfNodePtr &node) {
MS_EXCEPTION_IF_NULL(node);
if (!node->isa<CNode>()) {
MS_LOG(WARNING) << "only cnode has attr,but this anf is " << node->DebugString();
MS_LOG(WARNING) << "Only cnode has attr, but this anf is " << node->DebugString();
return false;
}
auto primitive = AnfAlgo::GetCNodePrimitive(node);
@ -252,7 +252,7 @@ bool AnfRuntimeAlgorithm::HasNodeAttr(const std::string &key, const AnfNodePtr &
size_t AnfRuntimeAlgorithm::GetInputTensorNum(const AnfNodePtr &node) {
MS_EXCEPTION_IF_NULL(node);
if (!node->isa<CNode>()) {
MS_LOG(EXCEPTION) << "only cnode has real input,but this anf is " << node->DebugString();
MS_LOG(EXCEPTION) << "Only cnode has real input, but this anf is " << node->DebugString();
}
auto cnode = node->cast<CNodePtr>();
MS_EXCEPTION_IF_NULL(cnode);
@ -404,7 +404,7 @@ std::vector<kernel::Axis> AnfRuntimeAlgorithm::GetInputReshapeType(const AnfNode
MS_EXCEPTION_IF_NULL(build_info);
std::vector<kernel::Axis> result;
if (!build_info->GetInputReshapeType(input_idx, &result)) {
MS_LOG(EXCEPTION) << "filed to ge the node's[ " << node->DebugString() << "] reshape type !";
MS_LOG(EXCEPTION) << "Failed to get the node's[ " << node->DebugString() << "] reshape type !";
}
return result;
}
@ -417,7 +417,7 @@ std::vector<kernel::Axis> AnfRuntimeAlgorithm::GetOutputReshapeType(const AnfNod
MS_EXCEPTION_IF_NULL(build_info);
std::vector<kernel::Axis> result;
if (!build_info->GetOutputReshapeType(output_idx, &result)) {
MS_LOG(EXCEPTION) << "filed to ge the node's[ " << node->DebugString() << "] reshape type !";
MS_LOG(EXCEPTION) << "Failed to get the node's[ " << node->DebugString() << "] reshape type !";
}
return result;
}
@ -593,7 +593,7 @@ void AnfRuntimeAlgorithm::SetOutputAddr(const DeviceAddressPtr &addr, size_t out
auto kernel_info = node->kernel_info();
MS_EXCEPTION_IF_NULL(kernel_info);
if (!kernel_info->SetOutputAddr(addr, output_idx)) {
MS_LOG(EXCEPTION) << "node " << node->DebugString() << "set adr" << output_idx << " fail";
MS_LOG(EXCEPTION) << "Node " << node->DebugString() << "set adr" << output_idx << " fail";
}
}
@ -603,7 +603,7 @@ void AnfRuntimeAlgorithm::SetWorkspaceAddr(const DeviceAddressPtr &addr, size_t
auto kernel_info = node->kernel_info();
MS_EXCEPTION_IF_NULL(kernel_info);
if (!kernel_info->SetWorkspaceAddr(addr, output_idx)) {
MS_LOG(EXCEPTION) << "node " << node->DebugString() << "set adr" << output_idx << " fail";
MS_LOG(EXCEPTION) << "Node " << node->DebugString() << "set adr" << output_idx << " fail";
}
}
@ -614,7 +614,7 @@ DeviceAddress *AnfRuntimeAlgorithm::GetWorkspaceAddr(const AnfNodePtr &node, siz
MS_EXCEPTION_IF_NULL(kernel_info);
auto addr = kernel_info->GetWorkspaceAddr(output_idx);
if (addr == nullptr) {
MS_LOG(EXCEPTION) << "output_idx " << output_idx << " of node " << node->DebugString()
MS_LOG(EXCEPTION) << "Output_idx " << output_idx << " of node " << node->DebugString()
<< "] workspace addr is not exist";
}
return addr;
@ -625,7 +625,7 @@ void AnfRuntimeAlgorithm::SetOutputInferTypeAndShape(const std::vector<TypeId> &
const std::vector<std::vector<size_t>> &shapes, AnfNode *node) {
MS_EXCEPTION_IF_NULL(node);
if (types.size() != shapes.size()) {
MS_LOG(EXCEPTION) << "types size " << types.size() << "should be same with shapes size " << shapes.size();
MS_LOG(EXCEPTION) << "Types size " << types.size() << "should be same with shapes size " << shapes.size();
}
if (shapes.empty()) {
MS_LOG(EXCEPTION) << "Illegal empty output_types_shapes";
@ -636,7 +636,7 @@ void AnfRuntimeAlgorithm::SetOutputInferTypeAndShape(const std::vector<TypeId> &
auto abstract = std::make_shared<AbstractTensor>(TypeIdToType(types[0]), shape_int);
node->set_abstract(abstract);
} else {
// mutiple output handle
// multiple output handle
std::vector<AbstractBasePtr> abstract_list;
for (size_t i = 0; i < types.size(); ++i) {
std::vector<int> shape_int;
@ -647,12 +647,12 @@ void AnfRuntimeAlgorithm::SetOutputInferTypeAndShape(const std::vector<TypeId> &
node->set_abstract(abstract_tuple);
}
}
// copy a abstract of a node to another node
// copy an abstract of a node to another node
void AnfRuntimeAlgorithm::CopyAbstract(const AnfNodePtr &from_node, AnfNode *to_node) {
to_node->set_abstract(from_node->abstract());
}
// get KernelBuildType of node ,such as ATT,RT,FWK and so on
// get KernelBuildType of node, such as ATT,RT,FWK and so on
KernelType AnfRuntimeAlgorithm::GetKernelType(const AnfNodePtr &node) {
MS_EXCEPTION_IF_NULL(node);
auto kernel_info = node->kernel_info();
@ -846,7 +846,7 @@ size_t AnfRuntimeAlgorithm::GetRealInputIndex(const mindspore::AnfNodePtr &anf_n
auto find = spec_node_list.find(node_name);
if (find != spec_node_list.end()) {
ret = find->second[cur_index];
MS_LOG(INFO) << "real input index change to" << ret << ", node name:" << node_name;
MS_LOG(INFO) << "Real input index change to" << ret << ", node name:" << node_name;
}
}
return ret;

4
mindspore/ccsrc/session/anf_runtime_algorithm.h
View File

@ -61,7 +61,7 @@ class AnfRuntimeAlgorithm {
MS_EXCEPTION_IF_NULL(node);
if (!node->isa<CNode>()) {
std::string node_debug_log = node->DebugString();
MS_LOG(EXCEPTION) << "only cnode has attr,but this anf is " << node_debug_log.c_str();
MS_LOG(EXCEPTION) << "Only cnode has attr, but this anf is " << node_debug_log.c_str();
}
auto primitive = GetCNodePrimitive(node);
MS_EXCEPTION_IF_NULL(primitive);
@ -105,7 +105,7 @@ class AnfRuntimeAlgorithm {
static TypeId GetOutputInferDataType(const AnfNodePtr &node, size_t output_idx);
// get output original data type from prev node,input_index is the input index of current node related to prev node
static TypeId GetPrevNodeOutputInferDataType(const AnfNodePtr &node, size_t input_idx);
// get output select data typpe of anf node
// get output select data type of anf node
static TypeId GetOutputDeviceDataType(const AnfNodePtr &node, size_t output_idx);
// get input select data type of anf node
static TypeId GetInputDeviceDataType(const AnfNodePtr &node, size_t input_idx);

177
mindspore/ccsrc/session/ascend_session.cc
View File

@ -56,7 +56,7 @@ void DumpGraphExeOrder(const std::vector<CNodePtr> &execution_order) {
}
void DumpGraphInputArgs(const VectorRef &args) {
MS_LOG(INFO) << "args size[%lu]" << args.size();
MS_LOG(INFO) << "Args size[%lu]" << args.size();
for (size_t i = 0; i < args.size(); i++) {
if (utils::isa<AnfNodePtr>(args[i])) {
auto anf = utils::cast<AnfNodePtr>(args[i]);
@ -67,7 +67,7 @@ void DumpGraphInputArgs(const VectorRef &args) {
MS_EXCEPTION_IF_NULL(value);
MS_LOG(INFO) << "Tensor arg" << i << " = " << value->ToString();
} else {
MS_LOG(INFO) << "Unknonwn arg" << i << " = " << args[i].ToString();
MS_LOG(INFO) << "Unknown arg" << i << " = " << args[i].ToString();
}
}
}
@ -96,7 +96,7 @@ GraphId GetDistinctionLabel(const KernelGraphPtr &graph) {
GraphId AscendSession::CompileGraph(const AnfNodePtrList &lst, const AnfNodePtrList &outputs) {
MS_LOG(INFO) << "start";
auto graph_id = graph_sum_;
// construct graph,if construct successs,graph_sum_ + 1
// construct graph, if successfully, graph_sum_ + 1
auto graph = ConstructKernelGraph(lst, outputs);
MS_EXCEPTION_IF_NULL(graph);
opt::AscendBackendIRFusionOptimization(graph);
@ -128,7 +128,7 @@ void AscendSession::BuildGraph(GraphId graph_id) {
// merge child graph
MergeGraphExecOrder();
} else {
// set the distinciton label of single graph
// set the distinction label of single graph
SetStreamDistinctionLabel(GetGraph(graph_id), graph_id, false);
}
// adjust execution order because merge child graph and other special operations
@ -144,7 +144,7 @@ void AscendSession::BuildGraph(GraphId graph_id) {
if (ms_context->precompile_only()) {
MS_LOG(INFO) << "Precompile only, stop in build kernel step";
} else {
// alloc memeory,include static memory and dynamic memory
// alloc memory, including static memory and dynamic memory
MemoryAlloc(graph.get());
// generate task info for task sink mode
GenerateTaskInfo(graph);
@ -159,9 +159,9 @@ void AscendSession::RunGraph(const GraphId &graph_id, const std::vector<tensor::
MS_LOG(INFO) << "start";
auto kernel_graph = GetGraph(graph_id);
MS_EXCEPTION_IF_NULL(kernel_graph);
// if no child graph exist and no anf output exist
// if none of child graph and no anf output exists
if (!kernel_graph->executable()) {
MS_LOG(INFO) << "no child graph but has anf output";
MS_LOG(INFO) << "No child graph has anf output";
UpdateOutputs(kernel_graph, outputs, inputs);
return;
}
@ -184,16 +184,16 @@ void AscendSession::RunGraph(const GraphId &graph_id, const std::vector<tensor::
}
void AscendSession::RunOpHardwareOptimize(const std::shared_ptr<session::KernelGraph> &kernel_graph) const {
MS_LOG(INFO) << "start !";
MS_LOG(INFO) << "Start";
// data layout optimization
opt::AscendDataLayout(kernel_graph);
// mixed precision optimization
opt::AscendMixPrecision(kernel_graph);
MS_LOG(INFO) << "Finish!";
MS_LOG(INFO) << "Finish";
}
void AscendSession::RunOpExecTask(const std::shared_ptr<KernelGraph> &kernel_graph) const {
MS_LOG(INFO) << "start !";
MS_LOG(INFO) << "Start!";
auto runtime_instance = device::KernelRuntimeManager::Instance().GetKernelRuntime(kAscendDevice, device_id_);
MS_EXCEPTION_IF_NULL(runtime_instance);
bool ret_ok = runtime_instance->LaunchKernel(kernel_graph.get());
@ -252,26 +252,26 @@ py::tuple AscendSession::RunOp(const OpRunInfo &op_run_info, const GraphInfo &gr
// compile graph steps
void AscendSession::SelectKernel(const KernelGraph &kernel_graph) const {
MS_LOG(INFO) << "start !";
MS_LOG(INFO) << "Start!";
for (const auto &cnode : kernel_graph.execution_order()) {
device::ascend::SelectKernelInfo(cnode);
MS_LOG(INFO) << "select ApplyKernel: " << cnode->DebugString();
MS_LOG(INFO) << "Select ApplyKernel: " << cnode->DebugString();
}
MS_LOG(INFO) << "Finish!";
}
void AscendSession::InitRuntimeResource() {
MS_LOG(INFO) << "start !";
MS_LOG(INFO) << "Start!";
auto runtime_instance = device::KernelRuntimeManager::Instance().GetKernelRuntime(kAscendDevice, device_id_);
MS_EXCEPTION_IF_NULL(runtime_instance);
if (!runtime_instance->Init()) {
MS_LOG(EXCEPTION) << "kernel runtime init error.";
MS_LOG(EXCEPTION) << "Kernel runtime init error.";
}
MS_LOG(INFO) << "Finish!";
}
void AscendSession::HardwareOptimize(const std::shared_ptr<KernelGraph> &kernel_graph) const {
MS_LOG(INFO) << "HardwareOptimize start !";
MS_LOG(INFO) << "HardwareOptimize start!";
opt::AscendBackendOptimization(kernel_graph);
MS_EXCEPTION_IF_NULL(kernel_graph);
kernel_graph->SetExecOrderByDefault();
@ -279,7 +279,7 @@ void AscendSession::HardwareOptimize(const std::shared_ptr<KernelGraph> &kernel_
}
void AscendSession::AdjustKernel(const std::shared_ptr<KernelGraph> &kernel_graph) const {
MS_LOG(INFO) << "start !";
MS_LOG(INFO) << "Start!";
device::KernelAdjust::GetInstance().Reorder(kernel_graph);
opt::HideNopNode(kernel_graph.get());
// Insert CLearZero op
@ -302,7 +302,7 @@ void AscendSession::AdjustKernel(const std::shared_ptr<KernelGraph> &kernel_grap
}
void AscendSession::RunOpAdjustKernel(const std::shared_ptr<KernelGraph> &kernel_graph) const {
MS_LOG(INFO) << "start !";
MS_LOG(INFO) << "Start!";
opt::HideNopNode(kernel_graph.get());
// Insert CLearZero op
// prepare for next step from json get atomic info
@ -312,18 +312,18 @@ void AscendSession::RunOpAdjustKernel(const std::shared_ptr<KernelGraph> &kernel
}
void AscendSession::AssignStream(const std::shared_ptr<KernelGraph> &kernel_graph) const {
MS_LOG(INFO) << "start !";
MS_LOG(INFO) << "Start!";
device::ascend::AscendStreamAssign::GetInstance().AssignStreamNew(kernel_graph);
MS_LOG(INFO) << "Finish!";
}
void AscendSession::BuildKernel(const std::shared_ptr<KernelGraph> &kernel_graph) const {
MS_LOG(INFO) << "start !";
MS_LOG(INFO) << "Start!";
struct timeval start_time, end_time;
(void)gettimeofday(&start_time, nullptr);
auto ret = device::ascend::KernelBuild(kernel_graph.get());
if (!ret) {
MS_LOG(EXCEPTION) << "kernel build error.";
MS_LOG(EXCEPTION) << "Kernel build error.";
}
(void)gettimeofday(&end_time, nullptr);
const uint64_t kUSecondInSecond = 1000000;
@ -334,7 +334,7 @@ void AscendSession::BuildKernel(const std::shared_ptr<KernelGraph> &kernel_graph
}
void AscendSession::MemoryAlloc(KernelGraph *kernel_graph) const {
MS_LOG(INFO) << "start !";
MS_LOG(INFO) << "Start!";
MS_EXCEPTION_IF_NULL(kernel_graph);
opt::RemoveNopNode(kernel_graph);
auto runtime_instance = device::KernelRuntimeManager::Instance().GetKernelRuntime(kAscendDevice, device_id_);
@ -345,7 +345,7 @@ void AscendSession::MemoryAlloc(KernelGraph *kernel_graph) const {
void AscendSession::RunOpMemoryAlloc(const std::vector<tensor::TensorPtr> &input_tensors,
KernelGraph *kernel_graph) const {
MS_LOG(INFO) << "start memory alloc!";
MS_LOG(INFO) << "Start memory alloc!";
MS_EXCEPTION_IF_NULL(kernel_graph);
opt::RemoveNopNode(kernel_graph);
auto runtime_instance = device::KernelRuntimeManager::Instance().GetKernelRuntime(kAscendDevice, device_id_);
@ -355,30 +355,30 @@ void AscendSession::RunOpMemoryAlloc(const std::vector<tensor::TensorPtr> &input
}
void AscendSession::GenerateTaskInfo(const std::shared_ptr<KernelGraph> &kernel_graph) const {
MS_LOG(INFO) << "start !";
MS_LOG(INFO) << "Start!";
(void)device::KernelAdjust::GetInstance().StepLoadCtrlInputs(context_, kernel_graph);
auto runtime_instance = device::KernelRuntimeManager::Instance().GetKernelRuntime(kAscendDevice, device_id_);
MS_EXCEPTION_IF_NULL(runtime_instance);
bool ret_ok = runtime_instance->GenTask(kernel_graph.get());
if (!ret_ok) {
MS_LOG(EXCEPTION) << "generate task error!";
MS_LOG(EXCEPTION) << "Generate task error!";
}
MS_LOG(INFO) << "Finish!";
}
void AscendSession::LoadTask(const std::shared_ptr<KernelGraph> &kernel_graph) const {
MS_LOG(INFO) << "start !";
MS_LOG(INFO) << "Start!";
auto runtime_instance = device::KernelRuntimeManager::Instance().GetKernelRuntime(kAscendDevice, device_id_);
MS_EXCEPTION_IF_NULL(runtime_instance);
bool ret_ok = runtime_instance->LoadTask(kernel_graph.get());
if (!ret_ok) {
MS_LOG(EXCEPTION) << "load task error!";
MS_LOG(EXCEPTION) << "Load task error!";
}
MS_LOG(INFO) << "Finish!";
}
void AscendSession::ExecTask(const std::shared_ptr<KernelGraph> &kernel_graph) const {
MS_LOG(INFO) << "start !";
MS_LOG(INFO) << "Start!";
auto runtime_instance = device::KernelRuntimeManager::Instance().GetKernelRuntime(kAscendDevice, device_id_);
MS_EXCEPTION_IF_NULL(runtime_instance);
bool ret_ok = runtime_instance->Run(kernel_graph.get());
@ -389,7 +389,7 @@ void AscendSession::ExecTask(const std::shared_ptr<KernelGraph> &kernel_graph) c
}
void AscendSession::Dump(const std::shared_ptr<KernelGraph> &kernel_graph) const {
MS_LOG(INFO) << "start !";
MS_LOG(INFO) << "Start!";
MS_EXCEPTION_IF_NULL(kernel_graph);
auto runtime_instance = device::KernelRuntimeManager::Instance().GetKernelRuntime(kAscendDevice, device_id_);
MS_EXCEPTION_IF_NULL(runtime_instance);
@ -398,7 +398,7 @@ void AscendSession::Dump(const std::shared_ptr<KernelGraph> &kernel_graph) const
}
GraphId AscendSession::SetFinalGraphInput(const std::vector<AnfNodePtr> &args) {
MS_LOG(INFO) << "start!args size " << args.size();
MS_LOG(INFO) << "Start! Args size " << args.size();
auto final_graph = std::make_shared<KernelGraph>();
final_graph_id_ = graph_sum_++;
graphs_[final_graph_id_] = final_graph;
@ -418,12 +418,12 @@ GraphId AscendSession::SetFinalGraphInput(const std::vector<AnfNodePtr> &args) {
if (parameter_belong_graph_id == kInvalidGraphId) {
parameter_backend = final_graph->NewParameter(parameter->cast<ParameterPtr>());
final_graph->FrontBackendlMapAdd(parameter, parameter_backend);
MS_LOG(INFO) << "new parameter" << parameter->DebugString() << "in final_graph";
MS_LOG(INFO) << "New parameter" << parameter->DebugString() << "in final_graph";
} else {
// parametr is a parameter of child graph
auto graph = GetGraph(parameter_belong_graph_id);
MS_EXCEPTION_IF_NULL(graph);
MS_LOG(INFO) << "reuse parameter [" << parameter->DebugString() << "] of child graph ["
MS_LOG(INFO) << "Reuse parameter [" << parameter->DebugString() << "] of child graph ["
<< parameter_belong_graph_id << "]";
parameter_backend = graph->GetBackendAnfByFrontAnf(parameter);
}
@ -435,7 +435,7 @@ GraphId AscendSession::SetFinalGraphInput(const std::vector<AnfNodePtr> &args) {
MS_EXCEPTION_IF_NULL(final_graph_inputs);
final_graph_inputs->push_back(parameter_backend);
}
MS_LOG(INFO) << "end final_graph_id " << final_graph_id_;
MS_LOG(INFO) << "End final_graph_id " << final_graph_id_;
return final_graph_id_;
}
@ -454,7 +454,7 @@ void AscendSession::SetFinalGraphOutput(const BaseRef &output) {
value_node->set_abstract(abstract::FromValue(value_ptr));
final_graph->set_output(final_graph->NewCNode({NewValueNode(prim::kPrimMakeTuple), value_node}));
final_graph->set_executable(false);
MS_LOG(INFO) << "not anf output[" << output.ToString() << "]";
MS_LOG(INFO) << "Not anf output[" << output.ToString() << "]";
return;
}
// get the backend anf node related to the output node of front
@ -462,12 +462,12 @@ void AscendSession::SetFinalGraphOutput(const BaseRef &output) {
auto output_from_graph_id = GetGraphIdByNode(output_anf_node);
auto output_from_graph = GetGraph(output_from_graph_id);
MS_EXCEPTION_IF_NULL(output_anf_node);
MS_LOG(INFO) << "set the output[" << output_anf_node->DebugString() << "] of graph[" << output_from_graph_id
MS_LOG(INFO) << "Set the output[" << output_anf_node->DebugString() << "] of graph[" << output_from_graph_id
<< "] to final graph";
MS_EXCEPTION_IF_NULL(output_from_graph);
// if output is from final graph,it remarks no child graph exist
if (final_graph_id_ == output_from_graph_id) {
MS_LOG(INFO) << "no child graph,output is " << output_anf_node->DebugString();
MS_LOG(INFO) << "No child graph,output is " << output_anf_node->DebugString();
final_graph->set_output(ConstructOutput({output_anf_node}, final_graph));
final_graph->set_executable(false);
return;
@ -478,15 +478,15 @@ void AscendSession::SetFinalGraphOutput(const BaseRef &output) {
KernelGraphPtr AscendSession::GetGraph(mindspore::GraphId graph_id) {
auto it = graphs_.find(graph_id);
if (it == graphs_.end()) {
MS_LOG(WARNING) << "can't find graph " << graph_id;
MS_LOG(WARNING) << "Can't find graph " << graph_id;
return nullptr;
}
return it->second;
}
void AscendSession::InsertSwitchToGraph(GraphId condition_graph_id, GraphId true_graph_id) {
MS_LOG(INFO) << "start";
MS_LOG(INFO) << "condition graph id[" << condition_graph_id << "],true graph id[" << true_graph_id << "]";
MS_LOG(INFO) << "Start!";
MS_LOG(INFO) << "Condition graph id[" << condition_graph_id << "],true graph id[" << true_graph_id << "]";
auto condition_graph = GetGraph(condition_graph_id);
MS_EXCEPTION_IF_NULL(condition_graph);
tensor::TensorPtr tensor = std::make_shared<tensor::Tensor>(kNumberTypeInt32, std::vector<int>{1});
@ -508,7 +508,7 @@ void AscendSession::InsertSwitchToGraph(GraphId condition_graph_id, GraphId true
kernel_build_info_builder->SetKernelType(KernelType::RT_KERNEL);
// condition graph's output must be single output
if (condition_graph->outputs().size() != 1) {
MS_LOG(EXCEPTION) << "condition_graph output num " << condition_graph_id << " should be 1";
MS_LOG(EXCEPTION) << "Condition_graph output num " << condition_graph_id << " should be 1";
}
AnfNodePtr cond_output_kernel = condition_graph->outputs()[0];
std::vector<AnfNodePtr> inputs = {NewValueNode(switch_primitive), cond_output_kernel, counter_const};
@ -528,7 +528,7 @@ void AscendSession::InsertSwitchToGraph(GraphId condition_graph_id, GraphId true
std::vector<CNodePtr> exec_order = condition_graph->execution_order();
exec_order.push_back(switch_node);
condition_graph->set_execution_order(exec_order);
MS_LOG(INFO) << "end";
MS_LOG(INFO) << "Finish!";
}
void AscendSession::CopyOutputOfIf(GraphId false_graph_id) {
@ -541,11 +541,11 @@ void AscendSession::CopyOutputOfIf(GraphId false_graph_id) {
for (int i = SizeToInt(false_index) - 1; i >= 0; i--) {
size_t graph_index = IntToSize(i);
if (graph_index >= graph_execute_order.size()) {
MS_LOG(EXCEPTION) << "graph index[" << graph_index << "] out of range[" << graph_execute_order.size() << "]";
MS_LOG(EXCEPTION) << "Graph index[" << graph_index << "] out of range[" << graph_execute_order.size() << "]";
}
if (graph_order_type[graph_index] == COMMON_GRAPH) {
auto true_last_id = graph_execute_order[graph_index];
MS_LOG(INFO) << "the last graph of if true branch is " << true_last_id;
MS_LOG(INFO) << "The last graph of if true branch is " << true_last_id;
auto true_last = GetGraph(true_last_id);
auto final_graph = GetGraph(final_graph_id_);
MS_EXCEPTION_IF_NULL(final_graph);
@ -553,10 +553,10 @@ void AscendSession::CopyOutputOfIf(GraphId false_graph_id) {
auto false_last = GetGraph(false_last_id);
MS_EXCEPTION_IF_NULL(true_last);
MS_EXCEPTION_IF_NULL(false_last);
MS_LOG(INFO) << "the last graph of false branch is " << false_last_id;
MS_LOG(INFO) << "The last graph of false branch is " << false_last_id;
// now only consider the single output
InsertMultipleAssignToGraph(true_last_id, true_last->output(), false_last->output());
// insert stream acitve for loop sink
// insert stream active for loop sink
auto context_ptr = MsContext::GetInstance();
MS_EXCEPTION_IF_NULL(context_ptr);
if (context_ptr->enable_task_sink() && context_ptr->loop_sink_flag() &&
@ -570,32 +570,32 @@ void AscendSession::CopyOutputOfIf(GraphId false_graph_id) {
}
void AscendSession::SwitchCompile(GraphId cond_graph_id, GraphId true_graph_id, GraphId false_graph_id) {
if (switchs_.find(cond_graph_id) != switchs_.end()) {
MS_LOG(WARNING) << "condition graph" << cond_graph_id << " has been set before ";
if (switches_.find(cond_graph_id) != switches_.end()) {
MS_LOG(WARNING) << "Condition graph" << cond_graph_id << " has been set before ";
return;
}
switchs_[cond_graph_id] = std::pair<GraphId, GraphId>(true_graph_id, false_graph_id);
MS_LOG(INFO) << "new switch compile " << cond_graph_id << " " << true_graph_id << " " << false_graph_id;
// set the type of condtion graph
switches_[cond_graph_id] = std::pair<GraphId, GraphId>(true_graph_id, false_graph_id);
MS_LOG(INFO) << "New switch compile " << cond_graph_id << " " << true_graph_id << " " << false_graph_id;
// set the type of condition graph
auto cond_graph_index = ExecOrderOfChildGraph(final_graph_id_, cond_graph_id);
auto &graph_order_type = GetGraphOrderType(final_graph_id_);
if (cond_graph_index >= graph_order_type.size()) {
MS_LOG(EXCEPTION) << "cond_graph_index " << cond_graph_index << " out of range " << graph_order_types_.size();
}
graph_order_type[cond_graph_index] = CONDITION_GRAPH;
// update disinction label of false graph,update before merge to sure the distinction
// update distinction label of false graph,update before merge to sure the distinction
if (false_graph_id != kInvalidGraphId) {
// false graph and condition in graph same stream
auto conditon_graph = GetGraph(cond_graph_id);
SetStreamDistinctionLabel(GetGraph(false_graph_id), GetDistinctionLabel(conditon_graph), true);
auto condition_graph = GetGraph(cond_graph_id);
SetStreamDistinctionLabel(GetGraph(false_graph_id), GetDistinctionLabel(condition_graph), true);
// if false graph is a condition graph and has been switch compiled before,it's false should be updated again
auto cond_it = switchs_.find(false_graph_id);
while (cond_it != switchs_.end() && cond_it->second.second != kInvalidGraphId) {
auto cond_it = switches_.find(false_graph_id);
while (cond_it != switches_.end() && cond_it->second.second != kInvalidGraphId) {
cond_graph_id = cond_it->first;
false_graph_id = cond_it->second.second;
conditon_graph = GetGraph(cond_graph_id);
SetStreamDistinctionLabel(GetGraph(false_graph_id), GetDistinctionLabel(conditon_graph), true);
cond_it = switchs_.find(false_graph_id);
condition_graph = GetGraph(cond_graph_id);
SetStreamDistinctionLabel(GetGraph(false_graph_id), GetDistinctionLabel(condition_graph), true);
cond_it = switches_.find(false_graph_id);
}
}
} // namespace session
@ -603,11 +603,11 @@ void AscendSession::SwitchCompile(GraphId cond_graph_id, GraphId true_graph_id,
void AscendSession::MergeSwitchCompile() {
auto graph_execute_order = GetGraphOrder(final_graph_id_);
auto &graph_order_type = GetGraphOrderType(final_graph_id_);
for (auto switch_compile : switchs_) {
for (auto switch_compile : switches_) {
auto cond_graph_id = switch_compile.first;
auto true_graph_id = switch_compile.second.first;
auto false_graph_id = switch_compile.second.second;
MS_LOG(INFO) << "switch compile: " << cond_graph_id << " " << true_graph_id << " " << false_graph_id;
MS_LOG(INFO) << "Switch compile: " << cond_graph_id << " " << true_graph_id << " " << false_graph_id;
auto condition_graph = GetGraph(cond_graph_id);
auto final_graph = GetGraph(final_graph_id_);
MS_EXCEPTION_IF_NULL(condition_graph);
@ -631,8 +631,8 @@ void AscendSession::MergeSwitchCompile() {
InsertStreamActiveToGraph(prev_graph_id, GetDistinctionLabel(condition_graph));
}
// if this is a 'if' condition
auto it = while_condtion_graphs_.find(cond_graph_id);
if (it == while_condtion_graphs_.end()) {
auto it = while_condition_graphs_.find(cond_graph_id);
if (it == while_condition_graphs_.end()) {
CopyOutputOfIf(false_graph_id);
} else {
// if it is a while,insert a stream active to true graph
@ -640,17 +640,17 @@ void AscendSession::MergeSwitchCompile() {
InsertStreamActiveToGraph(from_graph, GetDistinctionLabel(condition_graph));
}
}
MS_LOG(INFO) << "end";
MS_LOG(INFO) << "Finish!";
}
// insert active to graph
void AscendSession::SetActive(GraphId from, GraphId to) {
if (while_condtion_graphs_.find(to) != while_condtion_graphs_.end()) {
if (while_condition_graphs_.find(to) != while_condition_graphs_.end()) {
MS_LOG(WARNING) << " to " << to << " has been exits in map,from " << from << ",exist from "
<< while_condtion_graphs_[to];
<< while_condition_graphs_[to];
return;
}
MS_LOG(INFO) << "from " << from << " to " << to;
MS_LOG(INFO) << "From " << from << " to " << to;
auto &graph_order = GetGraphOrder(final_graph_id_);
auto &graph_type = GetGraphOrderType(final_graph_id_);
std::vector<GraphId> graph_order_new;
@ -669,21 +669,21 @@ void AscendSession::SetActive(GraphId from, GraphId to) {
// set the graph type of condition graph
graph_type[ExecOrderOfChildGraph(final_graph_id_, to)] = CONDITION_GRAPH;
// record the condition graph into while condition set
while_condtion_graphs_[to] = from;
while_condition_graphs_[to] = from;
}
void AscendSession::SetChildGraphParameter(const AnfNodePtr &front_anf, const AnfNodePtr &backend_parameter) {
MS_LOG(INFO) << "start";
MS_LOG(INFO) << "Start!";
MS_EXCEPTION_IF_NULL(backend_parameter);
MS_EXCEPTION_IF_NULL(front_anf);
if (!backend_parameter->isa<Parameter>()) {
MS_LOG(EXCEPTION) << "backend parameter's type is not a parameter,but is " << backend_parameter->ToString();
MS_LOG(EXCEPTION) << "Backend parameter's type is not a parameter,but is " << backend_parameter->ToString();
}
auto from_graph_id = GetGraphIdByNode(front_anf);
auto from_graph = GetGraph(from_graph_id);
MS_EXCEPTION_IF_NULL(from_graph);
MS_LOG(INFO) << "set node[" << front_anf->DebugString() << "] of graph[" << from_graph_id << "]to node["
MS_LOG(INFO) << "Set node[" << front_anf->DebugString() << "] of graph[" << from_graph_id << "]to node["
<< backend_parameter->DebugString() << "] of graph[" << AnfAlgo::GetGraphId(backend_parameter.get())
<< "]";
// a node should not assign to itself
@ -697,26 +697,27 @@ void AscendSession::SetChildGraphParameter(const AnfNodePtr &front_anf, const An
if (!AnfAlgo::OutputAddrExist(backend_arg, 0)) {
// set parameter's addr in child graph to parameter in final graph
AnfAlgo::SetOutputAddr(AnfAlgo::GetMutableOutputAddr(backend_parameter, 0), 0, backend_arg.get());
MS_LOG(INFO) << "assign mem of node" << backend_parameter->DebugString() << " of graph "
MS_LOG(INFO) << "Assign mem of node" << backend_parameter->DebugString() << " of graph "
<< AnfAlgo::GetGraphId(backend_parameter.get()) << " to node" << backend_arg->DebugString()
<< "of graph " << AnfAlgo::GetGraphId(backend_arg.get());
return;
}
}
InsertMultipleAssignToGraph(from_graph_id, backend_arg, backend_parameter);
// if front anf is a parameter,we can assign the value back,because backend_parameter won't be change in it's graph
// unless it's a weigth.If backend_parameter is a weight,we do should assign the value back
// if front anf is a parameter, we can assign the value back, because backend_parameter
// won't be changed in it's graph unless it's a weight. If backend_parameter is a weight,
// we do should assign the value back.
auto to_graph_id = AnfAlgo::GetGraphId(backend_parameter.get());
auto to_graph = GetGraph(to_graph_id);
MS_EXCEPTION_IF_NULL(to_graph);
if (backend_arg->isa<Parameter>() && !to_graph->execution_order().empty()) {
InsertMultipleAssignToGraph(to_graph_id, backend_parameter, backend_arg);
}
MS_LOG(INFO) << "end";
MS_LOG(INFO) << "Finish!";
}
void AscendSession::SetChildGraphParameter(const tensor::TensorPtr &front_tensor, const AnfNodePtr &backend_parameter) {
MS_LOG(INFO) << "start";
MS_LOG(INFO) << "Start!";
// sync data from host to device
MS_EXCEPTION_IF_NULL(front_tensor);
size_t tensor_size = front_tensor->data().nbytes();
@ -724,9 +725,9 @@ void AscendSession::SetChildGraphParameter(const tensor::TensorPtr &front_tensor
MS_EXCEPTION_IF_NULL(addr);
if (!addr->SyncHostToDevice(front_tensor->shape(), tensor_size, front_tensor->data_type(),
front_tensor->data_c(false))) {
MS_LOG(EXCEPTION) << "tensor SyncHostToDevice fail!";
MS_LOG(EXCEPTION) << "Tensor SyncHostToDevice fail!";
}
MS_LOG(INFO) << "end";
MS_LOG(INFO) << "Finish!";
}
void AscendSession::UpdateGraphOrder(GraphId to_graph_id) {
@ -743,7 +744,7 @@ void AscendSession::UpdateGraphOrder(GraphId to_graph_id) {
graph_order.push_back(to_graph_id);
graph_type.push_back(COMMON_GRAPH);
for (size_t i = 0; i < graph_order.size(); i++) {
MS_LOG(INFO) << "index " << i << ",graph_id " << graph_order[i] << ",graph_type" << graph_type[i];
MS_LOG(INFO) << "Index " << i << ",graph_id " << graph_order[i] << ",graph_type" << graph_type[i];
}
}
@ -775,10 +776,10 @@ void AscendSession::SetChildGraphInput(GraphId g, const VectorRef &args) {
SetChildGraphParameter(value->cast<TensorPtr>(), graph_inputs[input_index]);
input_index++;
} else {
MS_LOG(EXCEPTION) << "Unxpected arg type " << args[i].ToString();
MS_LOG(EXCEPTION) << "Unexpected arg type " << args[i].ToString();
}
}
MS_LOG(INFO) << "end";
MS_LOG(INFO) << "Finish!";
}
GraphId AscendSession::GetGraphIdByNode(const AnfNodePtr &front_anf) const {
@ -796,7 +797,7 @@ GraphId AscendSession::GetGraphIdByNode(const AnfNodePtr &front_anf) const {
}
void AscendSession::MergeGraphExecOrder() {
MS_LOG(INFO) << "start";
MS_LOG(INFO) << "Start!";
// insert switch to graph
MergeSwitchCompile();
// merge graph order
@ -805,7 +806,7 @@ void AscendSession::MergeGraphExecOrder() {
auto final_graph = GetGraph(final_graph_id_);
MS_EXCEPTION_IF_NULL(final_graph);
if (graph_order.empty()) {
MS_LOG(WARNING) << "graph output is a lonely variable not linked to any op!";
MS_LOG(WARNING) << "Graph output is a lonely variable not linked to any op!";
return;
}
// if first graph is common,the final graph has no label,then set the stream of final graph same with the first graph
@ -821,7 +822,7 @@ void AscendSession::MergeGraphExecOrder() {
last_graph = child_graph;
MS_EXCEPTION_IF_NULL(child_graph);
auto exec_order = child_graph->execution_order();
MS_LOG(INFO) << "merge graph,graph_id " << graph_id;
MS_LOG(INFO) << "Merge graph,graph_id " << graph_id;
(void)std::copy(exec_order.begin(), exec_order.end(), std::back_inserter(final_exec_order));
// add all value nodes of child graphs to final graph
for (auto &value_node : child_graph->graph_value_nodes()) {
@ -875,11 +876,11 @@ void AscendSession::InsertAssignToGraph(GraphId graph_id, const AnfNodePtr &from
void AscendSession::InsertMultipleAssignToGraph(GraphId graph_id, const AnfNodePtr &from, const AnfNodePtr &to) {
std::vector<AnfNodePtr> from_outputs = AnfAlgo::GetAllOutput(from, {prim::kPrimTupleGetItem});
std::vector<AnfNodePtr> to_outputs = AnfAlgo::GetAllOutput(to, {prim::kPrimTupleGetItem});
MS_LOG(INFO) << "insert assigns from [" << AnfAlgo::GetGraphId(from.get()) << "] to ["
MS_LOG(INFO) << "Insert assigns from [" << AnfAlgo::GetGraphId(from.get()) << "] to ["
<< AnfAlgo::GetGraphId(to.get()) << "]";
if (from_outputs.size() != to_outputs.size()) {
MS_LOG(INFO) << "from[" << from->DebugString(5) << "] to[" << to->DebugString(5) << "]";
MS_LOG(EXCEPTION) << "from outputs size[" << from_outputs.size() << "] is not equal to to outputs size["
MS_LOG(INFO) << "From[" << from->DebugString(5) << "] to[" << to->DebugString(5) << "]";
MS_LOG(EXCEPTION) << "From outputs size[" << from_outputs.size() << "] is not equal to to outputs size["
<< to_outputs.size() << "]";
}
for (size_t i = 0; i < from_outputs.size(); i++) {
@ -898,7 +899,7 @@ void AscendSession::InsertStreamActiveToGraph(GraphId graph_id, uint32_t actived
auto kernel_build_info_builder = std::make_shared<kernel::KernelBuildInfo::KernelBuildInfoBuilder>();
kernel_build_info_builder->SetKernelType(KernelType::RT_KERNEL);
AnfAlgo::SetSelectKernelBuildInfo(kernel_build_info_builder->Build(), active_node.get());
// set the actived stream id into the attr of active node
// set the active stream id into the attr of active node
std::vector<uint32_t> active_index_value = {};
active_index_value.push_back(actived_stream);
AnfAlgo::SetNodeAttr(kAttrActiveStreamList, MakeValue<std::vector<uint32_t>>(active_index_value), active_node);
@ -922,7 +923,7 @@ size_t AscendSession::ExecOrderOfChildGraph(GraphId final_graph, GraphId child_g
std::vector<GraphId> &AscendSession::GetGraphOrder(GraphId final_graph_id) {
auto graph_order_iter = graph_execute_orders_.find(final_graph_id);
if (graph_order_iter == graph_execute_orders_.end()) {
MS_LOG(EXCEPTION) << "final graph" << final_graph_id << "has no child graph";
MS_LOG(EXCEPTION) << "Final graph" << final_graph_id << "has no child graph";
}
return graph_order_iter->second;
}
@ -931,7 +932,7 @@ std::vector<GraphId> &AscendSession::GetGraphOrder(GraphId final_graph_id) {
std::vector<GraphType> &AscendSession::GetGraphOrderType(GraphId final_graph_id) {
auto graph_type_iter = graph_order_types_.find(final_graph_id);
if (graph_type_iter == graph_order_types_.end()) {
MS_LOG(EXCEPTION) << "final graph" << final_graph_id << "has no graph_order_types_";
MS_LOG(EXCEPTION) << "Final graph" << final_graph_id << "has no graph_order_types_";
}
return graph_type_iter->second;
}

13
mindspore/ccsrc/session/ascend_session.h
View File

@ -48,13 +48,14 @@ class AscendSession : public SessionBasic {
GraphId SetFinalGraphInput(const std::vector<AnfNodePtr> &args) override;
// set output of final graph
void SetFinalGraphOutput(const BaseRef &output) override;
// insert switch and set the relative acitve ops
// insert switch and set the relative active ops
void SwitchCompile(GraphId cond_g, GraphId true_g, GraphId false_g) override;
// set args of child graph.the arg maybe come from a output of other child graphs,or from final graph's parameter
// set args of child graph. the arg maybe come from a output of other child graphs,
// or from final graph's parameter
void SetChildGraphInput(GraphId g, const VectorRef &args) override;
// get graph id in child graphs by ME front anf node pointer
GraphId GetGraphIdByNode(const AnfNodePtr &front_anf) const override;
// get grpah id of final graph
// get graph id of final graph
GraphId GetFinalRunGraph() const override { return final_graph_id_; }
// insert active to graph
void SetActive(GraphId, GraphId) override;
@ -112,9 +113,9 @@ class AscendSession : public SessionBasic {
// key is final_graph_id,value is the graph types of child graphs
std::unordered_map<GraphId, std::vector<GraphType>> graph_order_types_;
// record condition graph of while
std::unordered_map<GraphId, GraphId> while_condtion_graphs_;
// record all conditons
std::unordered_map<GraphId, std::pair<GraphId, GraphId>> switchs_;
std::unordered_map<GraphId, GraphId> while_condition_graphs_;
// record all conditions
std::unordered_map<GraphId, std::pair<GraphId, GraphId>> switches_;
// final_graph_id is used in every root graph has it's own session situation
GraphId final_graph_id_;
};

4
mindspore/ccsrc/session/gpu_session.cc
View File

@ -83,7 +83,7 @@ void GPUSession::Execute(const std::shared_ptr<KernelGraph> &kernel_graph) const
}
GraphId GPUSession::CompileGraph(const AnfNodePtrList &lst, const AnfNodePtrList &outputs) {
// Construct graph, if construct successs, graph_sum_ + 1
// Construct graph, if successfully, graph_sum_ + 1
auto graph_id = graph_sum_;
auto graph = ConstructKernelGraph(lst, outputs);
// Select kernel build info
@ -100,7 +100,7 @@ GraphId GPUSession::CompileGraph(const AnfNodePtrList &lst, const AnfNodePtrList
auto execution_order = graph->execution_order();
Reorder(&execution_order);
graph->set_execution_order(execution_order);
// Alloc memeory, include static memory and dynamic memory
// Alloc memory, including static memory and dynamic memory
AllocateMemory(graph.get());
// Reset memory resource
auto runtime_instance = device::KernelRuntimeManager::Instance().GetSingleKernelRuntime(kGPUDevice, device_id_);

42
mindspore/ccsrc/session/kernel_graph.cc
View File

@ -34,7 +34,7 @@ void PushNoVisitedNode(const AnfNodePtr &node, std::queue<AnfNodePtr> *que,
if (visited_nodes->find(node) == visited_nodes->end()) {
que->push(node);
(void)visited_nodes->insert(node);
MS_LOG(DEBUG) << "push que:" << node->DebugString();
MS_LOG(DEBUG) << "Push que:" << node->DebugString();
}
}
} // namespace
@ -58,7 +58,7 @@ void KernelGraph::SetExecOrderByDefault() {
auto clear_output = [&zero_output_nodes, &allreduce_nodes, &visited_nodes, this](const AnfNodePtr &input) -> void {
if (node_output_num_[input] == 0 && visited_nodes.find(input) == visited_nodes.end()) {
MS_EXCEPTION_IF_NULL(input);
MS_LOG(DEBUG) << "clear output num:" << input->DebugString();
MS_LOG(DEBUG) << "Clear output num:" << input->DebugString();
(void)visited_nodes.insert(input);
if (input->isa<CNode>() && AnfAlgo::GetCNodeName(input) == kAllReduceOpName) {
allreduce_nodes.push(input);
@ -85,21 +85,21 @@ void KernelGraph::SetExecOrderByDefault() {
if (it == node_input_edges_.end()) {
// value node and parameter has no input,no need to print log
if (node->isa<CNode>()) {
MS_LOG(DEBUG) << "can not find node [" << node->DebugString() << "]";
MS_LOG(DEBUG) << "Can not find node [" << node->DebugString() << "]";
}
continue;
}
for (const auto &input_edge : it->second) {
if (node_output_num_.find(input_edge.first) == node_output_num_.end()) {
MS_EXCEPTION_IF_NULL(input_edge.first);
MS_LOG(EXCEPTION) << "can't find node[" << input_edge.first->DebugString() << "]";
MS_LOG(EXCEPTION) << "Can't find node[" << input_edge.first->DebugString() << "]";
}
MS_EXCEPTION_IF_NULL(input_edge.first);
MS_LOG(DEBUG) << "decrese input:" << input_edge.first->DebugString() << ",node:" << node->DebugString()
MS_LOG(DEBUG) << "Decrease input:" << input_edge.first->DebugString() << ",node:" << node->DebugString()
<< ",num: " << node_output_num_[input_edge.first] << ",decrease num:" << input_edge.second;
if (node_output_num_[input_edge.first] < input_edge.second) {
MS_LOG(EXCEPTION) << "input node:" << input_edge.first->DebugString() << ",node_output_num"
<< node_output_num_[input_edge.first] << "depend edege:" << input_edge.second;
MS_LOG(EXCEPTION) << "Input node:" << input_edge.first->DebugString() << ",node_output_num"
<< node_output_num_[input_edge.first] << "depend edge:" << input_edge.second;
}
node_output_num_[input_edge.first] = node_output_num_[input_edge.first] - input_edge.second;
clear_output(input_edge.first);
@ -120,20 +120,20 @@ void KernelGraph::CheckLoop() {
string str;
auto node_output_it = node_output_edges_.find(it.first);
if (node_output_it == node_output_edges_.end()) {
MS_LOG(EXCEPTION) << "can't find node [" << it.first->DebugString() << "]";
MS_LOG(EXCEPTION) << "Can't find node [" << it.first->DebugString() << "]";
}
for (const auto &output_edge : node_output_edges_[it.first]) {
MS_EXCEPTION_IF_NULL(output_edge.first);
str = str.append(output_edge.first->DebugString()).append("|");
}
if (it.second != 0) {
MS_LOG(WARNING) << "node:" << it.first->DebugString() << ",outputs:" << str << ",output num:" << it.second;
MS_LOG(WARNING) << "Node:" << it.first->DebugString() << ",outputs:" << str << ",output num:" << it.second;
none_zero_output[it.first] = it.second;
}
}
// if don't consider control depend and loop exit,a exception will be throw
if (!none_zero_output.empty()) {
MS_LOG(EXCEPTION) << "nodes have loop,left node num:" << none_zero_output.size();
MS_LOG(EXCEPTION) << "Nodes have loop, left node num:" << none_zero_output.size();
}
}
@ -152,7 +152,7 @@ CNodePtr KernelGraph::NewCNode(const CNodePtr &cnode) {
MS_EXCEPTION_IF_NULL(cnode);
auto new_cnode = std::make_shared<CNode>(*cnode);
// if a cnode is created not from front,this cnode won't be in map,so when replace it,we shouldn't update map
if (BakcendNodeExistInFrontBackendMap(cnode)) {
if (BackendNodeExistInFrontBackendMap(cnode)) {
FrontBackendlMapUpdate(cnode, new_cnode);
}
AnfAlgo::SetGraphId(graph_id_, cnode.get());
@ -299,7 +299,7 @@ AnfNodePtr KernelGraph::GetBackendAnfByFrontAnf(const AnfNodePtr &front_anf) {
return front_backend_anf_map_[front_anf];
}
bool KernelGraph::BakcendNodeExistInFrontBackendMap(const AnfNodePtr &backend_anf) {
bool KernelGraph::BackendNodeExistInFrontBackendMap(const AnfNodePtr &backend_anf) {
return backend_front_anf_map_.find(backend_anf) != backend_front_anf_map_.end();
}
@ -317,9 +317,9 @@ void KernelGraph::TensorValueNodeMapAdd(const tensor::TensorPtr &tensor, const V
}
void KernelGraph::AddDependEdge(const AnfNodePtr &node, const AnfNodePtr &input, size_t depend_edge_num) {
MS_LOG(DEBUG) << "input:" << input->DebugString() << ", node:" << node->DebugString() << ",num:" << depend_edge_num;
MS_LOG(DEBUG) << "Input:" << input->DebugString() << ", node:" << node->DebugString() << ",num:" << depend_edge_num;
auto output_depend_edge = std::pair<AnfNodePtr, size_t>(node, depend_edge_num);
// add output depend eddge of input
// add output depend edge of input
auto output_it = node_output_edges_.find(input);
if (output_it == node_output_edges_.end()) {
node_output_edges_[input] = std::vector<std::pair<AnfNodePtr, size_t>>{output_depend_edge};
@ -346,7 +346,7 @@ std::vector<AnfNodePtr> KernelGraph::GetOutputNodes(const AnfNodePtr &node) {
MS_EXCEPTION_IF_NULL(node);
auto it = node_output_edges_.find(node);
if (it == node_output_edges_.end()) {
MS_LOG(EXCEPTION) << "can'f find node[" << node->DebugString() << "]";
MS_LOG(EXCEPTION) << "Can't find node[" << node->DebugString() << "]";
}
std::vector<AnfNodePtr> output_nodes;
auto trans = [](const std::pair<AnfNodePtr, size_t> &pair) -> AnfNodePtr { return pair.first; };
@ -372,7 +372,7 @@ void KernelGraph::UpdateControlDependRelations(const std::vector<AnfNodePtr> &de
MS_EXCEPTION_IF_NULL(depend_node);
std::vector<AnfNodePtr> prior_nodes = {prior_node};
std::vector<AnfNodePtr> depend_nodes = {depend_node};
MS_LOG(INFO) << "prior node[" << prior_node->DebugString() << "],depend node[" << depend_node->DebugString()
MS_LOG(INFO) << "Prior node[" << prior_node->DebugString() << "],depend node[" << depend_node->DebugString()
<< "],depend_mode=[" << AnfAlgo::GetNodeAttr<int>(cnode, "depend_mode") << "]";
if (prior_node->isa<Parameter>()) {
prior_nodes = GetOutputNodes(prior_node);
@ -384,7 +384,7 @@ void KernelGraph::UpdateControlDependRelations(const std::vector<AnfNodePtr> &de
for (auto &second_node : depend_nodes) {
MS_EXCEPTION_IF_NULL(first_node);
MS_EXCEPTION_IF_NULL(second_node);
MS_LOG(INFO) << "add first node:" << first_node->DebugString() << ",second node:" << second_node->DebugString();
MS_LOG(INFO) << "Add first node:" << first_node->DebugString() << ",second node:" << second_node->DebugString();
AddDependEdge(second_node, first_node, 1);
}
}
@ -437,18 +437,18 @@ void KernelGraph::BfsToUpdateNodeOutput() {
MS_EXCEPTION_IF_NULL(cnode);
// handle data links
for (const auto &input : cnode->inputs()) {
size_t dpend_edge_num = 1;
size_t depend_edge_num = 1;
// handle control depend,all inputs of control depend has no depend edge
if (HandleControlDependNode(input, &que, &visited_nodes)) {
control_depends.push_back(input);
dpend_edge_num = 0;
depend_edge_num = 0;
}
// the 2rd input of depend is no depend edge
if (AnfAlgo::CheckPrimitiveType(node, prim::kPrimDepend) && input == cnode->input(kDependAttachNodeIndex)) {
dpend_edge_num = 0;
depend_edge_num = 0;
}
PushNoVisitedNode(input, &que, &visited_nodes);
AddDependEdge(node, input, dpend_edge_num);
AddDependEdge(node, input, depend_edge_num);
}
}
UpdateControlDependRelations(control_depends);

4
mindspore/ccsrc/session/kernel_graph.h
View File

@ -62,8 +62,8 @@ class KernelGraph : public FuncGraph {
void FrontBackendlMapUpdate(const AnfNodePtr &old_backend_anf, const AnfNodePtr &new_backend_anf);
// get backend anf by front anf
AnfNodePtr GetBackendAnfByFrontAnf(const AnfNodePtr &front_anf);
// check backend node wheteher exist in map
bool BakcendNodeExistInFrontBackendMap(const AnfNodePtr &backend_anf);
// check backend node whether exist in map
bool BackendNodeExistInFrontBackendMap(const AnfNodePtr &backend_anf);
// get value node by tensor
ValueNodePtr GetValueNodeByTensor(const tensor::TensorPtr &tensor);
// add value node tensor relation map

26
mindspore/ccsrc/session/session_basic.cc
View File

@ -281,7 +281,7 @@ std::vector<AnfNodePtr> CreateParameterFromTuple(const AnfNodePtr &node, KernelG
}
continue;
}
// creata single parameter if is a abstract real kernel
// create single parameter if is a abstract real kernel
create_parameter(out_node->abstract());
}
return parameters;
@ -413,7 +413,7 @@ CNodePtr SessionBasic::CreateNewCNode(const CNodePtr &cnode, KernelGraph *graph)
cnode_inputs.emplace_back(graph->GetBackendAnfByFrontAnf(anf));
continue;
} else if (anf->isa<ValueNode>() && !IsValueNode<FuncGraph>(anf)) {
// if input is a value ndoe,
// if input is a value node,
auto new_value_node = CreateNewValueNode(anf, graph);
if (new_value_node != nullptr) {
cnode_inputs.emplace_back(new_value_node);
@ -549,7 +549,7 @@ void SessionBasic::Reorder(std::vector<CNodePtr> *node_list) {
for (const auto &node : *node_list) {
MS_EXCEPTION_IF_NULL(node);
if (kOptOpeatorSet.find(AnfAlgo::GetCNodeName(node)) != kOptOpeatorSet.end()) {
if (kOptOperatorSet.find(AnfAlgo::GetCNodeName(node)) != kOptOperatorSet.end()) {
all_opt_list.emplace_back(node);
} else {
non_opt_list.emplace_back(node);
@ -599,7 +599,7 @@ void SessionBasic::ToTensorPtr(const OpRunInfo &op_run_info, std::vector<tensor:
MS_EXCEPTION_IF_NULL(inputs);
MS_EXCEPTION_IF_NULL(tensor_mask);
if (op_run_info.op_inputs.size() != op_run_info.inputs_mask.size()) {
MS_LOG(EXCEPTION) << "op input size " << op_run_info.op_inputs.size() << " should be equal to op input mask size "
MS_LOG(EXCEPTION) << "Op input size " << op_run_info.op_inputs.size() << " should be equal to op input mask size "
<< op_run_info.inputs_mask.size();
}
size_t input_num = op_run_info.op_inputs.size();
@ -636,7 +636,7 @@ CNodePtr SessionBasic::ConstructOutput(const AnfNodePtrList &outputs, const std:
if (backend_anf != nullptr) {
return backend_anf;
}
MS_LOG(EXCEPTION) << "did not find the node in the equiv map!";
MS_LOG(EXCEPTION) << "Can not find the node in the equiv map!";
};
output_args.push_back(NewValueNode(prim::kPrimMakeTuple));
(void)std::transform(outputs.begin(), outputs.end(), std::back_inserter(output_args),
@ -645,7 +645,7 @@ CNodePtr SessionBasic::ConstructOutput(const AnfNodePtrList &outputs, const std:
}
void SessionBasic::CreateOutputNode(const CNodePtr &cnode, const std::shared_ptr<KernelGraph> &graph) {
MS_LOG(INFO) << "start";
MS_LOG(INFO) << "Start!";
std::vector<AnfNodePtr> make_tuple_inputs;
make_tuple_inputs.push_back(NewValueNode(prim::kPrimMakeTuple));
if (AnfRuntimeAlgorithm::GetOutputTensorNum(cnode) > 1) {
@ -667,14 +667,14 @@ void SessionBasic::CreateOutputNode(const CNodePtr &cnode, const std::shared_ptr
// create output
auto g_output = graph->NewCNode(make_tuple_inputs);
graph->set_output(g_output);
// set graph manager,which now is only used to get valuendoes and hardware optimizing
// set graph manager,which now is only used to get valuenodes and hardware optimizing
MS_EXCEPTION_IF_NULL(context_);
FuncGraphManagerPtr manager = context_->manager();
if (manager != nullptr) {
manager->AddFuncGraph(graph);
graph->set_manager(manager);
}
MS_LOG(INFO) << "end";
MS_LOG(INFO) << "Finish!";
}
std::shared_ptr<KernelGraph> SessionBasic::ConstructSingleOpGraph(const OpRunInfo &op_run_info) {
@ -694,9 +694,9 @@ std::shared_ptr<KernelGraph> SessionBasic::ConstructSingleOpGraph(const OpRunInf
std::vector<tensor::TensorPtr> input_tensors;
std::vector<bool> tensors_mask;
ToTensorPtr(op_run_info, &input_tensors, &tensors_mask);
MS_LOG(INFO) << "input tensor size" << input_tensors.size();
MS_LOG(INFO) << "Input tensor size" << input_tensors.size();
if (input_tensors.size() != tensors_mask.size()) {
MS_LOG(EXCEPTION) << "input tensors size " << input_tensors.size() << " should be equal to tensors mask size "
MS_LOG(EXCEPTION) << "Input tensors size " << input_tensors.size() << " should be equal to tensors mask size "
<< tensors_mask.size();
}
for (size_t i = 0; i < input_tensors.size(); ++i) {
@ -711,7 +711,7 @@ std::shared_ptr<KernelGraph> SessionBasic::ConstructSingleOpGraph(const OpRunInf
cnode->set_abstract(op_run_info.abstract);
// set const input to attr if value is not a tensor,such as scalar or tuple
RunOpConvertConstInputToAttr(op_run_info, cnode);
// set exectuion order
// set execution order
std::vector<CNodePtr> exe_order = {cnode};
graph->set_execution_order(exe_order);
// set output
@ -734,14 +734,14 @@ BaseRef SessionBasic::TransformBaseRefListToTuple(const BaseRef &base_ref) {
py::tuple tensor_tuple = py::cast<py::tuple>(obj);
output_tensors[i] = tensor_tuple;
} else {
MS_LOG(EXCEPTION) << "The output is not a base ref list or a tensor !";
MS_LOG(EXCEPTION) << "The output is not a base ref list or a tensor!";
}
}
return output_tensors; // turn tuple to py::object and store in PyObjectRef
} else if (utils::isa<tensor::TensorPtr>(base_ref)) {
return base_ref;
} else {
MS_LOG(EXCEPTION) << "The output is not a base ref list or a tensor !";
MS_LOG(EXCEPTION) << "The output is not a base ref list or a tensor!";
}
}
} // namespace session

4
mindspore/ccsrc/session/session_basic.h
View File

@ -56,7 +56,7 @@ class SessionBasic {
virtual ~SessionBasic() { summary_callback_ = nullptr; }
virtual GraphId CompileGraph(const AnfNodePtrList &lst, const AnfNodePtrList &outputs) = 0;
// build graph ,used to handle mupltiple child graphs
// build graph, used to handle multiple child graphs
virtual void BuildGraph(GraphId) {}
virtual void RunGraph(const GraphId &graph_id, const std::vector<tensor::TensorPtr> &inputs, VectorRef *outputs) = 0;
@ -75,7 +75,7 @@ class SessionBasic {
virtual GraphId SetFinalGraphInput(const std::vector<AnfNodePtr> &) { return kInvalidGraphId; }
// set output of final graph
virtual void SetFinalGraphOutput(const BaseRef &) {}
// insert switch and set the relative acitve ops
// insert switch and set the relative active ops
virtual void SwitchCompile(GraphId, GraphId, GraphId) {}
// set args of child graph.the arg maybe come from a output of other child graphs,or from final graph's parameter
virtual void SetChildGraphInput(GraphId, const VectorRef &) {}

2
mindspore/ccsrc/utils/utils.h
View File

@ -186,7 +186,7 @@ const std::vector<std::set<std::string>> kShapeSupportFormatMap = {k1DSupportFor
k4DSupportFormat};
const std::set<std::string> kDefaultCompatibleFormat = {kOpFormat_ND, kOpFormat_NCHW, kOpFormat_NHWC, kOpFormat_HWCN};
const std::set<std::string> kOptOpeatorSet = {
const std::set<std::string> kOptOperatorSet = {
kMomentumOpName, kApplyMomentumOpName, kApplyAdadeltaOpName,
kApplyAdagradOpName, kApplyAdagradDAName, kApplyAdamOpName,
kApplyAdaMaxOpName, kApplyAddSignOpName, kApplyCenteredRMSPOpName,