mindspore 1.10.0__cp38-cp38-win_amd64.whl → 2.0.0rc1__cp38-cp38-win_amd64.whl

mindspore/_extends/parallel_compile/akg_compiler/build_tbe_kernel.py

@@ -14,7 +14,6 @@
 
 """build tbe kernel"""
 
-from __future__ import absolute_import
 import os
 import json
 import functools
@@ -102,13 +101,10 @@ class TransShape:
             from impl.add import _add_check_format, _infer_shape
             format_pattern = _add_check_format({"shape": shapes[0], "format": formats[0]},
                                                {"shape": shapes[1], "format": formats[1]})
-
-            ori_shape0 = ori_shapes[0]
-            if ori_shape0 is None:
-                ori_shape0 = infer_ori_shape(shapes[0], formats[0], ori_formats[0])
-            ori_shape1 = ori_shapes[1]
-            if ori_shape1 is None:
-                ori_shape1 = infer_ori_shape(shapes[1], formats[1], ori_formats[1])
+            ori_shape0 = ori_shapes[0] if ori_shapes[0] is not None else infer_ori_shape(
+                shapes[0], formats[0], ori_formats[0])
+            ori_shape1 = ori_shapes[1] if ori_shapes[1] is not None else infer_ori_shape(
+                shapes[1], formats[1], ori_formats[1])
             new_shapes = [None, None]
             new_shapes[0], new_shapes[1] = _infer_shape(format_pattern,
                                                         {"shape": shapes[0], "ori_shape": ori_shape0},
@@ -181,12 +177,16 @@ def get_inputs_name(input_desc):
     return inputs_name
 
 
-def get_outputs_name(output_desc):
-    """Get output tensor names."""
+def get_outputs_info(output_desc):
+    """Get output tensor names and inplace tensor names."""
     outputs_name = []
+    inplace_names = {}
     for item in output_desc:
-        outputs_name.append(item["tensor_name"])
-    return outputs_name
+        out_name = item["tensor_name"]
+        outputs_name.append(out_name)
+        if isinstance(item.get("inplace_to"), str):
+            inplace_names[out_name] = item["inplace_to"]
+    return outputs_name, inplace_names
 
 
 def get_all_op_name(op_desc):
@@ -222,19 +222,20 @@ def get_inputs_tensor(input_desc, all_tensors):
     return inputs
 
 
-def get_op_attrs(op, fusion_op_name):
-    """Get op attrs."""
-
-    def _get_attrs(attr_desc):
-        attrs = {}
-        if not isinstance(attr_desc, list):
-            return attrs
-        for attr in attr_desc:
-            attrs[attr["name"]] = attr["value"]
+def get_attr_dict(attr_desc):
+    """Parse attr_desc to dict."""
+    attrs = {}
+    if not isinstance(attr_desc, list):
         return attrs
+    for attr in attr_desc:
+        attrs[attr["name"]] = attr["value"]
+    return attrs
+
 
+def get_op_attrs(op, fusion_op_name):
+    """Get op attrs."""
     op_name = op["name"]
-    op_attrs = _get_attrs(op.get("attr"))
+    op_attrs = get_attr_dict(op.get("attr"))
     if op_name == "BatchMatMul":
         op_attrs["dst_type"] = op["output_desc"][0]["data_type"]
         op_attrs["dst_ori_shape"] = op["output_desc"][0].get("ori_shape")
@@ -318,7 +319,7 @@ def create_fusion_op_name(op_names):
     fusion_op_name = "te_fusion" if len(op_names) > 1 else ""
     for op_name in op_names:
         kernel_name = get_op_reg_info(op_name, "kernel_name")
-        fusion_op_name = "{}_{}".format(fusion_op_name, kernel_name)
+        fusion_op_name = fusion_op_name + "_" + kernel_name
     return fusion_op_name
 
 
@@ -347,12 +348,101 @@ def update_format(json_dict):
         _update_output_format(op["output_desc"])
 
 
-def build(json_str):
+def gen_args_remap(orig_inputs_name, orig_outputs_name, inputs_name, outputs_name, inplace_names):
+    """Generate the final kernel args indices."""
+    input_indices = []
+    output_indices = []
+    ni = len(orig_inputs_name)
+    for _, name in enumerate(inputs_name):
+        if name not in orig_inputs_name:
+            raise ValueError("Current input name [{}] can not be found in original input names list: {}"
+                             .format(name, orig_inputs_name))
+        input_indices.append(orig_inputs_name.index(name))
+    for _, name in enumerate(outputs_name):
+        if name in orig_outputs_name:
+            output_indices.append(ni + orig_outputs_name.index(name))
+        elif name in inplace_names and inplace_names[name] in orig_inputs_name:
+            output_indices.append(orig_inputs_name.index(inplace_names[name]))
+        else:
+            raise ValueError("Current output name [{}] can not be found in original output names list: {}, and it not "
+                             "inplace to an input tensor".format(name, orig_outputs_name))
+    return input_indices, output_indices
+
+
+def update_json(json_dict, inputs_name, outputs_name, inplace_names, kernel_meta_parent_dir):
+    """update kernel json."""
+
+    def _get_tensor_name(idx):
+        if idx < len(input_indices):
+            orig_idx = input_indices[idx]
+        elif idx - len(input_indices) < len(output_indices):
+            orig_idx = output_indices[idx - len(input_indices)]
+        else:
+            raise ValueError("parameters index >= the sum of input and output tensor numbers: {} vs {}"
+                             .format(idx, len(input_indices) + len(output_indices)))
+        if orig_idx < len(orig_input_names):
+            return orig_input_names[orig_idx]
+        if orig_idx - len(orig_input_names) >= len(orig_output_names):
+            raise ValueError("parameters index [{}]'s original index >= the sum of original input and original output"
+                             "tensor numbers: {} vs {}"
+                             .format(idx, orig_idx, len(orig_input_names) + len(orig_output_names)))
+        return orig_output_names[orig_idx - len(orig_input_names)]
+
+    def _update_parameters(cur_parameters):
+        atomic_tensors = set()
+        for i, p in enumerate(cur_parameters):
+            if p == 0:
+                continue
+            orig_tensor_name = _get_tensor_name(i)
+            if orig_tensor_name not in orig_input_names:
+                atomic_tensors.add(orig_tensor_name)
+        res = [0] * len(orig_input_names)
+        for _, name in enumerate(orig_output_names):
+            p = 1 if name in atomic_tensors else 0
+            res.append(p)
+        return res
+
+    def _save_json():
+        # remove original .json
+        try:
+            os.remove(json_path)
+        except OSError:
+            pass
+        # generate new .json
+        try:
+            with os.fdopen(os.open(json_path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o660), 'w') as fi:
+                json.dump(json_dict, fi, sort_keys=True, indent=4, separators=(',', ':'))
+        except OSError:
+            pass
+
+    global_attrs = get_attr_dict(json_dict.get("global_attrs", []))
+    orig_input_names = global_attrs.get("orig_input_names", [])
+    orig_output_names = global_attrs.get("orig_output_names", [])
+    input_indices, output_indices = gen_args_remap(orig_input_names, orig_output_names,
+                                                   inputs_name, outputs_name, inplace_names)
+    json_name = json_dict.get("op") + ".json"
+    json_path = os.path.join(os.path.realpath(kernel_meta_parent_dir), "kernel_meta", json_name)
+    if os.path.isfile(json_path):
+        with open(json_path, "r") as f:
+            json_dict = json.loads(f.read())
+        # Save args_remap to .json: use this information to fetch the correct address during kernel launch
+        json_dict["args_remap"] = [input_indices, output_indices]
+        # Update parameters: current parameters is relative to current info(the composite optimized info) whose input
+        # and output tensors may be different from the original info, however, the frame can only see the original
+        # info's input and output tensors, so we need to generate a new parameters which is relative to original info.
+        parameters = json_dict.get("parameters", [])
+        new_parameters = _update_parameters(parameters)
+        json_dict["parameters"] = new_parameters
+        # Save the updated json
+        _save_json()
+
+
+def build(json_str, kernel_meta_parent_dir):
     """Build kernel."""
     json_dict = json.loads(json_str)
     update_format(json_dict)
     inputs_name = get_inputs_name(json_dict.get("input_desc", []))
-    outputs_name = get_outputs_name(json_dict["output_desc"])
+    outputs_name, inplace_names = get_outputs_info(json_dict["output_desc"])
     op_names = get_all_op_name(json_dict["op_desc"])
     fusion_op_name = create_fusion_op_name(op_names)
 
@@ -399,9 +489,12 @@ def build(json_str):
         update_config(config, op_names)
         tbe_build(sch, config)
 
+    if inplace_names:
+        update_json(json_dict, inputs_name, outputs_name, inplace_names, kernel_meta_parent_dir)
+
 
 def build_tbe_kernel(json_str, kernel_meta_parent_dir):
     """Build TBE kernel."""
     initialize(kernel_meta_parent_dir)
     with build_config(kernel_meta_parent_dir=kernel_meta_parent_dir):
-        build(json_str)
+        build(json_str, kernel_meta_parent_dir)

mindspore/_extends/parallel_compile/akg_compiler/tbe_topi.py

@@ -13,14 +13,14 @@
 # limitations under the License.
 # ============================================================================
 """tbe topi"""
-from __future__ import absolute_import
 import math
 import functools
 from enum import Enum
 
 
 class OpPattern(Enum):
-    """OpPattern Enum."""
+    """Pattern of operator."""
+
     ELEMWISE = "ELEMWISE"
     BROADCAST = "BROADCAST"
     REDUCE = "REDUCE"
@@ -60,24 +60,24 @@ def get_op_reg_info(op_name, key, strict=True):
 
 def _broadcast(lhs, rhs):
     """Broadcast inputs."""
-    from te import tvm
-    from te.utils import shape_util
-    import te.lang.cce as tbe
-    if isinstance(lhs, tvm.tensor.Tensor) and isinstance(rhs, tvm.expr.ConstExpr):
-        return lhs, tbe.broadcast(rhs, lhs.shape)
-    if isinstance(lhs, tvm.expr.ConstExpr) and isinstance(rhs, tvm.tensor.Tensor):
-        return tbe.broadcast(lhs, rhs.shape), rhs
+    import tbe
+    from tbe import tvm
+    from tbe.common.utils import shape_to_list, broadcast_shapes
+    if isinstance(lhs, tvm.Tensor) and isinstance(rhs, tvm.expr.ConstExpr):
+        return lhs, tbe.dsl.broadcast(rhs, lhs.shape)
+    if isinstance(lhs, tvm.expr.ConstExpr) and isinstance(rhs, tvm.Tensor):
+        return tbe.dsl.broadcast(lhs, rhs.shape), rhs
     if isinstance(lhs, tvm.expr.ConstExpr) and isinstance(rhs, tvm.expr.ConstExpr):
         shape = [1]
-        return tbe.broadcast(lhs, shape), tbe.broadcast(rhs, shape)
-    if isinstance(lhs, tvm.tensor.Tensor) and isinstance(rhs, tvm.tensor.Tensor):
-        shape1 = shape_util.shape_to_list(lhs.shape)
-        shape2 = shape_util.shape_to_list(rhs.shape)
+        return tbe.dsl.broadcast(lhs, shape), tbe.dsl.broadcast(rhs, shape)
+    if isinstance(lhs, tvm.Tensor) and isinstance(rhs, tvm.Tensor):
+        shape1 = shape_to_list(lhs.shape)
+        shape2 = shape_to_list(rhs.shape)
         if shape1 != shape2:
-            _, _, shape = shape_util.broadcast_shapes(shape1, shape2, param_name_input1="lhs", param_name_input2="rhs")
-            return tbe.broadcast(lhs, shape), tbe.broadcast(rhs, shape)
+            _, _, shape = broadcast_shapes(shape1, shape2, param_name_input1="lhs", param_name_input2="rhs")
+            return tbe.dsl.broadcast(lhs, shape), tbe.dsl.broadcast(rhs, shape)
         return lhs, rhs
-    raise TypeError("Broadcast only supports tvm.tensor.Tensor or tvm.expr.ConstExpr, but got {}, {}"
+    raise TypeError("Broadcast only supports tvm.Tensor or tvm.expr.ConstExpr, but got {}, {}"
                     .format(type(lhs), type(rhs)))
 
 
@@ -105,13 +105,13 @@ def _acosh(x, attrs=None):
 @reg_op("Add", pattern=OpPattern.ELEMWISE)
 def _add(x0, x1, attrs=None):
     """Add"""
-    from te import tvm
-    import te.lang.cce as tbe
+    import tbe
+    from tbe import tvm
     is_float = x0.dtype in ["float16", "float32"]
-    if is_float and isinstance(x0, tvm.tensor.Tensor) and isinstance(x1, tvm.expr.ConstExpr):
-        return tbe.vadds(x0, x1)
-    if is_float and isinstance(x0, tvm.expr.ConstExpr) and isinstance(x1, tvm.tensor.Tensor):
-        return tbe.vadds(x1, x0)
+    if is_float and isinstance(x0, tvm.Tensor) and isinstance(x1, tvm.expr.ConstExpr):
+        return tbe.dsl.vadds(x0, x1)
+    if is_float and isinstance(x0, tvm.expr.ConstExpr) and isinstance(x1, tvm.Tensor):
+        return tbe.dsl.vadds(x1, x0)
     x0, x1 = _broadcast(x0, x1)
     from impl.add import add_compute
     return add_compute(x0, x1, None, kernel_name=attrs["fusion_op_name"])
@@ -151,7 +151,7 @@ def _cast(x, attrs=None):
     src_type = x.dtype
     dst_type = attrs["dst_type"]
     if src_type == "int64":
-        from te import tvm
+        from tbe import tvm
         from impl.cast import _kernel_ir
         res = tvm.extern([x.shape], [x], lambda ins, outs: _kernel_ir(outs, ins, dst_type, "int64"), name="res",
                          dtype=dst_type)
@@ -340,13 +340,13 @@ def _mod(x0, x1, attrs=None):
 @reg_op("Mul", pattern=OpPattern.ELEMWISE)
 def _mul(x0, x1, attrs=None):
     """Mul"""
-    from te import tvm
-    import te.lang.cce as tbe
+    import tbe
+    from tbe import tvm
     is_float = x0.dtype in ["float16", "float32"]
-    if is_float and isinstance(x0, tvm.tensor.Tensor) and isinstance(x1, tvm.expr.ConstExpr):
-        return tbe.vmuls(x0, x1)
-    if is_float and isinstance(x0, tvm.expr.ConstExpr) and isinstance(x1, tvm.tensor.Tensor):
-        return tbe.vmuls(x1, x0)
+    if is_float and isinstance(x0, tvm.Tensor) and isinstance(x1, tvm.expr.ConstExpr):
+        return tbe.dsl.vmuls(x0, x1)
+    if is_float and isinstance(x0, tvm.expr.ConstExpr) and isinstance(x1, tvm.Tensor):
+        return tbe.dsl.vmuls(x1, x0)
     x0, x1 = _broadcast(x0, x1)
     from impl.mul import mul_compute
     return mul_compute(x0, x1, None, kernel_name=attrs["fusion_op_name"])
@@ -378,10 +378,10 @@ def _pow(x0, x1, attrs=None):
 @reg_op("RealDiv", "real_div", OpPattern.ELEMWISE)
 def _realdiv(x0, x1, attrs=None):
     """RealDiv"""
-    from te import tvm
-    import te.lang.cce as tbe
-    if x0.dtype in ["float16", "float32"] and isinstance(x0, tvm.tensor.Tensor) and isinstance(x1, tvm.expr.ConstExpr):
-        return tbe.vmuls(x0, tvm.const(1.0 / x1.value, x0.dtype))
+    import tbe
+    from tbe import tvm
+    if x0.dtype in ["float16", "float32"] and isinstance(x0, tvm.Tensor) and isinstance(x1, tvm.expr.ConstExpr):
+        return tbe.dsl.vmuls(x0, tvm.const(1.0 / x1.value, x0.dtype))
     x0, x1 = _broadcast(x0, x1)
     from impl.real_div import real_div_compute
     return real_div_compute(x0, x1, None, kernel_name=attrs["fusion_op_name"])
@@ -439,14 +439,14 @@ def _square(x, attrs=None):
 @reg_op("Sub", pattern=OpPattern.ELEMWISE)
 def _sub(x0, x1, attrs=None):
     """Sub"""
-    from te import tvm
-    import te.lang.cce as tbe
+    import tbe
+    from tbe import tvm
     is_float = x0.dtype in ["float16", "float32"]
-    if is_float and isinstance(x0, tvm.tensor.Tensor) and isinstance(x1, tvm.expr.ConstExpr):
-        return tbe.vadds(x0, tvm.const(-1.0 * x1.value, x0.dtype))
-    if is_float and isinstance(x0, tvm.expr.ConstExpr) and isinstance(x1, tvm.tensor.Tensor):
-        tmp = tbe.vmuls(x1, tvm.const(-1, x1.dtype))
-        return tbe.vadds(tmp, tvm.const(x0.value, x0.dtype))
+    if is_float and isinstance(x0, tvm.Tensor) and isinstance(x1, tvm.expr.ConstExpr):
+        return tbe.dsl.vadds(x0, tvm.const(-1.0 * x1.value, x0.dtype))
+    if is_float and isinstance(x0, tvm.expr.ConstExpr) and isinstance(x1, tvm.Tensor):
+        tmp = tbe.dsl.vmuls(x1, tvm.const(-1, x1.dtype))
+        return tbe.dsl.vadds(tmp, tvm.const(x0.value, x0.dtype))
     x0, x1 = _broadcast(x0, x1)
     from impl.sub import sub_compute
     return sub_compute(x0, x1, None, kernel_name=attrs["fusion_op_name"])
@@ -462,26 +462,26 @@ def _tanh(x, attrs=None):
 @reg_op("BroadcastTo", "broadcast", OpPattern.BROADCAST)
 def _broadcast_to(x, attrs=None):
     """BroadcastTo"""
-    from te import tvm
-    import te.lang.cce as tbe
+    import tbe
+    from tbe import tvm
     shape = attrs["shape"]
-    if isinstance(x, tvm.tensor.Tensor):
+    if isinstance(x, tvm.Tensor):
         from impl.broadcast_to_d import broadcast_to_compute
         return broadcast_to_compute(x, None, shape, kernel_name=attrs["fusion_op_name"])
-    return tbe.broadcast(x, shape, x.dtype)
+    return tbe.dsl.broadcast(x, shape, x.dtype)
 
 
 @reg_op("ReduceSum", "reduce_sum", OpPattern.REDUCE)
 def _reduce_sum(x, attrs=None):
     """ReduceSum"""
-    from te.utils import shape_util
+    from tbe.common.utils import axis_check
     axis = attrs["axis"]
     keep_dims = attrs["keep_dims"]
     if not axis:
         axis = [i for i in range(len(x.shape))]
     if not isinstance(axis, list):
         axis = [axis]
-    axis = shape_util.axis_check(len(x.shape), axis)
+    axis = axis_check(len(x.shape), axis)
     from impl.reduce_sum_d import reduce_sum_d_compute
     return reduce_sum_d_compute(x, None, axis, keep_dims, kernel_name=attrs["fusion_op_name"])
 
@@ -489,14 +489,14 @@ def _reduce_sum(x, attrs=None):
 @reg_op("ReduceMax", "reduce_max", OpPattern.REDUCE)
 def _reduce_max(x, attrs=None):
     """ReduceMax"""
-    from te.utils import shape_util
+    from tbe.common.utils import axis_check
     axis = attrs["axis"]
     keep_dims = attrs["keep_dims"]
     if not axis:
         axis = [i for i in range(len(x.shape))]
     if not isinstance(axis, list):
         axis = [axis]
-    axis = shape_util.axis_check(len(x.shape), axis)
+    axis = axis_check(len(x.shape), axis)
     from impl.reduce_max_d import reduce_max_d_compute
     return reduce_max_d_compute(x, None, axis, keep_dims, kernel_name=attrs["fusion_op_name"])
 
@@ -504,14 +504,14 @@ def _reduce_max(x, attrs=None):
 @reg_op("ReduceMin", "reduce_min", OpPattern.REDUCE)
 def _reduce_min(x, attrs=None):
     """ReduceMin"""
-    from te.utils import shape_util
+    from tbe.common.utils import axis_check
     axis = attrs["axis"]
     keep_dims = attrs["keep_dims"]
     if not axis:
         axis = [i for i in range(len(x.shape))]
     if not isinstance(axis, list):
         axis = [axis]
-    axis = shape_util.axis_check(len(x.shape), axis)
+    axis = axis_check(len(x.shape), axis)
     from impl.reduce_min_d import reduce_min_d_compute
     return reduce_min_d_compute(x, None, axis, keep_dims, kernel_name=attrs["fusion_op_name"])
 

mindspore/_extends/parallel_compile/akg_compiler/util.py

@@ -58,14 +58,19 @@ def print_compile_log(compile_log):
                     logger.info(log)
 
 
-def get_kernel_meta_parent_dir():
+def get_kernel_meta_parent_dir(attrs):
     """Get kernel_meta parent dir."""
-    return os.path.realpath(os.getenv('MS_COMPILER_CACHE_PATH', './'))
+    attrs_dict = {}
+    if isinstance(attrs, str):
+        attrs_dict = json.loads(attrs)
+    elif isinstance(attrs, dict):
+        attrs_dict = attrs
+    return os.path.realpath(attrs_dict.get("compile_cache"))
 
 
-def get_ascend_compile_dirs():
+def get_ascend_compile_dirs(attrs):
     """Get several Ascend compile dirs."""
-    kernel_meta_dir = os.path.join(get_kernel_meta_parent_dir(), "akg_kernel_meta")
+    kernel_meta_dir = os.path.join(get_kernel_meta_parent_dir(attrs), "akg_kernel_meta")
     compile_dirs = {"kernel_meta_dir": kernel_meta_dir,
                     "akg_compile_dir": os.path.join(kernel_meta_dir, "akg"),
                     "tbe_compile_dir": os.path.join(kernel_meta_dir, "tbe"),
@@ -142,8 +147,6 @@ def check_tbe_support(json_desc):
 
     for op in json_desc["op_desc"]:
         op_name = op["name"]
-        if op_name == "Reshape":
-            continue
         if not get_op_reg_info(op_name, "func", False):
             logger.info("TBE op not registered: {}".format(op_name))
             return False

mindspore/_extends/parallel_compile/tbe_compiler/tbe_adapter.py

@@ -25,7 +25,7 @@ from tbe.common.rl_bank.bank_manager import set_current_op_name
 from tbe.common.repository_manager.interface import cann_kb_finalize, cann_kb_init
 from te.platform.cce_conf import te_set_version
 from te.platform.cce_policy import set_L1_info
-from te_fusion.compile_task_manager import dispatch_prebuild_task, dispatch_single_op_compile_task, import_py_module, \
+from te_fusion.compile_task_manager import dispatch_prebuild_task, dispatch_single_op_compile_task, \
     dispatch_fusion_op_compile_task, dispatch_autotune_task, sync_op_tune_params
 from te_fusion.compile_task_manager import sync_syspath
 from te_fusion.fusion_manager import call_op_func, clear_fusion_params, check_op_impl_mode, \
@@ -310,10 +310,10 @@ def check_support(job: TbeJob):
     if op_func_name in ("resize_nearest_neighbor_v2_grad_d", "resize_bilinear_v2_grad"):
         attrs.pop(-2)
     op_module_name = get_module_name(compute_op_info)
-    py_module_path = compute_op_info["py_module_path"]
-    _normalize_module_name(op_module_name, py_module_path)
+    _normalize_module_name(op_module_name, compute_op_info["py_module_path"])
     func_name = "check_supported"
-    res = call_op_func((inputs, outputs, attrs), op_module_name, func_name)
+    op_type = compute_op_info["type"]
+    res = call_op_func((inputs, outputs, attrs), op_module_name, func_name, op_type, "high_performance")
     if isinstance(res, tuple):
         result, reason = res
         result_str = str(result)
@@ -497,27 +497,6 @@ def before_build_process(job: TbeJob):
         dump_fusion_json(json.dumps(job.content), job.sys_tune_dump_path)
 
 
-def sync_fusion_env(fusion_need_sync, module_list):
-    """
-    Sync fusion env
-    :param fusion_need_sync:
-    :param module_list:
-    :return:
-    """
-    if fusion_need_sync == 0:
-        return True
-
-    module_using = []
-    for key, value in module_list.items():
-        if value > 0:
-            module_using.append(str(key))
-        module_list[key] = 0
-
-    module_str = ",".join(module_using)
-    import_py_module(module_str)
-    return True
-
-
 def parallel_compile_fusion_op(job: TbeJob):
     """
     Compile fusion op in parallel compiler

mindspore/_extends/parallel_compile/tbe_compiler/tbe_helper.py

@@ -143,10 +143,12 @@ def get_soc_info(initialize_job_info):
     soc_param = dict()
     soc_param["op_impl_mode"] = initialize_job_info["SocInfo"]["op_impl_mode"]
     soc_param["op_debug_level"] = reset_op_debug_level_in_soc_info(initialize_job_info["SocInfo"]["op_debug_level"])
+    soc_param["op_debug_config"] = initialize_job_info["SocInfo"]["op_debug_config"]
     soc_param["op_impl_mode_list"] = initialize_job_info["SocInfo"]["op_impl_mode_list"]
     soc_param["op_debug_dir"] = initialize_job_info["SocInfo"]["op_debug_dir"]
     soc_param["vector_fp_ceiling"] = initialize_job_info["SocInfo"]["vector_fp_ceiling"]
     soc_param['mdl_bank_path'] = initialize_job_info["SocInfo"]["mdl_bank_path"]
+    soc_param['te_version'] = initialize_job_info["SocInfo"]["te_version"]
     soc_param['op_bank_path'] = initialize_job_info["SocInfo"]["op_bank_path"]
     soc_param['kernel_meta_temp_dir'] = initialize_job_info["SocInfo"]["kernel_meta_temp_dir"]
 
@@ -247,7 +249,7 @@ def assemble_op_args(compute_op_info, is_single_op_build=False):
         attrs = []
         attrs_info = compute_op_info["attrs"] if "attrs" in compute_op_info.keys() else []
         for item in attrs_info:
-            if item["valid"] and item["name"] != "isRef":
+            if item["valid"]:
                 attrs.append(item)
     else:
         attrs = compute_op_info["attr_desc"] if "attr_desc" in compute_op_info.keys() else []
@@ -285,15 +287,18 @@ def get_options_info(job_content):
     options["l2Fusion"] = job_content["SocInfo"]["l2Fusion"]
     options["l2Mode"] = job_content["SocInfo"]["l2Mode"]
     options["op_debug_level"] = reset_op_debug_level_in_soc_info(job_content["SocInfo"]["op_debug_level"])
+    options["op_debug_config"] = job_content["SocInfo"]["op_debug_config"]
     options["op_impl_mode"] = job_content["SocInfo"]["op_impl_mode"]
     options["op_debug_dir"] = job_content["SocInfo"]["op_debug_dir"]
     options["mdl_bank_path"] = job_content["SocInfo"]["mdl_bank_path"]
+    options["te_version"] = job_content["SocInfo"]["te_version"]
     options["op_bank_path"] = job_content["SocInfo"]["op_bank_path"]
     options["deviceId"] = job_content["SocInfo"]["deviceId"]
     options["autoTilingMode"] = job_content["SocInfo"]["autoTilingMode"]
     options["op_impl_mode_list"] = job_content["SocInfo"]["op_impl_mode_list"]
     options["kernel_meta_temp_dir"] = job_content["SocInfo"]["kernel_meta_temp_dir"]
-    options["status_check"] = "false"
+    options["deterministic"] = job_content["SocInfo"]["deterministic"]
+    options["status_check"] = job_content["SocInfo"]["status_check"]
     return options
 
 
@@ -336,10 +341,10 @@ def get_module_name(compute_op_info):
     :param compute_op_info:
     :return:
     """
-    dynamic_compile_static = compute_op_info["dynamic_compile_static"]
+    is_dynamic_impl = compute_op_info["is_dynamic_impl"]
     unknown_shape = compute_op_info["unknown_shape"]
     op_module_name = compute_op_info["module_name"]
-    if dynamic_compile_static or unknown_shape:
+    if is_dynamic_impl or unknown_shape:
         d = ".dynamic."
         op_module_name = d.join((op_module_name.split(".")[0], op_module_name.split(".")[-1]))
     return op_module_name

mindspore/_extends/parallel_compile/tbe_compiler/tbe_job_manager.py

@@ -20,7 +20,7 @@ import traceback
 from enum import Enum
 
 from .tbe_adapter import tbe_initialize, get_auto_tune_support_op_list, tbe_finalize, check_support, select_op_format, \
-    parallel_pre_compile_op, do_fuzz_build_tbe_op, before_build_process, build_single_pre_op, sync_fusion_env, \
+    parallel_pre_compile_op, do_fuzz_build_tbe_op, before_build_process, build_single_pre_op, \
     parallel_compile_fusion_op, rl_tune_single_op, rl_tune_fusion_op, ga_tune, get_finish_tasks, get_prebuild_output
 from .tbe_helper import check_job_json, get_compute_op_list, get_func_names
 from .tbe_job import TbeJob, JobStatus, JobType
@@ -169,7 +169,6 @@ class TbeJobManager:
         if not res:
             job.error("Process CheckSupport Job failed, job json string:{}".format(job.json_string))
             return self.add_to_finished_jobs(job, JobStatus.JOB_FAILED)
-        self._update_imported_op_module(job)
         return self.add_to_finished_jobs(job, JobStatus.JOB_SUCCESS)
 
     def select_format_handler(self, job: TbeJob):
@@ -196,9 +195,6 @@ class TbeJobManager:
             return self.single_op_compile(job)
 
         before_build_process(job)
-        if self.fusion_need_sync:
-            sync_fusion_env(self.fusion_need_sync, self.imported_module)
-            self.fusion_need_sync = 0
         res = parallel_compile_fusion_op(job)
         if not res:
             job.error("Parallel_compile_fusion_op Job failed, job json string:{}".format(job.json_string))
@@ -245,25 +241,17 @@ class TbeJobManager:
                     "Tune Job failed, tune type {}, job json string:{}".format(tune_mode, job.json_string))
                 return self.add_to_finished_jobs(job, JobStatus.JOB_FAILED)
         else:
-            if self.fusion_need_sync:
-                sync_fusion_env(self.fusion_need_sync, self.imported_module)
-                self.fusion_need_sync = 0
             res = ga_tune(job)
             if not res:
                 job.error("ga tune Job failed, job json string:{}".format(job.json_string))
                 return self.compile_handler(job)
         if job.status == JobStatus.JOB_RUNNING:
-            if tune_mode == TuneMode.RL_TUNE:
-                self._update_imported_op_module(job)
             return self.add_to_running_jobs(job)
         return self.add_to_finished_jobs(job, JobStatus.JOB_SUCCESS)
 
     def fusion_op_tune(self, job: TbeJob):
         """Fusion operator tune"""
         tune_mode = self._select_tune_mode(job)
-        if self.fusion_need_sync:
-            sync_fusion_env(self.fusion_need_sync, self.imported_module)
-            self.fusion_need_sync = 0
         if tune_mode == TuneMode.RL_TUNE:
             res = rl_tune_fusion_op(job)
         else:
@@ -419,20 +407,6 @@ class TbeJobManager:
             self.core_num = int(initialize_job.content["SocInfo"]["coreNum"])
         self.op_bank_path = initialize_job.content["SocInfo"]["op_bank_path"]
 
-    def _update_imported_op_module(self, job):
-        """
-        update imported op module info according to new job
-        :param job:
-        :return:
-        """
-        compute_op_info = get_compute_op_list(job.content)[0]
-        op_module_name = compute_op_info["module_name"]
-        if op_module_name in self.imported_module.keys():
-            self.imported_module[op_module_name] = self.imported_module[op_module_name] + 1
-        else:
-            self.imported_module[op_module_name] = 1
-        self.fusion_need_sync = self.fusion_need_sync + 1
-
     def _select_tune_mode(self, job):
         """
         Select the corresponding tune mode according to op job content and job manager system info

mindspore/_extends/parse/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2020-2022 Huawei Technologies Co., Ltd
+# Copyright 2020-2023 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.
@@ -26,7 +26,8 @@ from .parser import (Parser, create_instance, is_supported_create_instance_type,
                      convert_to_ms_tensor, get_object_description, get_class_attr_namespace_symbol, get_ms_class_name,
                      is_class_type, check_obj_bool, python_isinstance, ms_isinstance, convert_to_ms_csrtensor,
                      convert_to_ms_cootensor, convert_class_to_function, convert_cell_list_to_sequence, is_cell_list,
-                     get_obj_from_sequence, get_type)
+                     get_obj_from_sequence, get_type, is_class_member_recursive, merge_global_params, get_global_params,
+                     get_adapter_tensor_attr, get_local_variable, set_local_variable, get_obj_defined_from_obj_type)
 
 __all__ = ['Parser', 'create_instance', 'is_supported_create_instance_type', 'generate_scope',
            'get_bprop_method_of_class', 'get_class_instance_type', 'get_class_member_namespace_symbol',
@@ -37,4 +38,5 @@ __all__ = ['Parser', 'create_instance', 'is_supported_create_instance_type', 'ge
            'convert_to_ms_tensor', 'get_object_description', 'get_class_attr_namespace_symbol', 'get_ms_class_name',
            'is_class_type', 'check_obj_bool', 'python_isinstance', 'ms_isinstance', 'convert_to_ms_csrtensor',
            'convert_to_ms_cootensor', 'convert_class_to_function', 'convert_cell_list_to_sequence', 'is_cell_list',
-           'get_obj_from_sequence', 'get_type']
+           'get_obj_from_sequence', 'get_type', 'is_class_member_recursive', 'get_adapter_tensor_attr',
+           'get_local_variable', 'set_local_variable', 'get_obj_defined_from_obj_type']