mindstudio-probe 1.0.3__py3-none-any.whl → 1.1.0__py3-none-any.whl

msprobe/mindspore/dump/hook_cell/wrap_api.py

@@ -0,0 +1,121 @@
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# 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.
+
+import os
+
+from mindspore import Tensor, mint, ops
+from mindspore.common._stub_tensor import StubTensor
+from mindspore.communication import comm_func
+from mindspore.mint.nn import functional
+
+from msprobe.core.common.const import Const
+from msprobe.core.common.file_utils import load_yaml
+from msprobe.mindspore.common.const import Const as MsConst
+from msprobe.mindspore.dump.hook_cell.hook_cell import HOOKCell
+
+cur_path = os.path.dirname(os.path.realpath(__file__))
+yaml_path = os.path.join(cur_path, MsConst.SUPPORTED_API_LIST_FILE)
+
+
+class HOOKTensor(object):
+    pass
+
+
+class HOOKStubTensor(object):
+    pass
+
+
+class HOOKFunctionalOP(object):
+    pass
+
+
+class HOOKMintOP(object):
+    pass
+
+
+class HOOKMintNNFunctionalOP(object):
+    pass
+
+
+class HOOKDistributedOP(object):
+    pass
+
+
+class ApiTemplate(HOOKCell):
+    def __init__(self, api_name, api_dict, prefix, hook):
+        self.api_name = api_name
+        self.api_func = api_dict[api_name]
+        self.prefix_api_name = prefix + str(api_name.split(Const.SEP)[-1]) + Const.SEP
+        super().__init__(hook)
+
+    def construct(self, *args, **kwargs):
+        if self.api_name.startswith(MsConst.DROPOUT_API_NAME_PREFIX):
+            return args[0] if args else kwargs.get(Const.INPUT)
+        return self.api_func(*args, **kwargs)
+
+
+class WrapApiName:
+    def __init__(self, tensor_api_names, stub_tensor_api_names, ops_api_names, mint_api_names, mint_nn_func_api_names,
+                 distributed_api_names):
+        self.tensor_api_names = tensor_api_names
+        self.stub_tensor_api_names = stub_tensor_api_names
+        self.ops_api_names = ops_api_names
+        self.mint_api_names = mint_api_names
+        self.mint_nn_func_api_names = mint_nn_func_api_names
+        self.distributed_api_names = distributed_api_names
+
+
+def get_wrap_api_list():
+    api_list = load_yaml(yaml_path)
+    tensor_api = api_list.get(MsConst.SUPPORTED_TENSOR_LIST_KEY)
+    ops_api = api_list.get(MsConst.SUPPORTED_OPS_LIST_KEY)
+    mint_api = api_list.get(MsConst.SUPPORTED_MINT_LIST_KEY)
+    mint_nn_func_api = api_list.get(MsConst.SUPPORTED__MINT_NN_FUNC_LIST_KEY)
+    distributed_api = api_list.get(MsConst.SUPPORTED_COMM_LIST_KEY)
+    wrap_api_name = WrapApiName(set(tensor_api) & set(dir(Tensor)),
+                                set(tensor_api) & set(dir(StubTensor)),
+                                set(ops_api) & set(dir(ops)),
+                                set(mint_api) & set(dir(mint)),
+                                set(mint_nn_func_api) & set(dir(functional)),
+                                set(distributed_api) & set(dir(comm_func)))
+    return wrap_api_name
+
+
+def wrap_api_func(api_name, api_dict, prefix, hook):
+    def api_function(*args, **kwargs):
+        return ApiTemplate(api_name, api_dict, prefix, hook)(*args, **kwargs)
+    return api_function
+
+
+def wrap_api_func_and_bind(api_list, api_dict, prefix, hook, hook_class):
+    for api_name in api_list:
+        if callable(api_dict[api_name]):
+            setattr(hook_class, Const.ATTR_NAME_PREFIX + api_name, wrap_api_func(api_name, api_dict, prefix, hook))
+
+
+def setup_hooks(hook):
+    wrap_api_name = get_wrap_api_list()
+    wrap_api_func_and_bind(wrap_api_name.tensor_api_names, {f: getattr(Tensor, f) for f in dir(Tensor)},
+                           MsConst.TENSOR_DATA_PREFIX, hook, HOOKTensor)
+    wrap_api_func_and_bind(wrap_api_name.stub_tensor_api_names, {f: getattr(StubTensor, f) for f in dir(StubTensor)},
+                           MsConst.STUB_TENSOR_DATA_PREFIX, hook, HOOKStubTensor)
+    wrap_api_func_and_bind(wrap_api_name.ops_api_names, {f: getattr(ops, f) for f in dir(ops)},
+                           MsConst.OPS_DATA_PREFIX, hook, HOOKFunctionalOP)
+    wrap_api_func_and_bind(wrap_api_name.mint_api_names, {f: getattr(mint, f) for f in dir(mint)},
+                           MsConst.MINT_DATA_PREFIX, hook, HOOKMintOP)
+    wrap_api_func_and_bind(wrap_api_name.mint_nn_func_api_names, {f: getattr(functional, f) for f in dir(functional)},
+                           MsConst.MINT_NN_FUNC_DATA_PREFIX, hook, HOOKMintNNFunctionalOP)
+    wrap_api_func_and_bind(wrap_api_name.distributed_api_names, {f: getattr(comm_func, f) for f in dir(comm_func)},
+                           MsConst.DISTRIBUTED_DATA_PREFIX, hook, HOOKDistributedOP)

