forked from huawei/mindspore2022
871 lines
35 KiB
Python
871 lines
35 KiB
Python
# 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.
|
|
# ==============================================================================
|
|
"""
|
|
The module DbgServices provides offline debugger APIs.
|
|
"""
|
|
|
|
import mindspore._mindspore_offline_debug as cds
|
|
from mindspore.offline_debug.mi_validators import check_init, check_initialize, check_add_watchpoint, check_remove_watchpoint, check_check_watchpoints, check_read_tensors, check_initialize_done, check_tensor_info_init, check_tensor_data_init, check_watchpoint_hit_init, check_parameter_init
|
|
|
|
|
|
def get_version():
|
|
"""
|
|
Function to return offline Debug Services version.
|
|
|
|
Returns:
|
|
version (str): dbgServices version.
|
|
|
|
Examples:
|
|
>>> from mindspore.ccsrc.debug.debugger.offline_debug import dbg_services
|
|
>>> version = dbg_services.get_version()
|
|
"""
|
|
return cds.DbgServices(False).GetVersion()
|
|
|
|
class DbgLogger:
|
|
"""
|
|
Offline Debug Services Logger
|
|
|
|
Args:
|
|
verbose (bool): whether to print logs.
|
|
|
|
Examples:
|
|
>>> from mindspore.ccsrc.debug.debugger.offline_debug import dbg_services
|
|
>>> version = dbg_services.DbgLogger(verbose=False)
|
|
"""
|
|
def __init__(self, verbose):
|
|
self.verbose = verbose
|
|
|
|
def __call__(self, *logs):
|
|
if self.verbose:
|
|
print(logs)
|
|
|
|
|
|
log = DbgLogger(False)
|
|
|
|
|
|
class DbgServices():
|
|
"""
|
|
Offline Debug Services class.
|
|
|
|
Args:
|
|
dump_file_path (str): directory where the dump files are saved.
|
|
verbose (bool): whether to print logs (default: False)..
|
|
|
|
Examples:
|
|
>>> from mindspore.ccsrc.debug.debugger.offline_debug import dbg_services
|
|
>>> d = dbg_services.DbgServices(dump_file_path="dump_file_path",
|
|
>>> verbose=True)
|
|
"""
|
|
|
|
@check_init
|
|
def __init__(self, dump_file_path, verbose=False):
|
|
log.verbose = verbose
|
|
log("in Python __init__, file path is ", dump_file_path)
|
|
self.dump_file_path = dump_file_path
|
|
self.dbg_instance = cds.DbgServices(verbose)
|
|
self.version = self.dbg_instance.GetVersion()
|
|
self.verbose = verbose
|
|
self.initialized = False
|
|
|
|
@check_initialize
|
|
def initialize(self, net_name, is_sync_mode=True):
|
|
"""
|
|
Initialize Debug Service.
|
|
|
|
Args:
|
|
net_name (str): Network name.
|
|
is_sync_mode (bool): Whether to process synchronous or asynchronous dump files mode
|
|
(default: True (synchronous)).
|
|
|
|
Returns:
|
|
Initialized Debug Service instance.
|
|
|
|
Examples:
|
|
>>> from mindspore.ccsrc.debug.debugger.offline_debug import dbg_services
|
|
>>> d = dbg_services.DbgServices(dump_file_path="dump_file_path",
|
|
>>> verbose=True)
|
|
>>> d_init = d.initialize(net_name="network name", is_sync_mode=True)
|
|
"""
|
|
|
|
log("in Python Initialize dump_file_path ", self.dump_file_path)
|
|
self.initialized = True
|
|
return self.dbg_instance.Initialize(net_name, self.dump_file_path, is_sync_mode)
|
|
|
|
@check_initialize_done
|
|
@check_add_watchpoint
|
|
def add_watchpoint(self, watchpoint_id, watch_condition, check_node_list, parameter_list):
|
|
"""
|
|
Adding watchpoint to Debug Service instance.
|
|
|
|
Args:
|
|
watchpoint_id (int): Watchpoint id
|
|
watch_condition (int): A representation of the condition to be checked.
|
|
check_node_list (dict): Dictionary of node names (str or '*' to check all nodes) as key,
|
|
mapping to device_id (list of ints or '*' to check all devices),
|
|
root_graph_id (list of ints or '*' to check all graphs) and is_parameter (bool).
|
|
parameter_list (list): List of parameters in watchpoint. Parameters should be instances of Parameter class.
|
|
Each parameter describes the value to be checked in watchpoint.
|
|
|
|
Returns:
|
|
Debug Service instance with added watchpoint.
|
|
|
|
Examples:
|
|
>>> from mindspore.ccsrc.debug.debugger.offline_debug import dbg_services
|
|
>>> d = dbg_services.DbgServices(dump_file_path="dump_file_path",
|
|
>>> verbose=True)
|
|
>>> d_init = d.initialize(is_sync_mode=True)
|
|
>>> d_wp = d_init.add_watchpoint(watchpoint_id=1,
|
|
>>> watch_condition=6,
|
|
>>> check_node_list={"conv2.bias" : {"device_id": [0],
|
|
root_graph_id: [0], "is_parameter": True}},
|
|
>>> parameter_list=[dbg_services.Parameter(name="param",
|
|
>>> disabled=False,
|
|
>>> value=0.0,
|
|
>>> hit=False,
|
|
>>> actual_value=0.0)])
|
|
"""
|
|
|
|
log("in Python AddWatchpoint")
|
|
for node_name, node_info in check_node_list.items():
|
|
for info_name, info_param in node_info.items():
|
|
if info_name in ["device_id", "root_graph_id"]:
|
|
if info_param in ["*"]:
|
|
check_node_list[node_name][info_name] = ["*"]
|
|
else:
|
|
check_node_list[node_name][info_name] = list(map(str, info_param))
|
|
parameter_list_inst = []
|
|
for elem in parameter_list:
|
|
parameter_list_inst.append(elem.instance)
|
|
return self.dbg_instance.AddWatchpoint(watchpoint_id, watch_condition, check_node_list, parameter_list_inst)
|
|
|
|
@check_initialize_done
|
|
@check_remove_watchpoint
|
|
def remove_watchpoint(self, watchpoint_id):
|
|
"""
|
|
Removing watchpoint from Debug Service instance.
|
|
|
|
Args:
|
|
watchpoint_id (int): Watchpoint id
|
|
|
|
Returns:
|
|
Debug Service instance with removed watchpoint.
|
|
|
|
Examples:
|
|
>>> from mindspore.ccsrc.debug.debugger.offline_debug import dbg_services
|
|
>>> d = dbg_services.DbgServices(dump_file_path="dump_file_path",
|
|
>>> verbose=True)
|
|
>>> d_init = d.initialize(is_sync_mode=True)
|
|
>>> d_wp = d_init.add_watchpoint(watchpoint_id=1,
|
|
>>> watch_condition=6,
|
|
>>> check_node_list={"conv2.bias" : {"device_id": [5],
|
|
root_graph_id: [0], "is_parameter": True}},
|
|
>>> parameter_list=[dbg_services.Parameter(name="param",
|
|
>>> disabled=False,
|
|
>>> value=0.0,
|
|
>>> hit=False,
|
|
>>> actual_value=0.0)])
|
|
>>> d_wp = d_wp.remove_watchpoint(watchpoint_id=1)
|
|
"""
|
|
|
|
log("in Python Remove Watchpoint id ", watchpoint_id)
|
|
return self.dbg_instance.RemoveWatchpoint(watchpoint_id)
|
|
|
|
@check_initialize_done
|
|
@check_check_watchpoints
|
|
def check_watchpoints(self, iteration):
|
|
"""
|
|
Checking watchpoint at given iteration.
|
|
|
|
Args:
|
|
iteration (int): Watchpoint check iteration.
|
|
|
|
Returns:
|
|
Watchpoint hit list.
|
|
|
|
Examples:
|
|
>>> from mindspore.ccsrc.debug.debugger.offline_debug import dbg_services
|
|
>>> d = dbg_services.DbgServices(dump_file_path="dump_file_path",
|
|
>>> verbose=True)
|
|
>>> d_init = d.initialize(is_sync_mode=True)
|
|
>>> d_wp = d_init.add_watchpoint(id=1,
|
|
>>> watch_condition=6,
|
|
>>> check_node_list={"conv2.bias" : {"device_id": [5],
|
|
root_graph_id: [0], "is_parameter": True}},
|
|
>>> parameter_list=[dbg_services.Parameter(name="param",
|
|
>>> disabled=False,
|
|
>>> value=0.0,
|
|
>>> hit=False,
|
|
>>> actual_value=0.0)])
|
|
>>> watchpoints = d_wp.check_watchpoints(iteration=8)
|
|
"""
|
|
|
|
log("in Python CheckWatchpoints iteration ", iteration)
|
|
watchpoint_list = self.dbg_instance.CheckWatchpoints(iteration)
|
|
watchpoint_hit_list = []
|
|
for watchpoint in watchpoint_list:
|
|
name = watchpoint.get_name()
|
|
slot = watchpoint.get_slot()
|
|
condition = watchpoint.get_condition()
|
|
watchpoint_id = watchpoint.get_watchpoint_id()
|
|
parameters = watchpoint.get_parameters()
|
|
error_code = watchpoint.get_error_code()
|
|
device_id = watchpoint.get_device_id()
|
|
root_graph_id = watchpoint.get_root_graph_id()
|
|
param_list = []
|
|
for param in parameters:
|
|
p_name = param.get_name()
|
|
disabled = param.get_disabled()
|
|
value = param.get_value()
|
|
hit = param.get_hit()
|
|
actual_value = param.get_actual_value()
|
|
param_list.append(Parameter(p_name, disabled, value, hit, actual_value))
|
|
watchpoint_hit_list.append(WatchpointHit(name, slot, condition, watchpoint_id,
|
|
param_list, error_code, device_id, root_graph_id))
|
|
return watchpoint_hit_list
|
|
|
|
@check_initialize_done
|
|
@check_read_tensors
|
|
def read_tensors(self, info):
|
|
"""
|
|
Returning tensor data object describing the tensor requested tensor.
|
|
|
|
Args:
|
|
info (list): List of TensorInfo objects.
|
|
|
|
Returns:
|
|
TensorData list (list).
|
|
|
|
Examples:
|
|
>>> from mindspore.ccsrc.debug.debugger.offline_debug import dbg_services
|
|
>>> d = dbg_services.DbgServices(dump_file_path="dump_file_path",
|
|
>>> verbose=True)
|
|
>>> d_init = d.initialize(is_sync_mode=True)
|
|
>>> tensor_data_list = d_init.read_tensors([dbg_services.TensorInfo(node_name="conv2.bias",
|
|
>>> slot=0,
|
|
>>> iteration=8,
|
|
>>> device_id=5,
|
|
>>> root_graph_id=0,
|
|
>>> is_parameter=True)])
|
|
"""
|
|
|
|
log("in Python ReadTensors info ", info)
|
|
info_list_inst = []
|
|
for elem in info:
|
|
log("in Python ReadTensors info ", info)
|
|
info_list_inst.append(elem.instance)
|
|
tensor_data_list = self.dbg_instance.ReadTensors(info_list_inst)
|
|
tensor_data_list_ret = []
|
|
for elem in tensor_data_list:
|
|
if elem.get_data_size() == 0:
|
|
tensor_data = TensorData(b'', elem.get_data_size(), elem.get_dtype(), elem.get_shape())
|
|
else:
|
|
tensor_data = TensorData(elem.get_data_ptr(), elem.get_data_size(), elem.get_dtype(), elem.get_shape())
|
|
tensor_data_list_ret.append(tensor_data)
|
|
return tensor_data_list_ret
|
|
|
|
class TensorInfo():
|
|
"""
|
|
Tensor Information class.
|
|
|
|
Args:
|
|
node_name (str): Fully qualified name of the desired node.
|
|
slot (int): The particular output for the requested node.
|
|
iteration (int): The desired itraretion to gather tensor information.
|
|
device_id (int): The desired device id to gather tensor information.
|
|
is_parameter (bool): Whether node is a parameter (input, constant, bias, parameter).
|
|
|
|
Examples:
|
|
>>> from mindspore.ccsrc.debug.debugger.offline_debug import dbg_services
|
|
>>> tensor_info = dbg_services.TensorInfo(node_name="conv2.bias",
|
|
>>> slot=0,
|
|
>>> iteration=8,
|
|
>>> device_id=5,
|
|
>>> root_graph_id=0,
|
|
>>> is_parameter=True)
|
|
"""
|
|
|
|
@check_tensor_info_init
|
|
def __init__(self, node_name, slot, iteration, device_id, root_graph_id, is_parameter):
|
|
self.instance = cds.tensor_info(node_name, slot, iteration, device_id, root_graph_id, is_parameter)
|
|
|
|
@property
|
|
def node_name(self):
|
|
"""
|
|
Function to receive TensorInfo node_name.
|
|
|
|
Returns:
|
|
node_name of TensorInfo instance (str).
|
|
|
|
Examples:
|
|
>>> from mindspore.ccsrc.debug.debugger.offline_debug import dbg_services
|
|
>>> tensor_info = dbg_services.TensorInfo(node_name="conv2.bias",
|
|
>>> slot=0,
|
|
>>> iteration=8,
|
|
>>> device_id=5,
|
|
>>> root_graph_id=0,
|
|
>>> is_parameter=True)
|
|
>>> name = tensor_info.node_name
|
|
"""
|
|
|
|
return self.instance.get_node_name()
|
|
|
|
@property
|
|
def slot(self):
|
|
"""
|
|
Function to receive TensorInfo slot.
|
|
|
|
Returns:
|
|
slot of TensorInfo instance (int).
|
|
|
|
Examples:
|
|
>>> from mindspore.ccsrc.debug.debugger.offline_debug import dbg_services
|
|
>>> tensor_info = dbg_services.TensorInfo(node_name="conv2.bias",
|
|
>>> slot=0,
|
|
>>> iteration=8,
|
|
>>> device_id=5,
|
|
>>> root_graph_id=0,
|
|
>>> is_parameter=True)
|
|
>>> slot = tensor_info.slot
|
|
"""
|
|
|
|
return self.instance.get_slot()
|
|
|
|
@property
|
|
def iteration(self):
|
|
"""
|
|
Function to receive TensorInfo iteration.
|
|
|
|
Returns:
|
|
iteration of TensorInfo instance (int).
|
|
|
|
Examples:
|
|
>>> from mindspore.ccsrc.debug.debugger.offline_debug import dbg_services
|
|
>>> tensor_info = dbg_services.TensorInfo(node_name="conv2.bias",
|
|
>>> slot=0,
|
|
>>> iteration=8,
|
|
>>> device_id=5,
|
|
>>> root_graph_id=0,
|
|
>>> is_parameter=True)
|
|
>>> iteration = tensor_info.iteration
|
|
"""
|
|
|
|
return self.instance.get_iteration()
|
|
|
|
@property
|
|
def device_id(self):
|
|
"""
|
|
Function to receive TensorInfo device_id.
|
|
|
|
Returns:
|
|
device_id of TensorInfo instance (int).
|
|
|
|
Examples:
|
|
>>> from mindspore.ccsrc.debug.debugger.offline_debug import dbg_services
|
|
>>> tensor_info = dbg_services.TensorInfo(node_name="conv2.bias",
|
|
>>> slot=0,
|
|
>>> iteration=8,
|
|
>>> device_id=5,
|
|
>>> root_graph_id=0,
|
|
>>> is_parameter=True)
|
|
>>> device_id = tensor_info.device_id
|
|
"""
|
|
|
|
@property
|
|
def root_graph_id(self):
|
|
"""
|
|
Function to receive TensorInfo root_graph_id.
|
|
|
|
Returns:
|
|
root_graph_id of TensorInfo instance (int).
|
|
|
|
Examples:
|
|
>>> from mindspore.ccsrc.debug.debugger.offline_debug import dbg_services
|
|
>>> tensor_info = dbg_services.TensorInfo(node_name="conv2.bias",
|
|
>>> slot=0,
|
|
>>> iteration=8,
|
|
>>> device_id=5,
|
|
>>> root_graph_id=0,
|
|
>>> is_parameter=True)
|
|
>>> device_id = tensor_info.root_graph_id
|
|
"""
|
|
|
|
return self.instance.get_root_graph_id()
|
|
|
|
@property
|
|
def is_parameter(self):
|
|
"""
|
|
Function to receive TensorInfo is_parameter.
|
|
|
|
Returns:
|
|
is_parameter of TensorInfo instance (bool).
|
|
|
|
Examples:
|
|
>>> from mindspore.ccsrc.debug.debugger.offline_debug import dbg_services
|
|
>>> tensor_info = dbg_services.TensorInfo(node_name="conv2.bias",
|
|
>>> slot=0,
|
|
>>> iteration=8,
|
|
>>> device_id=5,
|
|
>>> root_graph_id=0,
|
|
>>> is_parameter=True)
|
|
>>> is_parameter = tensor_info.is_parameter
|
|
"""
|
|
|
|
return self.instance.get_is_parameter()
|
|
|
|
class TensorData():
|
|
"""
|
|
TensorData class.
|
|
|
|
Args:
|
|
data_ptr (byte): Data pointer.
|
|
data_size (int): Size of data in bytes.
|
|
dtype (int): An encoding representing the type of TensorData.
|
|
shape (list): Shape of tensor.
|
|
|
|
Examples:
|
|
>>> from mindspore.ccsrc.debug.debugger.offline_debug import dbg_services
|
|
>>> tensor_data = dbg_services.TensorData(data_ptr=b'\xba\xd0\xba\xd0',
|
|
>>> data_size=4,
|
|
>>> dtype=0,
|
|
>>> shape=[2, 2])
|
|
"""
|
|
|
|
@check_tensor_data_init
|
|
def __init__(self, data_ptr, data_size, dtype, shape):
|
|
self.instance = cds.tensor_data(data_ptr, data_size, dtype, shape)
|
|
|
|
@property
|
|
def data_ptr(self):
|
|
"""
|
|
Function to receive TensorData data_ptr.
|
|
|
|
Returns:
|
|
data_ptr of TensorData instance (byte).
|
|
|
|
Examples:
|
|
>>> from mindspore.ccsrc.debug.debugger.offline_debug import dbg_services
|
|
>>> tensor_data = dbg_services.TensorData(data_ptr=b'\xba\xd0\xba\xd0',
|
|
>>> data_size=4,
|
|
>>> dtype=0,
|
|
>>> shape=[2, 2])
|
|
>>> data_ptr = tensor_data.data_ptr
|
|
"""
|
|
|
|
return self.instance.get_data_ptr()
|
|
|
|
@property
|
|
def data_size(self):
|
|
"""
|
|
Function to receive TensorData data_size.
|
|
|
|
Returns:
|
|
data_size of TensorData instance (int).
|
|
|
|
Examples:
|
|
>>> from mindspore.ccsrc.debug.debugger.offline_debug import dbg_services
|
|
>>> tensor_data = dbg_services.TensorData(data_ptr=b'\xba\xd0\xba\xd0',
|
|
>>> data_size=4,
|
|
>>> dtype=0,
|
|
>>> shape=[2, 2])
|
|
>>> data_size = tensor_data.data_size
|
|
"""
|
|
|
|
return self.instance.get_data_size()
|
|
|
|
@property
|
|
def dtype(self):
|
|
"""
|
|
Function to receive TensorData dtype.
|
|
|
|
Returns:
|
|
dtype of TensorData instance (int).
|
|
|
|
Examples:
|
|
>>> from mindspore.ccsrc.debug.debugger.offline_debug import dbg_services
|
|
>>> tensor_data = dbg_services.TensorData(data_ptr=b'\xba\xd0\xba\xd0',
|
|
>>> data_size=4,
|
|
>>> dtype=0,
|
|
>>> shape=[2, 2])
|
|
>>> dtype = tensor_data.dtype
|
|
"""
|
|
|
|
return self.instance.get_dtype()
|
|
|
|
@property
|
|
def shape(self):
|
|
"""
|
|
Function to receive TensorData shape.
|
|
|
|
Returns:
|
|
shape of TensorData instance (list).
|
|
|
|
Examples:
|
|
>>> from mindspore.ccsrc.debug.debugger.offline_debug import dbg_services
|
|
>>> tensor_data = dbg_services.TensorData(data_ptr=b'\xba\xd0\xba\xd0',
|
|
>>> data_size=4,
|
|
>>> dtype=0,
|
|
>>> shape=[2, 2])
|
|
>>> shape = tensor_data.shape
|
|
"""
|
|
|
|
return self.instance.get_shape()
|
|
|
|
class WatchpointHit():
|
|
"""
|
|
WatchpointHit class.
|
|
|
|
Args:
|
|
name (str): Name of WatchpointHit instance.
|
|
slot (int): The numerical label of an output.
|
|
condition (int): A representation of the condition to be checked.
|
|
watchpoint_id (int): Watchpoint id.
|
|
parameters (list): A list of all parameters for WatchpointHit instance.
|
|
Parameters have to be instances of Parameter class.
|
|
error_code (int): An explanation of certain scenarios where watchpoint could not be checked.
|
|
device_id (int): Device id where the watchpoint is hit.
|
|
root_graph_id (int): Root graph id where the watchpoint is hit.
|
|
|
|
Examples:
|
|
>>> from mindspore.ccsrc.debug.debugger.offline_debug import dbg_services
|
|
>>> watchpoint_hit = dbg_services.WatchpointHit(name="hit1",
|
|
>>> slot=1,
|
|
>>> condition=2,
|
|
>>> watchpoint_id=3,
|
|
>>> parameters=[param1, param2],
|
|
>>> error_code=0,
|
|
>>> device_id=1,
|
|
>>> root_graph_id=1)
|
|
"""
|
|
|
|
@check_watchpoint_hit_init
|
|
def __init__(self, name, slot, condition, watchpoint_id, parameters, error_code, device_id, root_graph_id):
|
|
parameter_list_inst = []
|
|
for elem in parameters:
|
|
parameter_list_inst.append(elem.instance)
|
|
self.instance = cds.watchpoint_hit(name, slot, condition, watchpoint_id,
|
|
parameter_list_inst, error_code, device_id, root_graph_id)
|
|
|
|
@property
|
|
def name(self):
|
|
"""
|
|
Function to receive WatchpointHit name.
|
|
|
|
Returns:
|
|
name of WatchpointHit instance (str).
|
|
|
|
Examples:
|
|
>>> from mindspore.ccsrc.debug.debugger.offline_debug import dbg_services
|
|
>>> watchpoint_hit = dbg_services.WatchpointHit(name="hit1",
|
|
>>> slot=1,
|
|
>>> condition=2,
|
|
>>> watchpoint_id=3,
|
|
>>> parameters=[param1, param2],
|
|
>>> error_code=0,
|
|
>>> device_id=1,
|
|
>>> root_graph_id=1)
|
|
>>> name = watchpoint_hit.name
|
|
"""
|
|
|
|
return self.instance.get_name()
|
|
|
|
@property
|
|
def slot(self):
|
|
"""
|
|
Function to receive WatchpointHit slot.
|
|
|
|
Returns:
|
|
slot of WatchpointHit instance (int).
|
|
|
|
Examples:
|
|
>>> from mindspore.ccsrc.debug.debugger.offline_debug import dbg_services
|
|
>>> watchpoint_hit = dbg_services.WatchpointHit(name="hit1",
|
|
>>> slot=1,
|
|
>>> condition=2,
|
|
>>> watchpoint_id=3,
|
|
>>> parameters=[param1, param2],
|
|
>>> error_code=0,
|
|
>>> device_id=1,
|
|
>>> root_graph_id=1)
|
|
>>> slot = watchpoint_hit.slot
|
|
"""
|
|
|
|
return self.instance.get_slot()
|
|
|
|
@property
|
|
def condition(self):
|
|
"""
|
|
Function to receive WatchpointHit condition.
|
|
|
|
Returns:
|
|
condition of WatchpointHit instance (int).
|
|
|
|
Examples:
|
|
>>> from mindspore.ccsrc.debug.debugger.offline_debug import dbg_services
|
|
>>> watchpoint_hit = dbg_services.WatchpointHit(name="hit1",
|
|
>>> slot=1,
|
|
>>> condition=2,
|
|
>>> watchpoint_id=3,
|
|
>>> parameters=[param1, param2],
|
|
>>> error_code=0,
|
|
>>> device_id=1,
|
|
>>> root_graph_id=1)
|
|
>>> condition = watchpoint_hit.condition
|
|
"""
|
|
|
|
return self.instance.get_condition()
|
|
|
|
@property
|
|
def watchpoint_id(self):
|
|
"""
|
|
Function to receive WatchpointHit watchpoint_id.
|
|
|
|
Returns:
|
|
watchpoint_id of WatchpointHit instance (int).
|
|
|
|
Examples:
|
|
>>> from mindspore.ccsrc.debug.debugger.offline_debug import dbg_services
|
|
>>> watchpoint_hit = dbg_services.WatchpointHit(name="hit1",
|
|
>>> slot=1,
|
|
>>> condition=2,
|
|
>>> watchpoint_id=3,
|
|
>>> parameters=[param1, param2],
|
|
>>> error_code=0,
|
|
>>> device_id=1,
|
|
>>> root_graph_id=1)
|
|
>>> watchpoint_id = watchpoint_hit.watchpoint_id
|
|
"""
|
|
|
|
return self.instance.get_watchpoint_id()
|
|
|
|
@property
|
|
def parameters(self):
|
|
"""
|
|
Function to receive WatchpointHit parameters.
|
|
|
|
Returns:
|
|
List of parameters of WatchpointHit instance (list).
|
|
|
|
Examples:
|
|
>>> from mindspore.ccsrc.debug.debugger.offline_debug import dbg_services
|
|
>>> watchpoint_hit = dbg_services.WatchpointHit(name="hit1",
|
|
>>> slot=1,
|
|
>>> condition=2,
|
|
>>> watchpoint_id=3,
|
|
>>> parameters=[param1, param2],
|
|
>>> error_code=0,
|
|
>>> device_id=1,
|
|
>>> root_graph_id=1)
|
|
>>> parameters = watchpoint_hit.parameters
|
|
"""
|
|
|
|
params = self.instance.get_parameters()
|
|
param_list = []
|
|
for elem in params:
|
|
tmp = Parameter(elem.get_name(),
|
|
elem.get_disabled(),
|
|
elem.get_value(),
|
|
elem.get_hit(),
|
|
elem.get_actual_value())
|
|
param_list.append(tmp)
|
|
return param_list
|
|
|
|
@property
|
|
def error_code(self):
|
|
"""
|
|
Function to receive WatchpointHit error_code.
|
|
|
|
Returns:
|
|
error_code of WatchpointHit instance (int).
|
|
|
|
Examples:
|
|
>>> from mindspore.ccsrc.debug.debugger.offline_debug import dbg_services
|
|
>>> watchpoint_hit = dbg_services.WatchpointHit(name="hit1",
|
|
>>> slot=1,
|
|
>>> condition=2,
|
|
>>> watchpoint_id=3,
|
|
>>> parameters=[param1, param2],
|
|
>>> error_code=0,
|
|
>>> device_id=1,
|
|
>>> root_graph_id=1)
|
|
>>> error_code = watchpoint_hit.error_code
|
|
"""
|
|
|
|
return self.instance.get_error_code()
|
|
|
|
@property
|
|
def device_id(self):
|
|
"""
|
|
Function to receive WatchpointHit device_id.
|
|
|
|
Returns:
|
|
device_id of WatchpointHit instance (int).
|
|
|
|
Examples:
|
|
>>> from mindspore.ccsrc.debug.debugger.offline_debug import dbg_services
|
|
>>> watchpoint_hit = dbg_services.WatchpointHit(name="hit1",
|
|
>>> slot=1,
|
|
>>> condition=2,
|
|
>>> watchpoint_id=3,
|
|
>>> parameters=[param1, param2],
|
|
>>> error_code=0,
|
|
>>> device_id=1,
|
|
>>> root_graph_id=1)
|
|
>>> device_id = watchpoint_hit.device_id
|
|
"""
|
|
|
|
return self.instance.get_device_id()
|
|
|
|
@property
|
|
def root_graph_id(self):
|
|
"""
|
|
Function to receive WatchpointHit root_graph_id.
|
|
|
|
Returns:
|
|
root_graph_id of WatchpointHit instance (int).
|
|
|
|
Examples:
|
|
>>> from mindspore.ccsrc.debug.debugger.offline_debug import dbg_services
|
|
>>> watchpoint_hit = dbg_services.WatchpointHit(name="hit1",
|
|
>>> slot=1,
|
|
>>> condition=2,
|
|
>>> watchpoint_id=3,
|
|
>>> parameters=[param1, param2],
|
|
>>> error_code=0,
|
|
>>> device_id=1,
|
|
>>> root_graph_id=1)
|
|
>>> root_graph_id = watchpoint_hit.root_graph_id
|
|
"""
|
|
|
|
return self.instance.get_root_graph_id()
|
|
|
|
class Parameter():
|
|
"""
|
|
Parameter class.
|
|
|
|
Args:
|
|
name (str): Name of the parameter.
|
|
disabled (bool): Whether parameter is used in backend.
|
|
value (float): Threshold value of the parameter.
|
|
hit (bool): Whether this parameter triggered watchpoint (default is False).
|
|
actual_value (float): Actual value of the parameter (default is 0.0).
|
|
|
|
Examples:
|
|
>>> from mindspore.ccsrc.debug.debugger.offline_debug import dbg_services
|
|
>>> parameter = dbg_services.Parameter(name="param",
|
|
>>> disabled=False,
|
|
>>> value=0.0,
|
|
>>> hit=False,
|
|
>>> actual_value=0.0)
|
|
"""
|
|
|
|
@check_parameter_init
|
|
def __init__(self, name, disabled, value, hit=False, actual_value=0.0):
|
|
self.instance = cds.parameter(name, disabled, value, hit, actual_value)
|
|
|
|
@property
|
|
def name(self):
|
|
"""
|
|
Function to receive Parameter name.
|
|
|
|
Returns:
|
|
name of Parameter instance (str).
|
|
|
|
Examples:
|
|
>>> from mindspore.ccsrc.debug.debugger.offline_debug import dbg_services
|
|
>>> parameter = dbg_services.Parameter(name="param",
|
|
>>> disabled=False,
|
|
>>> value=0.0,
|
|
>>> hit=False,
|
|
>>> name = watchpoint_hit.name
|
|
"""
|
|
|
|
return self.instance.get_name()
|
|
|
|
@property
|
|
def disabled(self):
|
|
"""
|
|
Function to receive Parameter disabled value.
|
|
|
|
Returns:
|
|
disabled of Parameter instance (bool).
|
|
|
|
Examples:
|
|
>>> from mindspore.ccsrc.debug.debugger.offline_debug import dbg_services
|
|
>>> parameter = dbg_services.Parameter(name="param",
|
|
>>> disabled=False,
|
|
>>> value=0.0,
|
|
>>> hit=False,
|
|
>>> disabled = watchpoint_hit.disabled
|
|
"""
|
|
|
|
return self.instance.get_disabled()
|
|
|
|
@property
|
|
def value(self):
|
|
"""
|
|
Function to receive Parameter value.
|
|
|
|
Returns:
|
|
value of Parameter instance (float).
|
|
|
|
Examples:
|
|
>>> from mindspore.ccsrc.debug.debugger.offline_debug import dbg_services
|
|
>>> parameter = dbg_services.Parameter(name="param",
|
|
>>> disabled=False,
|
|
>>> value=0.0,
|
|
>>> hit=False,
|
|
>>> value = watchpoint_hit.value
|
|
"""
|
|
|
|
return self.instance.get_value()
|
|
|
|
@property
|
|
def hit(self):
|
|
"""
|
|
Function to receive Parameter hit value.
|
|
|
|
Returns:
|
|
hit of Parameter instance (bool).
|
|
|
|
Examples:
|
|
>>> from mindspore.ccsrc.debug.debugger.offline_debug import dbg_services
|
|
>>> parameter = dbg_services.Parameter(name="param",
|
|
>>> disabled=False,
|
|
>>> value=0.0,
|
|
>>> hit=False,
|
|
>>> hit = watchpoint_hit.hit
|
|
"""
|
|
|
|
return self.instance.get_hit()
|
|
|
|
@property
|
|
def actual_value(self):
|
|
"""
|
|
Function to receive Parameter actual_value value.
|
|
|
|
Returns:
|
|
actual_value of Parameter instance (float).
|
|
|
|
Examples:
|
|
>>> from mindspore.ccsrc.debug.debugger.offline_debug import dbg_services
|
|
>>> parameter = dbg_services.Parameter(name="param",
|
|
>>> disabled=False,
|
|
>>> value=0.0,
|
|
>>> hit=False,
|
|
>>> actual_value = watchpoint_hit.actual_value
|
|
"""
|
|
|
|
return self.instance.get_actual_value()
|