graph: interface: fpmath: construct fpmath_t explicitly

TaoLv · TaoLv · commit 2ee03b641c6b · 2025-03-12T23:38:10.000-07:00
diff --git a/src/graph/interface/graph_attr.hpp b/src/graph/interface/graph_attr.hpp
@@ -1,5 +1,5 @@
 /*******************************************************************************
-* Copyright 2024 Intel Corporation
+* Copyright 2024-2025 Intel Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -24,16 +24,16 @@ namespace impl {
 namespace graph {
 
 struct fpmath_t {
+    fpmath_t() = default;
 
-    fpmath_t(dnnl_fpmath_mode_t mode = fpmath_mode::strict,
-            bool apply_to_int = false)
+    fpmath_t(fpmath_mode_t mode, bool apply_to_int)
         : mode_(mode), apply_to_int_(apply_to_int) {}
 
     bool operator==(const fpmath_t &rhs) const {
         return mode_ == rhs.mode_ && apply_to_int_ == rhs.apply_to_int_;
     }
 
-    graph::fpmath_mode_t mode_;
+    fpmath_mode_t mode_ = fpmath_mode::strict;
     bool apply_to_int_ = false;
 };
 
diff --git a/tests/gtests/graph/unit/backend/dnnl/test_compiled_partition.cpp b/tests/gtests/graph/unit/backend/dnnl/test_compiled_partition.cpp
@@ -309,9 +309,9 @@ TEST(test_compiled_partition, GetAndInfoMethod) {
             graph::dnnl_impl::dnnl_compiled_partition_impl_t>(
             engine, inputs, outputs, kernel);
     graph::partition_t par;
+    const graph::fpmath_t fpm {graph::fpmath_mode::strict, false};
     auto par_impl = std::make_shared<graph::dnnl_impl::dnnl_partition_impl_t>(
-            engine.kind(), graph::fpmath_mode::strict,
-            graph::partition_kind_t::undef);
+            engine.kind(), fpm, graph::partition_kind_t::undef);
     par.init(par_impl);
     graph::compiled_partition_t cp(par);
     cp.init(cp_impl);
diff --git a/tests/gtests/graph/unit/backend/dnnl/test_layout_propagator_cpu.cpp b/tests/gtests/graph/unit/backend/dnnl/test_layout_propagator_cpu.cpp
@@ -1,5 +1,5 @@
 /*******************************************************************************
-* Copyright 2022-2024 Intel Corporation
+* Copyright 2022-2025 Intel Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -45,9 +45,10 @@ TEST(test_layout_propagator, LayoutPropagatorForPermute) {
     dnnl::engine p_engine = dnnl_impl::make_dnnl_engine(eng);
     dnnl_impl::fusion_info_mgr_t mgr;
     dnnl_impl::pd_cache_t pd_cache;
+    const graph::fpmath_t fpm {graph::fpmath_mode::any, false};
     auto sg = std::make_shared<dnnl_impl::subgraph_t>(
-            std::vector<std::shared_ptr<graph::op_t>> {op}, p_engine,
-            graph::fpmath_mode::any, false, false);
+            std::vector<std::shared_ptr<graph::op_t>> {op}, p_engine, fpm,
+            false, false);
     dnnl_impl::subgraph_rewriter_t rewriter {sg};
     ASSERT_EQ(dnnl_impl::layout_propagator_for_permute(
                       op, p_engine, mgr, pd_cache, rewriter),
@@ -69,9 +70,10 @@ TEST(test_layout_propagator, LayoutPropagatorForReorder) {
     dnnl::engine p_engine = dnnl_impl::make_dnnl_engine(eng);
     dnnl_impl::fusion_info_mgr_t mgr;
     dnnl_impl::pd_cache_t pd_cache;
+    const graph::fpmath_t fpm {graph::fpmath_mode::any, false};
     auto sg = std::make_shared<dnnl_impl::subgraph_t>(
-            std::vector<std::shared_ptr<graph::op_t>> {op}, p_engine,
-            graph::fpmath_mode::any, false, false);
+            std::vector<std::shared_ptr<graph::op_t>> {op}, p_engine, fpm,
+            false, false);
     dnnl_impl::subgraph_rewriter_t rewriter {sg};
     ASSERT_EQ(layout_propagator_for_reorder(
                       op, p_engine, mgr, pd_cache, rewriter),
@@ -91,9 +93,10 @@ TEST(test_layout_propagator, LayoutPropagatorForSumDeathTest) {
 
     op->add_input(lt_in);
     op->add_output(lt_out);
+    const graph::fpmath_t fpm {graph::fpmath_mode::any, false};
     auto sg = std::make_shared<dnnl_impl::subgraph_t>(
-            std::vector<std::shared_ptr<graph::op_t>> {op}, p_engine,
-            graph::fpmath_mode::any, false, false);
+            std::vector<std::shared_ptr<graph::op_t>> {op}, p_engine, fpm,
+            false, false);
     dnnl_impl::subgraph_rewriter_t rewriter {sg};
     ASSERT_EQ(layout_propagator_for_sum(op, p_engine, mgr, pd_cache, rewriter),
             graph::status::success);
@@ -126,9 +129,10 @@ TEST(test_layout_propagator, LayoutPropagatorForSubZpsDeathTest) {
     dnnl_impl::fusion_info_mgr_t mgr;
     dnnl_impl::pd_cache_t pd_cache;
     auto op = std::make_shared<graph::op_t>(0, graph::op_kind::Wildcard, "op");
+    const graph::fpmath_t fpm {graph::fpmath_mode::any, false};
     auto sg = std::make_shared<dnnl_impl::subgraph_t>(
-            std::vector<std::shared_ptr<graph::op_t>> {op}, p_engine,
-            graph::fpmath_mode::any, false, false);
+            std::vector<std::shared_ptr<graph::op_t>> {op}, p_engine, fpm,
+            false, false);
     dnnl_impl::subgraph_rewriter_t rewriter {sg};
 #ifndef NDEBUG
     EXPECT_DEATH(dnnl_impl::layout_propagator_for_sub_zps(
@@ -147,9 +151,10 @@ TEST(test_layout_propagator, LayoutPropagatorForAddZpsDeathTest) {
     dnnl_impl::fusion_info_mgr_t mgr;
     dnnl_impl::pd_cache_t pd_cache;
     auto op = std::make_shared<graph::op_t>(0, graph::op_kind::Wildcard, "op");
+    const graph::fpmath_t fpm {graph::fpmath_mode::any, false};
     auto sg = std::make_shared<dnnl_impl::subgraph_t>(
-            std::vector<std::shared_ptr<graph::op_t>> {op}, p_engine,
-            graph::fpmath_mode::any, false, false);
+            std::vector<std::shared_ptr<graph::op_t>> {op}, p_engine, fpm,
+            false, false);
     dnnl_impl::subgraph_rewriter_t rewriter {sg};
 #ifndef NDEBUG
     EXPECT_DEATH(dnnl_impl::layout_propagator_for_add_zps(
diff --git a/tests/gtests/graph/unit/backend/dnnl/test_partition_cpu.cpp b/tests/gtests/graph/unit/backend/dnnl/test_partition_cpu.cpp
@@ -1,5 +1,5 @@
 /*******************************************************************************
-* Copyright 2020-2024 Intel Corporation
+* Copyright 2020-2025 Intel Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -30,19 +30,21 @@ using namespace dnnl::impl::graph;
 using namespace dnnl::graph::tests::unit::utils;
 
 TEST(test_partition, CreateSimple) {
+    const graph::fpmath_t fpm {fpmath_mode::strict, false};
     dnnl::impl::graph::dnnl_impl::dnnl_partition_impl_t p(
-            engine_kind::cpu, fpmath_mode::strict, partition_kind_t::undef);
+            engine_kind::cpu, fpm, partition_kind_t::undef);
     ASSERT_EQ(p.get_ops().size(), 0U);
-    ASSERT_EQ(p.get_fpmath_mode(), fpmath_mode::strict);
+    ASSERT_EQ(p.get_fpmath_mode().mode_, fpmath_mode::strict);
     ASSERT_EQ(p.get_kind(), partition_kind_t::undef);
 }
 
 TEST(test_partition, AddOps) {
     std::vector<engine_kind_t> engine_kinds
             = {engine_kind::cpu, engine_kind::gpu};
+    const graph::fpmath_t fpm {fpmath_mode::strict, false};
     for (const auto &engine_kind : engine_kinds) {
         dnnl::impl::graph::dnnl_impl::dnnl_partition_impl_t p(
-                engine_kind, fpmath_mode::strict, partition_kind_t::undef);
+                engine_kind, fpm, partition_kind_t::undef);
         size_t id = 100;
         std::shared_ptr<op_t> n(new op_t(id, op_kind::Wildcard, "Wildcard"));
         p.add_op(n);
@@ -60,8 +62,9 @@ TEST(test_partition, AddOps) {
 }
 
 TEST(test_partition, GetOps) {
+    const graph::fpmath_t fpm {fpmath_mode::strict, false};
     dnnl::impl::graph::dnnl_impl::dnnl_partition_impl_t p(
-            engine_kind::cpu, fpmath_mode::strict, partition_kind_t::undef);
+            engine_kind::cpu, fpm, partition_kind_t::undef);
     size_t id = 100;
     std::shared_ptr<op_t> n(new op_t(id, op_kind::Wildcard, "Wildcard"));
     p.add_op(n);
@@ -73,9 +76,10 @@ TEST(test_partition, GetOps) {
 TEST(test_partition, Init) {
     std::vector<engine_kind_t> engine_kinds
             = {engine_kind::cpu, engine_kind::gpu};
+    const graph::fpmath_t fpm {fpmath_mode::strict, false};
     for (const auto &engine_kind : engine_kinds) {
         dnnl::impl::graph::dnnl_impl::dnnl_partition_impl_t p(
-                engine_kind, fpmath_mode::strict, partition_kind_t::undef);
+                engine_kind, fpm, partition_kind_t::undef);
         std::shared_ptr<op_t> n(new op_t(0, op_kind::Convolution, "Conv"));
         n->set_attr<int64_t>(op_attr::groups, 0);
         p.add_op(n);
@@ -87,9 +91,10 @@ TEST(test_partition, Init) {
 TEST(test_partition, Clone) {
     std::vector<engine_kind_t> engine_kinds
             = {engine_kind::cpu, engine_kind::gpu};
+    const graph::fpmath_t fpm {fpmath_mode::strict, false};
     for (const auto &engine_kind : engine_kinds) {
-        dnnl::impl::graph::dnnl_impl::dnnl_partition_impl_t p(engine_kind,
-                fpmath_mode::strict, partition_kind_t::convolution_post_ops);
+        dnnl::impl::graph::dnnl_impl::dnnl_partition_impl_t p(
+                engine_kind, fpm, partition_kind_t::convolution_post_ops);
         auto n = std::make_shared<op_t>(op_kind::Convolution);
         n->set_attr<int64_t>(op_attr::groups, 1);
 
@@ -120,11 +125,10 @@ TEST(test_partition_op, AssignedPartition) {
     op_t conv {0, op_kind::Convolution, std::string("convolution")};
 
     ASSERT_EQ(conv.get_partition(), nullptr);
-
+    const graph::fpmath_t fpm {fpmath_mode::strict, false};
     auto part = std::make_shared<
             dnnl::impl::graph::dnnl_impl::dnnl_partition_impl_t>(
-            engine_kind::cpu, fpmath_mode::strict,
-            partition_kind_t::convolution_post_ops);
+            engine_kind::cpu, fpm, partition_kind_t::convolution_post_ops);
     conv.set_partition(part.get());
     ASSERT_EQ(conv.get_partition(), part.get());
 }
@@ -133,9 +137,10 @@ TEST(test_partition, SetFpmathMode) {
     engine_t *eng = get_engine();
     for (auto m : {fpmath_mode::strict, fpmath_mode::bf16, fpmath_mode::f16,
                  fpmath_mode::any}) {
+        const graph::fpmath_t fpm {m, false};
         dnnl::impl::graph::dnnl_impl::dnnl_partition_impl_t p(
-                eng->kind(), m, partition_kind_t::undef);
-        ASSERT_EQ(p.get_fpmath_mode(), m);
+                eng->kind(), fpm, partition_kind_t::undef);
+        ASSERT_EQ(p.get_fpmath_mode().mode_, m);
     }
 }
 
@@ -154,11 +159,10 @@ TEST(test_partition, InferShape) {
 
         std::vector<const graph::logical_tensor_t *> inputs {&lt1, &lt2};
         std::vector<graph::logical_tensor_t *> outputs {&lt3};
-
+        const graph::fpmath_t fpm {fpmath_mode::strict, false};
         auto par = std::make_shared<
                 dnnl::impl::graph::dnnl_impl::dnnl_partition_impl_t>(
-                engine_kind, graph::fpmath_mode::strict,
-                graph::partition_kind_t::undef);
+                engine_kind, fpm, graph::partition_kind_t::undef);
         ASSERT_EQ(par->infer_shape(inputs, outputs), graph::status::success);
     }
 }
diff --git a/tests/gtests/graph/unit/backend/dnnl/test_subgraph_pass.cpp b/tests/gtests/graph/unit/backend/dnnl/test_subgraph_pass.cpp
diff --git a/tests/gtests/graph/unit/interface/test_graph_cpu.cpp b/tests/gtests/graph/unit/interface/test_graph_cpu.cpp