msprobe/mindspore/dump/jit_dump.py

@@ -1,56 +1,96 @@
-import os
-from mindspore.common.api import _MindsporeFunctionExecutor
-from mindspore._c_expression import PyNativeExecutor_
-from msprobe.mindspore.dump.hook_cell.api_registry import api_register
-from msprobe.core.data_dump.data_processor.base import ModuleForwardInputsOutputs
-
-
-def dump_jit(name, in_feat, out_feat, is_forward):
-    pid = os.getpid()
-    ori_args = str(name)
-    index = ori_args.find("<")
-    if index != 0 and index != -1:
-        result = ori_args[0:index]
-    else:
-        result = "JitFunction"
-    if is_forward:
-        name_template = "Jit." + result + ".forward"
-    else:
-        name_template = "Jit." + result + ".backward"
-    JitDump.data_collector.visit_and_clear_overflow_status(name_template)
-    if JitDump.data_collector:
-        module_input_output = ModuleForwardInputsOutputs(args=in_feat, kwargs={}, output=out_feat)
-        JitDump.data_collector.forward_data_collect(name_template, {}, pid, module_input_output)
-
-
-class JitDump(_MindsporeFunctionExecutor):
-    dump_config = None
-    jit_enable = False
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self._executor = PyNativeExecutor_.get_instance()
-
-    def __call__(self, *args, **kwargs):
-        api_register.api_set_ori_func()
-        out = super().__call__(*args, **kwargs)
-        dump_jit(args[0], args[1], out, True)
-        JitDump.jit_enable = True
-        api_register.api_set_hook_func()
-        return out
-
-    @classmethod
-    def set_config(cls, value):
-        cls.dump_config = value
-
-    @classmethod
-    def set_data_collector(cls, value):
-        cls.data_collector = value
-
-    def grad(self, obj, grad, weights, grad_position, *args,  **kwargs):
-        if JitDump.jit_enable:
-            api_register.api_set_ori_func()
-        output = self._executor.grad(grad, obj, weights, grad_position, *args, *(kwargs.values()))
-        if JitDump.jit_enable:
-            dump_jit(obj, args, output, False)
-            api_register.api_set_hook_func()
-        return output
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# 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.
+
+import os
+from collections import defaultdict
+
+from mindspore import Tensor
+from mindspore._c_expression import PyNativeExecutor_
+from mindspore.common.api import _MindsporeFunctionExecutor
+
+from msprobe.mindspore.dump.hook_cell.api_registry import api_register
+from msprobe.core.data_dump.data_processor.base import ModuleForwardInputsOutputs, ModuleBackwardInputsOutputs
+from msprobe.core.common.const import Const
+from msprobe.core.data_dump.data_processor.base import ModuleForwardInputsOutputs
+from msprobe.mindspore.dump.hook_cell.api_registry import api_register
+
+
+def dump_jit(name, in_feat, out_feat, is_forward):
+    pid = os.getpid()
+    ori_args = str(name)
+    index = ori_args.find("<")
+    if index != 0 and index != -1:
+        result = ori_args[0:index]
+    else:
+        result = "JitFunction"
+    if JitDump.need_dump():
+        if is_forward:
+            JitDump.jit_count[result] += 1
+            name_template = Const.JIT + Const.SEP + result + Const.SEP + str(JitDump.jit_count[result]) + Const.SEP + \
+                            Const.FORWARD
+            JitDump.data_collector.update_api_or_module_name(name_template)
+            module_input_output = ModuleForwardInputsOutputs(args=in_feat, kwargs={}, output=out_feat)
+            JitDump.data_collector.forward_data_collect(name_template, None, pid, module_input_output)
+        else:
+            name_template = Const.JIT + Const.SEP + result + Const.SEP + str(JitDump.jit_count[result]) + Const.SEP + \
+                            Const.BACKWARD
+            JitDump.data_collector.update_api_or_module_name(name_template)
+            module_input_output = ModuleBackwardInputsOutputs(grad_input=in_feat ,grad_output=out_feat)
+            JitDump.data_collector.backward_data_collect(name_template, None, pid, module_input_output)
+
+
+class JitDump(_MindsporeFunctionExecutor):
+    dump_config = None
+    jit_enable = False
+    jit_dump_switch = True
+    jit_count = defaultdict(int)
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._executor = PyNativeExecutor_.get_instance()
+
+    def __call__(self, *args, **kwargs):
+        api_register.api_set_ori_func()
+        out = super().__call__(*args, **kwargs)
+        if JitDump.jit_dump_switch and len(args) > 0:
+            dump_jit(args[0], args, out, True)
+            JitDump.jit_enable = True
+        api_register.api_set_hook_func()
+        return out
+
+    @classmethod
+    def set_config(cls, value):
+        cls.dump_config = value
+
+    @classmethod
+    def set_data_collector(cls, value):
+        cls.data_collector = value
+
+    @classmethod
+    def need_dump(cls):
+        if cls.dump_config.task != Const.TENSOR and cls.dump_config.task != Const.STATISTICS:
+            return False
+        if not cls.data_collector or cls.data_collector.data_processor.is_terminated:
+            return False
+        return True
+
+    def grad(self, obj, grad, weights, grad_position, *args, **kwargs):
+        if JitDump.jit_dump_switch and JitDump.jit_enable:
+            api_register.api_set_ori_func()
+        output = self._executor.grad(grad, obj, weights, grad_position, *args, *(kwargs.values()))
+        if JitDump.jit_dump_switch and JitDump.jit_enable:
+            dump_jit(obj, args, None, False)
+            api_register.api_set_hook_func()
+        return output

