!12437 [Ascend][GPU] Trigger final execution graph dump on dump enabled

From: @islam_amin
Reviewed-by: @john_tzanakakis
Signed-off-by:
pull/12437/MERGE
mindspore-ci-bot 4 years ago committed by Gitee
commit a99fcf890a

@ -65,6 +65,11 @@
#include "debug/data_dump/e2e_dump_util.h"
#include "debug/anf_ir_dump.h"
#include "debug/dump_proto.h"
#ifdef ENABLE_DEBUGGER
#include "debug/debugger/proto_exporter.h"
#else
#include "debug/debugger/proto_exporter_stub.h"
#endif
#include "toolchain/adx_datadump_server.h"
#ifdef ENABLE_DUMP_IR
#include "debug/rdr/running_data_recorder.h"
@ -802,6 +807,7 @@ void AscendSession::SelectKernel(const KernelGraph &kernel_graph) const {
void DumpInit() {
auto &json_parser = DumpJsonParser::GetInstance();
json_parser.Parse();
json_parser.CopyJsonToDir();
if (json_parser.async_dump_enabled()) {
if (AdxDataDumpServerInit() != 0) {
MS_LOG(EXCEPTION) << "Adx data dump server init failed";
@ -999,6 +1005,14 @@ void AscendSession::DumpAllGraphs(const std::vector<KernelGraphPtr> &all_graphs)
auto context_ptr = MsContext::GetInstance();
MS_EXCEPTION_IF_NULL(context_ptr);
bool save_graphs = context_ptr->get_param<bool>(MS_CTX_SAVE_GRAPHS_FLAG);
auto &json_parser = DumpJsonParser::GetInstance();
json_parser.Parse();
if (!save_graphs && !json_parser.e2e_dump_enabled() && !json_parser.async_dump_enabled()) {
return;
}
auto kernel_runtime = device::KernelRuntimeManager::Instance().GetKernelRuntime(kAscendDevice, device_id_);
MS_EXCEPTION_IF_NULL(kernel_runtime);
uint32_t device_id = kernel_runtime->device_id();
for (auto &graph : all_graphs) {
MS_EXCEPTION_IF_NULL(graph);
std::string tag = "graph_build";
@ -1009,6 +1023,19 @@ void AscendSession::DumpAllGraphs(const std::vector<KernelGraphPtr> &all_graphs)
DumpIRProto(graph, "vm_build_" + std::to_string(graph->graph_id()));
DumpIR("trace_code_graph", graph, true, kWholeStack);
}
std::string final_graph = "trace_code_graph_" + std::to_string(graph->graph_id());
if (json_parser.e2e_dump_enabled()) {
std::string target_dir =
json_parser.path() + "/" + json_parser.net_name() + "/device_" + std::to_string(device_id) + "/graphs";
std::string ir_file_path = target_dir + "/" + "ms_output_" + final_graph + ".ir";
DumpIRProtoWithSrcInfo(graph, final_graph, target_dir, kDebugWholeStack);
DumpIR("trace_code_graph", graph, true, kWholeStack, ir_file_path);
} else if (json_parser.async_dump_enabled()) {
std::string target_dir = json_parser.path() + "/device_" + std::to_string(device_id) + "/graphs";
std::string ir_file_path = target_dir + "/" + "ms_output_" + final_graph + ".ir";
DumpIRProtoWithSrcInfo(graph, final_graph, target_dir, kDebugWholeStack);
DumpIR("trace_code_graph", graph, true, kWholeStack, ir_file_path);
}
}
#endif
}

@ -62,7 +62,14 @@
#include "backend/optimizer/pass/communication_op_fusion.h"
#include "backend/optimizer/pass/getitem_tuple.h"
#include "common/trans.h"
#include "debug/anf_ir_dump.h"
#include "debug/data_dump/e2e_dump_util.h"
#ifdef ENABLE_DEBUGGER
#include "debug/debugger/proto_exporter.h"
#else
#include "debug/debugger/proto_exporter_stub.h"
#endif
#include "debug/data_dump/dump_json_parser.h"
#include "debug/tensor_load.h"
#include "debug/dump_proto.h"
#include "runtime/device/gpu/gpu_kernel_build.h"
@ -103,7 +110,9 @@ void GPUSession::Init(uint32_t device_id) {
auto ms_context = MsContext::GetInstance();
MS_EXCEPTION_IF_NULL(ms_context);
ms_context->set_param<uint32_t>(MS_CTX_DEVICE_ID, device_id);
auto &json_parser = DumpJsonParser::GetInstance();
// Dump json config file if dump is enabled
json_parser.CopyJsonToDir();
MS_LOG(INFO) << "Set device id " << device_id << " for gpu session.";
InitExecutor(kGPUDevice, device_id);
}
@ -361,6 +370,11 @@ GraphId GPUSession::CompileGraphImpl(KernelGraphPtr graph) {
auto context_ptr = MsContext::GetInstance();
MS_EXCEPTION_IF_NULL(context_ptr);
bool save_graphs = context_ptr->get_param<bool>(MS_CTX_SAVE_GRAPHS_FLAG);
auto runtime_instance = device::KernelRuntimeManager::Instance().GetSingleKernelRuntime(kGPUDevice, device_id_);
MS_EXCEPTION_IF_NULL(runtime_instance);
uint32_t device_id = runtime_instance->device_id();
auto &json_parser = DumpJsonParser::GetInstance();
json_parser.Parse();
// Dump .pb graph before graph optimization
if (save_graphs) {
DumpIRProto(graph, "before_opt_" + std::to_string(graph->graph_id()));
@ -399,6 +413,13 @@ GraphId GPUSession::CompileGraphImpl(KernelGraphPtr graph) {
if (save_graphs) {
DumpIRProto(graph, "after_opt_" + std::to_string(graph->graph_id()));
}
if (json_parser.e2e_dump_enabled()) {
std::string target_dir =
json_parser.path() + "/" + json_parser.net_name() + "/device_" + std::to_string(device_id) + "/graphs";
std::string ir_file_path = target_dir + "/" + "after_opt_" + std::to_string(graph->graph_id()) + ".ir";
DumpIRProtoWithSrcInfo(graph, "after_opt_" + std::to_string(graph->graph_id()), target_dir, kDebugWholeStack);
DumpIR("trace_code_graph", graph, true, kWholeStack, ir_file_path);
}
// Set graph manager.
MS_EXCEPTION_IF_NULL(context_);
FuncGraphManagerPtr manager = MakeManager({graph});

@ -558,12 +558,16 @@ void GetEnvDumpIrLineLevel(LocDumpMode *dump_location) {
}
#ifdef ENABLE_DUMP_IR
void DumpIR(const std::string &filename, const FuncGraphPtr &graph, bool dump_full_name, LocDumpMode dump_location) {
void DumpIR(const std::string &filename, const FuncGraphPtr &graph, bool dump_full_name, LocDumpMode dump_location,
const std::string &target_file) {
GetEnvDumpIrLineLevel(&dump_location);
if (graph == nullptr) {
return;
}
auto path = pipeline::GetSaveGraphsPathName(AddGlobalId(filename));
if (!target_file.empty()) {
path = target_file;
}
auto realpath = Common::GetRealPath(path);
if (!realpath.has_value()) {
MS_LOG(ERROR) << "Get real path failed. path=" << path;
@ -642,7 +646,7 @@ void DumpIRForRDR(const std::string &filename, const FuncGraphPtr &graph, bool d
}
#else
void DumpIR(const std::string &, const FuncGraphPtr &, bool, LocDumpMode) {
void DumpIR(const std::string &, const FuncGraphPtr &, bool, LocDumpMode, const std::string &) {
static bool already_printed = false;
if (already_printed) {
return;

@ -25,7 +25,7 @@ namespace mindspore {
enum LocDumpMode { kOff = 0, kTopStack = 1, kWholeStack = 2 };
constexpr char PARALLEL_STRATEGY[] = "strategy";
void DumpIR(const std::string &filename, const FuncGraphPtr &func_graph, bool dump_full_name = false,
LocDumpMode dump_location = kOff);
LocDumpMode dump_location = kOff, const std::string &target_file = "");
void PrintInputAndOutputInferType(std::ostringstream &buffer, const AnfNodePtr &nd);
void DumpIRForRDR(const std::string &filename, const FuncGraphPtr &func_graph, bool dump_full_name = false,

@ -38,9 +38,9 @@ class Common {
const bool &print_str = true);
static bool IsFilenameValid(const std::string &filename, const int &length_limit,
const std::string &error_message = "");
static bool CreateNotExistDirs(const std::string &path);
private:
static bool CreateNotExistDirs(const std::string &path);
static bool IsEveryFilenameValid(const std::string &path, const int &length_limit, const std::string &error_message);
};
} // namespace mindspore

@ -112,6 +112,28 @@ void DumpJsonParser::Parse() {
JudgeDumpEnabled();
}
void DumpJsonParser::CopyJsonToDir() {
this->Parse();
if (!IsDumpEnabled()) {
return;
}
auto dump_config_file = Common::GetConfigFile(kMindsporeDumpConfig);
if (!dump_config_file.has_value()) {
MS_LOG(EXCEPTION) << "Get dump config file failed";
}
std::ifstream json_file(dump_config_file.value());
if (async_dump_enabled_ || e2e_dump_enabled_) {
auto realpath = Common::GetRealPath(path_ + "/.metadata/data_dump.json");
if (!realpath.has_value()) {
MS_LOG(ERROR) << "Get real path failed in CopyJsonDir.";
}
std::ofstream json_copy(realpath.value());
json_copy << json_file.rdbuf();
json_copy.close();
ChangeFileMode(realpath.value(), S_IRUSR);
}
}
bool DumpJsonParser::DumpToFile(const std::string &filename, const void *data, size_t len) {
if (filename.empty() || data == nullptr || len == 0) {
MS_LOG(ERROR) << "Incorrect parameter.";

@ -34,6 +34,7 @@ class DumpJsonParser {
void Parse();
static bool DumpToFile(const std::string &filename, const void *data, size_t len);
void CopyJsonToDir();
bool NeedDump(const std::string &op_full_name) const;
void MatchKernel(const std::string &kernel_name);
void PrintUnusedKernel();

@ -233,6 +233,7 @@ message NodeProto {
// for debugger, full name with scope
optional string full_name = 8;
optional string source_address = 9;
}
// Models

@ -13,6 +13,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "debug/debugger/proto_exporter.h"
#include <fstream>
#include <map>
@ -22,60 +23,39 @@
#include <utility>
#include <algorithm>
#include "debug/common.h"
#include "debug/debugger/debugger.h"
#include "debug/data_dump/dump_json_parser.h"
#include "proto/debug_graph.pb.h"
#include "ir/graph_utils.h"
#include "utils/symbolic.h"
#include "utils/trace_base.h"
namespace mindspore {
class DebuggerProtoExporter {
public:
DebuggerProtoExporter() {}
~DebuggerProtoExporter() {}
std::string GetFuncGraphProtoString(const FuncGraphPtr &func_graph);
debugger::ModelProto GetFuncGraphProto(const FuncGraphPtr &func_graph);
private:
void InitModelInfo();
void GetOpNodeTypeAndAttrs(const FuncGraphPtr &func_graph, const AnfNodePtr &node, debugger::NodeProto *node_proto);
std::string GetOpNodeInputId(const FuncGraphPtr &func_graph, const AnfNodePtr &node,
const std::map<AnfNodePtr, size_t> &apply_map,
std::map<AnfNodePtr, size_t> *const_map_ptr);
void SetValueToProto(const ValuePtr &attr_value, debugger::ValueProto *value_proto);
void SetScalarToProto(const ScalarPtr &val, debugger::ValueProto *value_proto);
void SetSequenceToProto(const ValueSequeuePtr &val, debugger::ValueProto *value_proto);
void SetDictionaryToProto(const ValueDictionaryPtr &val, debugger::ValueProto *value_proto);
void SetNodeOutputType(const AnfNodePtr &node, debugger::TypeProto *type_proto);
void SetNodeOutputType(const TypePtr &node, const BaseShapePtr &shape, debugger::TypeProto *type_proto);
void ExportFuncGraph(const FuncGraphPtr &func_graph, debugger::GraphProto *graph_proto);
void ExportParameters(const FuncGraphPtr &func_graph, debugger::GraphProto *graph_proto);
void ExportCNodes(const FuncGraphPtr &func_graph, debugger::GraphProto *graph_proto,
std::map<AnfNodePtr, size_t> *const_map_ptr);
void ExportCNode(const FuncGraphPtr &func_graph, const CNodePtr &node, std::map<AnfNodePtr, size_t> *apply_map_ptr,
std::map<AnfNodePtr, size_t> *const_map_ptr, debugger::GraphProto *graph_proto);
void ExportFuncGraphOutput(const FuncGraphPtr &func_graph, const CNodePtr &ret_node,
const std::map<AnfNodePtr, size_t> &apply_map, std::map<AnfNodePtr, size_t> *const_map_ptr,
debugger::GraphProto *graph_proto);
void ExportValueNodes(const std::map<AnfNodePtr, size_t> &const_map, debugger::GraphProto *graph_proto);
static std::string GetConstNodeId(size_t idx) { return std::string("cst") + std::to_string(idx); }
debugger::ModelProto model_;
};
void DebuggerProtoExporter::SetNodeOutputType(const TypePtr &type, const BaseShapePtr &shape,
debugger::TypeProto *type_proto) {
if (type_proto == nullptr) {
return;
void CheckIfValidType(const TypePtr &type, debugger::TypeProto *type_proto) {
if (!(type->isa<Number>() || type->isa<TensorType>() || type->isa<Tuple>() || type->isa<TypeType>() ||
type->isa<List>() || type->isa<TypeAnything>() || type->isa<RefKeyType>() || type->isa<RefType>() ||
type->isa<Function>() || type->isa<TypeNone>() || type->isa<String>() || type->isa<SymbolicKeyType>() ||
type->isa<UMonadType>() || type->isa<IOMonadType>())) {
MS_LOG(EXCEPTION) << "Unknown type: " << type->type_name();
}
if (type == nullptr) {
type_proto->set_data_type(debugger::DT_UNDEFINED);
} else if (type->isa<Number>()) {
type_proto->set_data_type(GetDebuggerNumberDataType(type));
} else if (type->isa<TensorType>()) {
}
}
void DebuggerProtoExporter::SetNodeOutputType(const TypePtr &type, const BaseShapePtr &shape,
debugger::TypeProto *type_proto) {
if (type_proto == nullptr) {
return;
}
if (type != nullptr) {
CheckIfValidType(type, type_proto);
}
if (type->isa<TensorType>()) {
TypePtr elem_type = dyn_cast<TensorType>(type)->element();
type_proto->mutable_tensor_type()->set_elem_type(GetDebuggerNumberDataType(elem_type));
type_proto->set_data_type(debugger::DT_TENSOR);
@ -111,14 +91,10 @@ void DebuggerProtoExporter::SetNodeOutputType(const TypePtr &type, const BaseSha
type_proto->set_data_type(debugger::DT_NONE);
} else if (type->isa<String>()) {
type_proto->set_data_type(debugger::DT_STRING);
} else if (type->isa<SymbolicKeyType>()) {
// Do Nothing.
} else if (type->isa<UMonadType>()) {
type_proto->set_data_type(debugger::DT_UMONAD);
} else if (type->isa<IOMonadType>()) {
type_proto->set_data_type(debugger::DT_IOMONAD);
} else {
MS_LOG(EXCEPTION) << "Unknown type: " << type->type_name();
}
}
@ -325,14 +301,15 @@ std::string DebuggerProtoExporter::GetOpNodeInputId(const FuncGraphPtr &, const
MS_LOG(EXCEPTION) << "Unknown node type. node is '" << node->ToString() << "'";
}
std::string DebuggerProtoExporter::GetFuncGraphProtoString(const FuncGraphPtr &func_graph) {
std::string DebuggerProtoExporter::GetFuncGraphProtoString(const FuncGraphPtr &func_graph,
LocDebugDumpMode dump_location) {
if (func_graph == nullptr) {
return "";
}
InitModelInfo();
debugger::GraphProto *graph_proto = model_.mutable_graph();
ExportFuncGraph(func_graph, graph_proto);
ExportFuncGraph(func_graph, graph_proto, dump_location);
return model_.SerializeAsString();
}
@ -347,7 +324,8 @@ debugger::ModelProto DebuggerProtoExporter::GetFuncGraphProto(const FuncGraphPtr
return model_;
}
void DebuggerProtoExporter::ExportFuncGraph(const FuncGraphPtr &func_graph, debugger::GraphProto *graph_proto) {
void DebuggerProtoExporter::ExportFuncGraph(const FuncGraphPtr &func_graph, debugger::GraphProto *graph_proto,
LocDebugDumpMode dump_location) {
if (func_graph == nullptr || graph_proto == nullptr) {
return;
}
@ -362,7 +340,7 @@ void DebuggerProtoExporter::ExportFuncGraph(const FuncGraphPtr &func_graph, debu
ExportParameters(func_graph, graph_proto);
ExportCNodes(func_graph, graph_proto, &const_map);
ExportCNodes(func_graph, graph_proto, &const_map, dump_location);
ExportValueNodes(const_map, graph_proto);
}
@ -389,7 +367,7 @@ void DebuggerProtoExporter::ExportParameters(const FuncGraphPtr &func_graph, deb
}
void DebuggerProtoExporter::ExportCNodes(const FuncGraphPtr &func_graph, debugger::GraphProto *graph_proto,
std::map<AnfNodePtr, size_t> *const_map_ptr) {
std::map<AnfNodePtr, size_t> *const_map_ptr, LocDebugDumpMode dump_location) {
if (func_graph == nullptr || graph_proto == nullptr || const_map_ptr == nullptr) {
return;
}
@ -403,7 +381,7 @@ void DebuggerProtoExporter::ExportCNodes(const FuncGraphPtr &func_graph, debugge
}
auto cnode = node->cast<CNodePtr>();
if (cnode != func_graph->get_return()) {
ExportCNode(func_graph, cnode, &apply_map, const_map_ptr, graph_proto);
ExportCNode(func_graph, cnode, &apply_map, const_map_ptr, graph_proto, dump_location);
} else {
ExportFuncGraphOutput(func_graph, cnode, apply_map, const_map_ptr, graph_proto);
}
@ -412,8 +390,8 @@ void DebuggerProtoExporter::ExportCNodes(const FuncGraphPtr &func_graph, debugge
void DebuggerProtoExporter::ExportCNode(const FuncGraphPtr &func_graph, const CNodePtr &node,
std::map<AnfNodePtr, size_t> *apply_map_ptr,
std::map<AnfNodePtr, size_t> *const_map_ptr,
debugger::GraphProto *graph_proto) {
std::map<AnfNodePtr, size_t> *const_map_ptr, debugger::GraphProto *graph_proto,
LocDebugDumpMode dump_location) {
if (func_graph == nullptr || node == nullptr || apply_map_ptr == nullptr || const_map_ptr == nullptr ||
graph_proto == nullptr) {
return;
@ -440,7 +418,14 @@ void DebuggerProtoExporter::ExportCNode(const FuncGraphPtr &func_graph, const CN
// add full_name for debugger
node_proto->set_full_name(node->fullname_with_scope());
MS_LOG(INFO) << "full_name: " << node->fullname_with_scope();
if (dump_location == kDebugWholeStack) {
std::ostringstream buffer;
auto traces = mindspore::trace::GetSourceLineList(node);
for (auto &trace : traces) {
buffer << " # " << trace;
}
node_proto->set_source_address(buffer.str());
}
// process OP inputs
for (size_t i = 1; i < inputs.size(); ++i) {
debugger::InputProto *input_proto = node_proto->add_input();
@ -546,4 +531,63 @@ debugger::DataType GetDebuggerNumberDataType(const TypePtr &type) {
}
}
#ifdef ENABLE_DUMP_IR
void DumpIRProtoWithSrcInfo(const FuncGraphPtr &func_graph, const std::string &suffix, const std::string &target_dir,
LocDebugDumpMode dump_location) {
DebuggerProtoExporter exporter;
std::string graph_proto = exporter.GetFuncGraphProtoString(func_graph, dump_location);
if (func_graph == nullptr) {
MS_LOG(ERROR) << "Func graph is nullptr";
return;
}
std::string file_path = target_dir + "/" + "ms_output_" + suffix + ".pb";
bool status = Common::CreateNotExistDirs(target_dir);
if (!status) {
MS_LOG(ERROR) << "Failed at CreateNotExistDirs in dump_proto";
return;
}
if (file_path.size() > PATH_MAX) {
MS_LOG(ERROR) << "File path " << file_path << " is too long.";
return;
}
char real_path[PATH_MAX] = {0};
char *real_path_ret = nullptr;
#if defined(_WIN32) || defined(_WIN64)
real_path_ret = _fullpath(real_path, file_path.c_str(), PATH_MAX);
#else
real_path_ret = realpath(file_path.c_str(), real_path);
#endif
if (nullptr == real_path_ret) {
MS_LOG(DEBUG) << "dir " << file_path << " does not exit.";
} else {
std::string path_string = real_path;
if (chmod(common::SafeCStr(path_string), S_IRUSR | S_IWUSR) == -1) {
MS_LOG(ERROR) << "Modify file:" << real_path << " to rw fail.";
return;
}
}
// write to pb file
std::ofstream ofs(real_path);
if (!ofs.is_open()) {
MS_LOG(ERROR) << "Open file '" << real_path << "' failed!";
return;
}
ofs << graph_proto;
ofs.close();
// set file mode to read only by user
ChangeFileMode(file_path, S_IRUSR);
}
#else
void DumpIRProtoWithSrcInfo(const FuncGraphPtr &, const std::string &, const std::string &) {
static bool already_printed = false;
if (already_printed) {
return;
}
already_printed = true;
MS_LOG(WARNING) << "The functionality of dumping function graph IR in protobuf format is disabled,"
<< "because ENABLE_DEBUGGER option is off"
<< "please recompile source to enable it. See help of building script.";
}
#endif
} // namespace mindspore

@ -0,0 +1,73 @@
/**
* Copyright 2021 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef MINDSPORE_PROTO_EXPORTER_H
#define MINDSPORE_PROTO_EXPORTER_H
#include <map>
#include <string>
#include <vector>
#include "debug/common.h"
#include "debug/data_dump/dump_json_parser.h"
#include "ir/graph_utils.h"
#include "proto/debug_graph.pb.h"
#include "utils/symbolic.h"
#include "utils/trace_base.h"
namespace mindspore {
enum LocDebugDumpMode { kDebugOff = 0, kDebugTopStack = 1, kDebugWholeStack = 2 };
class DebuggerProtoExporter {
public:
DebuggerProtoExporter() {}
~DebuggerProtoExporter() {}
std::string GetFuncGraphProtoString(const FuncGraphPtr &func_graph, LocDebugDumpMode dump_location = kDebugOff);
debugger::ModelProto GetFuncGraphProto(const FuncGraphPtr &func_graph);
private:
void InitModelInfo();
void GetOpNodeTypeAndAttrs(const FuncGraphPtr &func_graph, const AnfNodePtr &node, debugger::NodeProto *node_proto);
std::string GetOpNodeInputId(const FuncGraphPtr &func_graph, const AnfNodePtr &node,
const std::map<AnfNodePtr, size_t> &apply_map,
std::map<AnfNodePtr, size_t> *const_map_ptr);
void SetValueToProto(const ValuePtr &attr_value, debugger::ValueProto *value_proto);
void SetScalarToProto(const ScalarPtr &val, debugger::ValueProto *value_proto);
void SetSequenceToProto(const ValueSequeuePtr &val, debugger::ValueProto *value_proto);
void SetDictionaryToProto(const ValueDictionaryPtr &val, debugger::ValueProto *value_proto);
void SetNodeOutputType(const AnfNodePtr &node, debugger::TypeProto *type_proto);
void SetNodeOutputType(const TypePtr &node, const BaseShapePtr &shape, debugger::TypeProto *type_proto);
void ExportFuncGraph(const FuncGraphPtr &func_graph, debugger::GraphProto *graph_proto,
LocDebugDumpMode dump_location = kDebugOff);
void ExportParameters(const FuncGraphPtr &func_graph, debugger::GraphProto *graph_proto);
void ExportCNodes(const FuncGraphPtr &func_graph, debugger::GraphProto *graph_proto,
std::map<AnfNodePtr, size_t> *const_map_ptr, LocDebugDumpMode dump_location = kDebugOff);
void ExportCNode(const FuncGraphPtr &func_graph, const CNodePtr &node, std::map<AnfNodePtr, size_t> *apply_map_ptr,
std::map<AnfNodePtr, size_t> *const_map_ptr, debugger::GraphProto *graph_proto,
LocDebugDumpMode dump_location = kDebugOff);
void ExportFuncGraphOutput(const FuncGraphPtr &func_graph, const CNodePtr &ret_node,
const std::map<AnfNodePtr, size_t> &apply_map, std::map<AnfNodePtr, size_t> *const_map_ptr,
debugger::GraphProto *graph_proto);
void ExportValueNodes(const std::map<AnfNodePtr, size_t> &const_map, debugger::GraphProto *graph_proto);
static std::string GetConstNodeId(size_t idx) { return std::string("cst") + std::to_string(idx); }
debugger::ModelProto model_;
};
void DumpIRProtoWithSrcInfo(const FuncGraphPtr &func_graph, const std::string &suffix, const std::string &target_dir,
LocDebugDumpMode dump_location = kDebugOff);
} // namespace mindspore
#endif // MINDSPORE_CCSRC_DEBUG_DEBUGGER_MINDSPORE_PROTO_EXPORTER_H_

@ -0,0 +1,29 @@
/**
* Copyright 2021 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef MINDSPORE_PROTO_EXPORTER_STUB_H
#define MINDSPORE_PROTO_EXPORTER_STUB_H
#include <string>
#include "utils/symbolic.h"
namespace mindspore {
enum LocDebugDumpMode { kDebugOff = 0, kDebugTopStack = 1, kDebugWholeStack = 2 };
void DumpIRProtoWithSrcInfo(const FuncGraphPtr &func_graph, const std::string &suffix, const std::string &target_dir,
LocDebugDumpMode dump_location = kDebugOff) {
return;
}
} // namespace mindspore
#endif // MINDSPORE_CCSRC_DEBUG_DEBUGGER_MINDSPORE_PROTO_EXPORTER_STUB_H_

@ -22,6 +22,7 @@
#include <utility>
#include <vector>
#include "debug/common.h"
#include "proto/anf_ir.pb.h"
#include "ir/graph_utils.h"
#include "utils/ms_context.h"
@ -103,11 +104,26 @@ static irpb::DataType GetNumberDataType(const TypePtr &type) {
}
}
void CheckIfValidType(const TypePtr &type) {
if (type->isa<Problem>()) {
MS_LOG(WARNING) << "The type: " << type->type_name();
}
if (!(type->isa<Number>() || type->isa<TensorType>() || type->isa<Tuple>() || type->isa<TypeType>() ||
type->isa<List>() || type->isa<TypeAnything>() || type->isa<RefKeyType>() || type->isa<RefType>() ||
type->isa<Function>() || type->isa<TypeNone>() || type->isa<Problem>() || type->isa<String>() ||
type->isa<RowTensorType>() || type->isa<UndeterminedType>() || type->isa<SparseTensorType>() ||
type->isa<SymbolicKeyType>() || type->isa<MonadType>())) {
MS_LOG(EXCEPTION) << "Unknown type: " << type->type_name();
}
}
void ProtoExporter::SetNodeOutputType(const TypePtr &type, const BaseShapePtr &shape, irpb::TypeProto *type_proto) {
if (type_proto == nullptr) {
return;
}
if (type != nullptr) {
CheckIfValidType(type);
}
if (type == nullptr) {
type_proto->set_data_type(irpb::DT_UNDEFINED);
} else if (type->isa<Number>()) {
@ -122,12 +138,6 @@ void ProtoExporter::SetNodeOutputType(const TypePtr &type, const BaseShapePtr &s
type_proto->mutable_tensor_type()->mutable_shape()->add_dim()->set_size(elem);
}
}
} else if (type->isa<RowTensorType>()) {
// Do Nothing
} else if (type->isa<UndeterminedType>()) {
// Do Nothing
} else if (type->isa<SparseTensorType>()) {
// Do Nothing
} else if (type->isa<Tuple>()) {
TuplePtr tuple_type = dyn_cast<Tuple>(type);
type_proto->set_data_type(irpb::DT_TUPLE);
@ -154,14 +164,6 @@ void ProtoExporter::SetNodeOutputType(const TypePtr &type, const BaseShapePtr &s
type_proto->set_data_type(irpb::DT_NONE);
} else if (type->isa<String>()) {
type_proto->set_data_type(irpb::DT_STRING);
} else if (type->isa<SymbolicKeyType>()) {
// Do Nothing.
} else if (type->isa<MonadType>()) {
// Do Nothing.
} else if (type->isa<Problem>()) {
MS_LOG(WARNING) << "The type: " << type->type_name();
} else {
MS_LOG(EXCEPTION) << "Unknown type: " << type->type_name();
}
}

Loading…
Cancel
Save