[SOT][3.13] support CONVERT_VALUE and FORMAT_WITH_SPEC opcode in python3.13 (#69401)

GoldenStain · web-flow · commit f63f41a99303 · 2024-11-18T23:10:37.000+08:00
diff --git a/python/paddle/jit/sot/opcode_translator/executor/instr_flag.py b/python/paddle/jit/sot/opcode_translator/executor/instr_flag.py
@@ -26,6 +26,12 @@ class FORMAT_VALUE_FLAG:
     FVS_HAVE_SPEC = 0x4
 
 
+class CONVERT_VALUE_FLAG:
+    CV_STR = 1
+    CV_REPR = 2
+    CV_ASCII = 3
+
+
 class MAKE_FUNCTION_FLAG:
     MF_HAS_CLOSURE = 0x08
     MF_HAS_ANNOTATION = 0x04
diff --git a/python/paddle/jit/sot/opcode_translator/executor/opcode_executor.py b/python/paddle/jit/sot/opcode_translator/executor/opcode_executor.py
@@ -62,6 +62,7 @@
 from .function_graph import FunctionGraph
 from .instr_flag import (
     CALL_FUNCTION_EX_FLAG as CFE,
+    CONVERT_VALUE_FLAG as CV,
     FORMAT_VALUE_FLAG as FV,
     MAKE_FUNCTION_FLAG as MF,
     IntrinsicsUnaryFunctions,
@@ -1596,7 +1597,7 @@ def FORMAT_VALUE(self, instr: Instruction):
         if isinstance(value, ConstantVariable):
             result = value.get_py_value()
             if convert_fn is not None:
-                result = getattr(result, convert_fn)(result)
+                result = getattr(result, convert_fn)()
 
             if not isinstance(result, str) or fmt_spec != "":
                 result = format(result, fmt_spec)
@@ -1607,6 +1608,54 @@ def FORMAT_VALUE(self, instr: Instruction):
         else:
             raise FallbackError(f"Do not support format {type(value)} now")
 
+    def CONVERT_VALUE(self, instr: Instruction):
+        value = self.stack.pop()
+        flag = instr.arg
+        if flag == CV.CV_STR:
+            convert_fn = "__str__"
+        elif flag == CV.CV_REPR:
+            convert_fn = "__repr__"
+        elif flag == CV.CV_ASCII:
+            convert_fn = "__ascii__"
+        else:
+            raise InnerError(
+                f"Unexpected conversion flag {flag} in {instr.opname}"
+            )
+        if isinstance(value, ConstantVariable):
+            result = value.get_py_value()
+            result = getattr(result, convert_fn)()
+            self.stack.push(
+                ConstantVariable(result, self._graph, DummyTracker([value]))
+            )
+        else:
+            raise FallbackError(
+                f"Do not support format {type(value)} now in {instr.opname} now"
+            )
+
+    def FORMAT_WITH_SPEC(self, instr: Instruction):
+        # unlike the former FORMAT_VALUE, the FORMAT_WITH_SPEC opcode has no parameter flag.
+        raw_spec = self.stack.pop()
+        value = self.stack.pop()
+        if isinstance(value, ConstantVariable) and isinstance(
+            raw_spec, ConstantVariable
+        ):
+            spec = raw_spec.get_py_value()
+            result = value.get_py_value()
+            result = format(result, spec)
+            if result is None:
+                raise InnerError(
+                    f"The format operation failed in {instr.opname}"
+                )
+            self.stack.push(
+                ConstantVariable(
+                    result, self._graph, DummyTracker([raw_spec, value])
+                )
+            )
+        else:
+            raise FallbackError(
+                f"Do not support format {type(value)} or {type(spec)} in {instr.opname} now"
+            )
+
     def FORMAT_SIMPLE(self, instr: Instruction):
         value = self.stack.pop()
 
diff --git a/test/sot/test_09_f_string.py b/test/sot/test_09_f_string.py
@@ -32,10 +32,33 @@ def foo(x: paddle.Tensor):
     return x
 
 
+def fstring_with_convert_test(x: paddle.Tensor):
+    obj = 42
+    formatted_string = f"{obj!r}"
+    z = assert_true(formatted_string == "42")
+    x = x + 1
+    return x
+
+
+def fstring_with_spec(x: paddle.Tensor):
+    int_num = 42
+    float_num = 3.1415
+    formatted_string = f"{int_num} and {float_num:.2f}"
+    z = assert_true(formatted_string == "42 and 3.14")
+    x = x + 1
+    return x
+
+
 class TestFString(TestCaseBase):
-    def test_fstring(self):
+    def test_f_string(self):
         self.assert_results(foo, paddle.to_tensor(1))
 
+    def test_f_string_with_spec(self):
+        self.assert_results(fstring_with_spec, paddle.to_tensor(1))
+
+    def test_f_string_with_convert_test(self):
+        self.assert_results(fstring_with_convert_test, paddle.to_tensor(1))
+
 
 if __name__ == "__main__":
     unittest.main()