msprobe/mindspore/dump/kernel_graph_dump.py

@@ -1,60 +1,75 @@
-import os
-import json
-from msprobe.core.common.utils import make_dump_path_if_not_exists
-from msprobe.mindspore.debugger.debugger_config import DebuggerConfig
-from msprobe.core.common.log import logger
-from msprobe.core.common.file_check import FileOpen
-
-
-class KernelGraphDump:
-    def __init__(self, config: DebuggerConfig):
-        self.dump_json = dict()
-        self.dump_json["common_dump_settings"] = dict()
-        self.dump_json["common_dump_settings"]["dump_mode"] = 0
-        self.dump_json["common_dump_settings"]["path"] = ""
-        self.dump_json["common_dump_settings"]["net_name"] = "Net"
-        self.dump_json["common_dump_settings"]["iteration"] = "all"
-        self.dump_json["common_dump_settings"]["saved_data"] = "statistic"
-        self.dump_json["common_dump_settings"]["input_output"] = 0
-        self.dump_json["common_dump_settings"]["kernels"] = []
-        self.dump_json["common_dump_settings"]["support_device"] = [0, 1, 2, 3, 4, 5, 6, 7]
-        self.dump_json["common_dump_settings"]["op_debug_mode"] = 0
-        self.dump_json["common_dump_settings"]["file_format"] = "npy"
-
-        if len(config.list) > 0:
-            self.dump_json["common_dump_settings"]["dump_mode"] = 1
-            self.dump_json["common_dump_settings"]["kernels"] = config.list
-        self.dump_json["common_dump_settings"]["path"] = config.dump_path
-        if len(config.step) > 0:
-            step_str = ""
-            for s in config.step:
-                step_str += (str(s) + '|')
-            self.dump_json["common_dump_settings"]["iteration"] = step_str[:-1]
-        if len(config.rank) > 0:
-            self.dump_json["common_dump_settings"]["support_device"] = config.rank
-        if config.task == "tensor":
-            self.dump_json["common_dump_settings"]["saved_data"] = "tensor"
-            self.dump_json["common_dump_settings"]["file_format"] = config.file_format
-        if len(config.data_mode) == 1:
-            if config.data_mode[0] == "input":
-                self.dump_json["common_dump_settings"]["input_output"] = 1
-            if config.data_mode[0] == "output":
-                self.dump_json["common_dump_settings"]["input_output"] = 2
-
-    def handle(self):
-        if os.getenv("GRAPH_OP_RUN") == "1":
-            raise Exception("Must run in graph mode, not kbk mode")
-        json_path = self.dump_json["common_dump_settings"]["path"]
-        make_dump_path_if_not_exists(json_path)
-        json_path = os.path.join(json_path, "kernel_graph_dump.json")
-        with FileOpen(json_path, 'w') as f:
-            json.dump(self.dump_json, f)
-        logger.info(json_path + " has been created.")
-        os.environ["MINDSPORE_DUMP_CONFIG"] = json_path
-        if self.dump_json["common_dump_settings"]["dump_mode"] == 0:
-            if self.dump_json["common_dump_settings"]["iteration"] != "all" or \
-               len(self.dump_json["common_dump_settings"]["kernels"]) == 0:
-                os.environ["MS_ACL_DUMP_CFG_PATH"] = json_path
-        else:
-            if "MS_ACL_DUMP_CFG_PATH" in os.environ:
-                del os.environ["MS_ACL_DUMP_CFG_PATH"]
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# 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.
+
+import json
+import os
+
+from msprobe.core.common.file_utils import FileOpen, create_directory
+from msprobe.mindspore.common.log import logger
+from msprobe.mindspore.debugger.debugger_config import DebuggerConfig
+
+
+class KernelGraphDump:
+    def __init__(self, config: DebuggerConfig):
+        self.dump_json = dict()
+        self.dump_json["common_dump_settings"] = dict()
+        self.dump_json["common_dump_settings"]["dump_mode"] = 0
+        self.dump_json["common_dump_settings"]["path"] = ""
+        self.dump_json["common_dump_settings"]["net_name"] = "Net"
+        self.dump_json["common_dump_settings"]["iteration"] = "all"
+        self.dump_json["common_dump_settings"]["saved_data"] = "statistic"
+        self.dump_json["common_dump_settings"]["input_output"] = 0
+        self.dump_json["common_dump_settings"]["kernels"] = []
+        self.dump_json["common_dump_settings"]["support_device"] = [0, 1, 2, 3, 4, 5, 6, 7]
+        self.dump_json["common_dump_settings"]["op_debug_mode"] = 0
+        self.dump_json["common_dump_settings"]["file_format"] = "npy"
+
+        if len(config.list) > 0:
+            self.dump_json["common_dump_settings"]["dump_mode"] = 1
+            self.dump_json["common_dump_settings"]["kernels"] = config.list
+        self.dump_json["common_dump_settings"]["path"] = config.dump_path
+        if len(config.step) > 0:
+            step_str = ""
+            for s in config.step:
+                step_str += (str(s) + '|')
+            self.dump_json["common_dump_settings"]["iteration"] = step_str[:-1]
+        if len(config.rank) > 0:
+            self.dump_json["common_dump_settings"]["support_device"] = config.rank
+        if config.task == "tensor":
+            self.dump_json["common_dump_settings"]["saved_data"] = "tensor"
+            self.dump_json["common_dump_settings"]["file_format"] = config.file_format
+        if len(config.data_mode) == 1:
+            if config.data_mode[0] == "input":
+                self.dump_json["common_dump_settings"]["input_output"] = 1
+            if config.data_mode[0] == "output":
+                self.dump_json["common_dump_settings"]["input_output"] = 2
+
+    def handle(self):
+        if os.getenv("GRAPH_OP_RUN") == "1":
+            raise Exception("Must run in graph mode, not kbk mode")
+        json_path = self.dump_json["common_dump_settings"]["path"]
+        create_directory(json_path)
+        json_path = os.path.join(json_path, "kernel_graph_dump.json")
+        with FileOpen(json_path, 'w') as f:
+            json.dump(self.dump_json, f)
+        logger.info(json_path + " has been created.")
+        os.environ["MINDSPORE_DUMP_CONFIG"] = json_path
+        if self.dump_json["common_dump_settings"]["dump_mode"] == 0:
+            if self.dump_json["common_dump_settings"]["iteration"] != "all" or \
+               len(self.dump_json["common_dump_settings"]["kernels"]) == 0:
+                os.environ["MS_ACL_DUMP_CFG_PATH"] = json_path
+        else:
+            if "MS_ACL_DUMP_CFG_PATH" in os.environ:
+                del os.environ["MS_ACL_DUMP_CFG_PATH"]

