changed debug_name

python/paddle/jit/sot/opcode_translator/executor/function_graph.py

@@ -229,7 +229,7 @@ def _builtins(self):
         # prepare builtins
         for name, value in builtins.__dict__.items():
             builtins_[name] = VariableFactory.from_value(
-                value, self, BuiltinTracker(name), debug_name=name
+                value, self, BuiltinTracker(name)
             )
         return builtins_
 

python/paddle/jit/sot/opcode_translator/executor/opcode_executor.py

@@ -186,7 +186,6 @@ def inner(self: OpcodeExecutorBase, instr: Instruction):
         res = BuiltinVariable(fn, graph=self._graph, tracker=DanglingTracker())(
             *args
         )
-        res.debug_name = args[0].debug_name
         self.stack.push(res)
 
     return inner
@@ -941,13 +940,11 @@ def STORE_FAST(self, instr: Instruction):
         """
         var = self.stack.pop()
         name = self._code.co_varnames[instr.arg]
-        var.debug_name = name
         self._locals[name] = var
 
     def STORE_GLOBAL(self, instr: Instruction):
         var = self.stack.pop()
         name = self._code.co_names[instr.arg]
-        var.debug_name = name
         self._globals.set(name, var)
 
     def DELETE_GLOBAL(self, instr: Instruction):
@@ -979,7 +976,6 @@ def store_subscr_operation(self, key, container, value, opname):
         BuiltinVariable(operator.setitem, self._graph, DanglingTracker())(
             container, key, value
         )
-        value.debug_name = f"{container.debug_name}[{key.debug_name}]"
 
     def DELETE_SUBSCR(self, instr: Instruction):
         key = self.stack.pop()
@@ -1944,7 +1940,7 @@ def _prepare_virtual_env(self):
                 else LocalTracker(name)
             )
             self._locals[name] = VariableFactory.from_value(
-                value, self._graph, tracker, debug_name=name
+                value, self._graph, tracker
             )
 
         for name in free_or_cell_vars:

python/paddle/jit/sot/opcode_translator/executor/variables/base.py

@@ -38,10 +38,13 @@
 )
 from ..mutable_data import MutableDictLikeData
 from ..tracker import (
+    BuiltinTracker,
     DummyTracker,
     GetAttrTracker,
     GetItemTracker,
     GetIterTracker,
+    GlobalTracker,
+    LocalTracker,
     Tracker,
 )
 
@@ -229,8 +232,6 @@ def from_value(
         value: Any,
         graph: FunctionGraph,
         tracker: Tracker,
-        *,
-        debug_name: str | None = None,
     ) -> VariableBase:
         """
         Create a new variable object from the given value.
@@ -243,7 +244,6 @@ def from_value(
             value (Any): The input value.
             graph (FunctionGraph): The FunctionGraph object that this variable is associated with.
             tracker (Tracker): The Tracker object that tracks the information of this variable.
-            debug_name (str | None): An optional debug name for the variable.
 
         Returns:
             VariableBase: A new variable object representing the input value.
@@ -270,10 +270,20 @@ def _find_var(key: str = "default") -> VariableBase | None:
             var = VariableFactory.default_from_value(
                 value, graph, tracker
             )  # If a Variable could not be found using the registered functions, use the default function to create a new Variable
-        var.debug_name = debug_name
         return var
 
 
+def infer_debug_name_from_tracker(self, tracker: Tracker) -> str:
+    res = None
+    if isinstance(tracker, (LocalTracker, GlobalTracker, BuiltinTracker)):
+        res = f"{tracker.name}"
+    elif isinstance(tracker, GetItemTracker) and tracker.container.debug_name:
+        res = f"{tracker.container.debug_name}[{tracker.key}]"
+    elif isinstance(tracker, GetAttrTracker) and tracker.obj.debug_name:
+        res = f"{tracker.obj.debug_name}.{tracker.attr}"
+    return res
+
+
 class VariableBase:
     """
     VariableBase is a basic concept and each symbols in VM stack is regarded as
@@ -300,10 +310,11 @@ class VariableBase:
     mutable_attrs = []
 
     def __init__(self, graph: FunctionGraph, tracker: Tracker):
+
         self.graph = graph
         self.tracker = tracker
         self.id = VariableBase.name_generator.next()
-        self._debug_name: str | None = None
+        self.debug_name = infer_debug_name_from_tracker(self, tracker)
 
     @property
     def main_info(self) -> dict[str, Any]:
@@ -320,44 +331,12 @@ def debug_info(self) -> dict[str, Any]:
         """
         Property method to return a dictionary of debug information about the variable
         """
-        return {
-            "debug_name": self.debug_name,
+        info = {
             "id": self.id,
         }
-
-    @property
-    def debug_name(self) -> str:
-        """
-        Generate a debug_name for each variable.
-
-        Returns:
-            _debug_name: the name of variable.
-        """
-        if self._debug_name is not None:
-            # Return the self._debug_name cache if it is not None.
-            return self._debug_name
-        inputs = self.tracker.inputs
-        if isinstance(self.tracker, GetItemTracker):
-            self._debug_name = (
-                f"{self.tracker.container.debug_name}[{self.tracker.key}]"
-            )
-        elif isinstance(self.tracker, GetAttrTracker):
-            self._debug_name = (
-                f"{self.tracker.obj.debug_name}.{self.tracker.attr}"
-            )
-        elif len(inputs) == 0:
-            self._debug_name = "tmp_var"
-        else:  # len(inputs) >= 0
-            for input in inputs:
-                assert input is not None
-            self._debug_name = "tmp_var_" + "_".join(
-                input.debug_name for input in inputs
-            )
-        return self._debug_name
-
-    @debug_name.setter
-    def debug_name(self, name):
-        self._debug_name = name
+        if self.debug_name:
+            info["debug_name"] = self.debug_name
+        return info
 
     def __hash__(self):
         return hash(self.id)

python/paddle/jit/sot/opcode_translator/executor/variables/basic.py

@@ -134,14 +134,6 @@ def __init__(
     def get_py_value(self, allow_tensor=False):
         return self.value
 
-    @property
-    def debug_name(self) -> str:
-        return f"{self.value}"
-
-    @debug_name.setter
-    def debug_name(self, name):
-        pass
-
     def _reconstruct(self, codegen: PyCodeGen):
         codegen.gen_load_const(self.value)
 
@@ -1051,20 +1043,6 @@ def __init__(self, slice_: slice, graph, tracker):
         super().__init__(graph, tracker)
         self.value = slice_
 
-    @property
-    def debug_name(self) -> str:
-        return ":".join(
-            [
-                str(self.value.start) if self.value.start is not None else "",
-                str(self.value.stop) if self.value.stop is not None else "",
-                str(self.value.step) if self.value.step is not None else "",
-            ]
-        )
-
-    @debug_name.setter
-    def debug_name(self, name):
-        pass
-
     @cached_property
     def attr_proxy(self):
         return self.graph.side_effects.get_proxy(