[PIR]Add old ir guard for old ir test (#63376)

YuanRisheng · web-flow · commit 54996da651be · 2024-04-11T10:51:53.000+08:00
* Add old ir guard for old ir test

* fix unittest
diff --git a/paddle/fluid/pybind/pir.cc b/paddle/fluid/pybind/pir.cc
@@ -300,6 +300,15 @@ void BindProgram(py::module *m) {
           [](std::shared_ptr<Program> self, int64_t random_seed) {
             SetProgramInt64Attr(self, "random_seed", random_seed);
           })
+      .def_property_readonly(
+          "blocks",
+          [](const std::shared_ptr<Program> &self) {
+            // Note: We only return global block currently.
+            py::list op_list;
+            op_list.append(self->block());
+            return op_list;
+          },
+          return_value_policy::reference)
       .def("get_output_value_by_name",
            [](Program &self, const std::string &name) {
              return GetOutputValueByName(self, name);
diff --git a/python/paddle/pir_utils.py b/python/paddle/pir_utils.py
@@ -130,7 +130,8 @@ def __exit__(self, exc_type, exc_val, exc_tb):
 def test_with_pir_api(func):
     @wraps(func)
     def impl(*args, **kwargs):
-        func(*args, **kwargs)
+        with OldIrGuard():
+            func(*args, **kwargs)
         with IrGuard():
             func(*args, **kwargs)
 
diff --git a/python/paddle/tensor/creation.py b/python/paddle/tensor/creation.py
@@ -2738,6 +2738,15 @@ def tril_indices(row, col, offset=0, dtype='int64'):
     if not isinstance(dtype, core.VarDesc.VarType):
         dtype = convert_np_dtype_to_dtype_(dtype)
 
+    if not isinstance(row, int) or row < 0:
+        raise TypeError("row should be a non-negative int")
+
+    if col is not None:
+        if not isinstance(col, int) or col < 0:
+            raise TypeError("col should be a non-negative int")
+    else:
+        col = row
+
     if in_dynamic_or_pir_mode():
         if col is None:
             col = row
@@ -2746,15 +2755,6 @@ def tril_indices(row, col, offset=0, dtype='int64'):
         )
         return out
     else:
-        if not isinstance(row, int) or row < 0:
-            raise TypeError("row should be a non-negative int")
-
-        if col is not None:
-            if not isinstance(col, int) or col < 0:
-                raise TypeError("col should be a non-negative int")
-        else:
-            col = row
-
         if not isinstance(offset, int):
             raise TypeError("offset should be a  int")
 
@@ -2817,6 +2817,15 @@ def triu_indices(row, col=None, offset=0, dtype='int64'):
     if not isinstance(dtype, core.VarDesc.VarType):
         dtype = convert_np_dtype_to_dtype_(dtype)
 
+    if not isinstance(row, int) or row < 0:
+        raise TypeError("row should be a non-negative int")
+
+    if col is not None:
+        if not isinstance(col, int) or col < 0:
+            raise TypeError("col should be a non-negative int")
+    else:
+        col = row
+
     if in_dynamic_or_pir_mode():
         if col is None:
             col = row
@@ -2825,15 +2834,6 @@ def triu_indices(row, col=None, offset=0, dtype='int64'):
         )
         return out
     else:
-        if not isinstance(row, int) or row < 0:
-            raise TypeError("row should be a non-negative int")
-
-        if col is not None:
-            if not isinstance(col, int) or col < 0:
-                raise TypeError("col should be a non-negative int")
-        else:
-            col = row
-
         if not isinstance(offset, int):
             raise TypeError("offset should be a int")
 
diff --git a/test/ir/pir/test_ir_pybind.py b/test/ir/pir/test_ir_pybind.py
@@ -48,6 +48,8 @@ def test_program(self):
 
         self.assertEqual(pir_program, program)
 
+        self.assertEqual(len(pir_program.blocks), 1)
+
     def test_block(self):
         pir_program = get_ir_program()
         block = pir_program.global_block()
diff --git a/test/legacy_test/op_test.py b/test/legacy_test/op_test.py
@@ -2568,11 +2568,12 @@ def _is_skip_name(self, name):
                 )
 
         if check_prim:
-            prim_checker = PrimForwardChecker(self, place)
-            prim_checker.check()
-            # Support operators which are not in the NO_FP64_CHECK_GRAD_OP_LIST list can be test prim with fp32
-            self.__class__.check_prim = True
-            self.__class__.op_type = self.op_type
+            with paddle.pir_utils.OldIrGuard():
+                prim_checker = PrimForwardChecker(self, place)
+                prim_checker.check()
+                # Support operators which are not in the NO_FP64_CHECK_GRAD_OP_LIST list can be test prim with fp32
+                self.__class__.check_prim = True
+                self.__class__.op_type = self.op_type
 
         if check_prim_pir:
             with paddle.pir_utils.IrGuard():
diff --git a/test/legacy_test/test_inner.py b/test/legacy_test/test_inner.py
@@ -152,27 +152,27 @@ def test_errors_dynamic_case1(self):
         y_data = np.random.rand(10, 2)
         x = paddle.to_tensor(x_data)
         y = paddle.to_tensor(y_data)
-        self.assertRaises(ValueError, paddle.inner, x, y)
+        self.assertRaises(Exception, paddle.inner, x, y)
 
     def test_errors_dynamic_case2(self):
         # test dynamic computation graph: dtype must be Tensor type
         x_data = np.random.randn(200).astype(np.float64)
         y_data = np.random.randn(200).astype(np.float64)
         y = paddle.to_tensor(y_data)
-        self.assertRaises(TypeError, paddle.inner, x_data, y)
+        self.assertRaises(Exception, paddle.inner, x_data, y)
 
     def test_errors_dynamic_case3(self):
         # test dynamic computation graph: dtype must be Tensor type
         x_data = np.random.randn(200).astype(np.float64)
         y_data = np.random.randn(200).astype(np.float64)
         x = paddle.to_tensor(x_data)
-        self.assertRaises(TypeError, paddle.inner, x, y_data)
+        self.assertRaises(Exception, paddle.inner, x, y_data)
 
     def test_errors_dynamic_case4(self):
         # test dynamic computation graph: dtype must be Tensor type
         x_data = np.random.randn(200).astype(np.float32)
         y_data = np.random.randn(200).astype(np.float32)
-        self.assertRaises(TypeError, paddle.inner, x_data, y_data)
+        self.assertRaises(Exception, paddle.inner, x_data, y_data)
 
 
 if __name__ == '__main__':
diff --git a/test/legacy_test/test_logcumsumexp_op.py b/test/legacy_test/test_logcumsumexp_op.py
@@ -200,10 +200,12 @@ def test_gpu(self):
         self.run_static(use_gpu=True)
 
     def test_name(self):
+        paddle.enable_static()
         with base.program_guard(base.Program()):
             x = paddle.static.data('x', [3, 4])
             y = paddle.logcumsumexp(x, name='out')
             self.assertTrue('out' in y.name)
+        paddle.disable_static()
 
     @test_with_pir_api
     def test_type_error(self):
diff --git a/test/legacy_test/test_outer.py b/test/legacy_test/test_outer.py
@@ -160,18 +160,18 @@ def test_errors_dynamic(self):
         x_data = np.random.randn(200).astype(np.float64)
         y_data = np.random.randn(200).astype(np.float64)
         y = paddle.to_tensor(y_data)
-        self.assertRaises(TypeError, paddle.outer, x_data, y)
+        self.assertRaises(Exception, paddle.outer, x_data, y)
 
         # test dynamic computation graph: dtype must be Tensor type
         x_data = np.random.randn(200).astype(np.float32)
         y_data = np.random.randn(200).astype(np.float32)
         x = paddle.to_tensor(x_data)
-        self.assertRaises(TypeError, paddle.outer, x, y_data)
+        self.assertRaises(Exception, paddle.outer, x, y_data)
 
         # test dynamic computation graph: dtype must be Tensor type
         x_data = np.random.randn(200).astype(np.float32)
         y_data = np.random.randn(200).astype(np.float32)
-        self.assertRaises(TypeError, paddle.outer, x_data, y_data)
+        self.assertRaises(Exception, paddle.outer, x_data, y_data)
 
 
 if __name__ == '__main__':