msprobe/mindspore/dump/kernel_kbyk_dump.py

@@ -1,65 +1,79 @@
-import os
-import json
-
-from msprobe.core.common.utils import make_dump_path_if_not_exists
-from msprobe.mindspore.debugger.debugger_config import DebuggerConfig
-from msprobe.core.common.log import logger
-from msprobe.core.common.file_check import FileOpen
-from msprobe.core.common.const import Const
-
-
-class KernelKbykDump:
-    COMMON_SETTINGS = "common_dump_settings"
-    E2E_SETTINGS = "e2e_dump_settings"
-
-    def __init__(self, config: DebuggerConfig):
-        self.dump_json = dict()
-        common_set = dict()
-        e2e_set = dict()
-
-        common_set = dict()
-        common_set["dump_mode"] = 0
-        common_set["path"] = ""
-        common_set["net_name"] = "Net"
-        common_set["iteration"] = "all"
-        common_set["saved_data"] = "statistic"
-        common_set["input_output"] = 0
-        common_set["kernels"] = []
-        common_set["support_device"] = [0, 1, 2, 3, 4, 5, 6, 7]
-        e2e_set = dict()
-        e2e_set["enable"] = True
-        e2e_set["trans_flag"] = True
-
-        if config.list:
-            common_set["dump_mode"] = 1
-            common_set["kernels"] = config.list
-        common_set["path"] = config.dump_path
-        if config.step:
-            step_str = ""
-            for s in config.step:
-                step_str += (str(s) + '|')
-            common_set["iteration"] = step_str[:-1]
-        if config.rank:
-            common_set["support_device"] = config.rank
-        if config.task == Const.TENSOR:
-            common_set["saved_data"] = Const.TENSOR
-        if len(config.data_mode) == 1:
-            if config.data_mode[0] == Const.INPUT:
-                common_set["input_output"] = 1
-            if config.data_mode[0] == Const.OUTPUT:
-                common_set["input_output"] = 2
-
-        self.dump_json[KernelKbykDump.COMMON_SETTINGS] = common_set
-        self.dump_json[KernelKbykDump.E2E_SETTINGS] = e2e_set
-
-    def handle(self):
-        json_path = self.dump_json[KernelKbykDump.COMMON_SETTINGS]["path"]
-        make_dump_path_if_not_exists(json_path)
-        json_path = os.path.join(json_path, "kernel_kbyk_dump.json")
-        with FileOpen(json_path, 'w') as f:
-            json.dump(self.dump_json, f)
-        logger.info(json_path + " has been created.")
-
-        os.environ["MINDSPORE_DUMP_CONFIG"] = json_path
-        if "MS_ACL_DUMP_CFG_PATH" in os.environ:
-            del os.environ["MS_ACL_DUMP_CFG_PATH"]
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# 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.
+
+import json
+import os
+
+from msprobe.core.common.const import Const
+from msprobe.core.common.file_utils import FileOpen, create_directory
+from msprobe.mindspore.common.log import logger
+from msprobe.mindspore.debugger.debugger_config import DebuggerConfig
+
+
+class KernelKbykDump:
+    COMMON_SETTINGS = "common_dump_settings"
+    E2E_SETTINGS = "e2e_dump_settings"
+
+    def __init__(self, config: DebuggerConfig):
+        self.dump_json = dict()
+        common_set = dict()
+        e2e_set = dict()
+
+        common_set = dict()
+        common_set["dump_mode"] = 0
+        common_set["path"] = ""
+        common_set["net_name"] = "Net"
+        common_set["iteration"] = "all"
+        common_set["saved_data"] = "statistic"
+        common_set["input_output"] = 0
+        common_set["kernels"] = []
+        common_set["support_device"] = [0, 1, 2, 3, 4, 5, 6, 7]
+        e2e_set = dict()
+        e2e_set["enable"] = True
+        e2e_set["trans_flag"] = True
+
+        if config.list:
+            common_set["dump_mode"] = 1
+            common_set["kernels"] = config.list
+        common_set["path"] = config.dump_path
+        if config.step:
+            step_str = ""
+            for s in config.step:
+                step_str += (str(s) + '|')
+            common_set["iteration"] = step_str[:-1]
+        if config.rank:
+            common_set["support_device"] = config.rank
+        if config.task == Const.TENSOR:
+            common_set["saved_data"] = Const.TENSOR
+        if len(config.data_mode) == 1:
+            if config.data_mode[0] == Const.INPUT:
+                common_set["input_output"] = 1
+            if config.data_mode[0] == Const.OUTPUT:
+                common_set["input_output"] = 2
+
+        self.dump_json[KernelKbykDump.COMMON_SETTINGS] = common_set
+        self.dump_json[KernelKbykDump.E2E_SETTINGS] = e2e_set
+
+    def handle(self):
+        json_path = self.dump_json[KernelKbykDump.COMMON_SETTINGS]["path"]
+        create_directory(json_path)
+        json_path = os.path.join(json_path, "kernel_kbyk_dump.json")
+        with FileOpen(json_path, 'w') as f:
+            json.dump(self.dump_json, f)
+        logger.info(json_path + " has been created.")
+
+        os.environ["MINDSPORE_DUMP_CONFIG"] = json_path
+        if "MS_ACL_DUMP_CFG_PATH" in os.environ:
+            del os.environ["MS_ACL_DUMP_CFG_PATH"]