graph: backend: dnnl: fix code format

Author: ElaineBao

src/graph/backend/dnnl/executables/sdpa.cpp

@@ -404,7 +404,8 @@ sdpa_bwd_executable_t::sdpa_bwd_executable_t(std::shared_ptr<op_t> &op,
     status_t s = create_sdpa_pd(hint_fwd_pd, p_engine.get(), md_q.get(),
             md_k.get(), md_v.get(), md_dst.get(), md_attn_mask.get(),
             md_scale.get(), is_invert_scale_, kv_head_number, mask_type_,
-            softmax_alg, impl::prop_kind::forward_training, attr.get(), qk_attr.get(), vs_attr.get());
+            softmax_alg, impl::prop_kind::forward_training, attr.get(),
+            qk_attr.get(), vs_attr.get());
     if (s != dnnl::impl::status::success) {
         is_initialized_ = false;
         return;
@@ -423,7 +424,6 @@ sdpa_bwd_executable_t::sdpa_bwd_executable_t(std::shared_ptr<op_t> &op,
         s = sdpa_bwd_pd_->create_primitive(sdpa_bwd_prim_, p_engine.get());
         is_initialized_ = s == status::success;
     }
-
 }
 
 void sdpa_bwd_executable_t::execute(const stream &stream,
@@ -466,8 +466,7 @@ void sdpa_bwd_executable_t::execute(const stream &stream,
     // Set up scratchpad grantor required by the primitive's execute
     const memory_storage_t *mem_storage = nullptr;
     memory_t *scratchpad_memory = ctx.output(DNNL_ARG_SCRATCHPAD);
-    if (scratchpad_memory)
-        mem_storage = scratchpad_memory->memory_storage();
+    if (scratchpad_memory) mem_storage = scratchpad_memory->memory_storage();
     const void *host_ptr
             = ctx.host_ptr(mem_storage, /* require_host_ptr = */ true);
     auto *scratchpad_grantor

src/graph/backend/dnnl/kernels/sdp_bwd_primitive.cpp

@@ -51,8 +51,7 @@ status_t sdp_bwd_primitive_kernel_t::initial_check(
         const std::vector<logical_tensor_t> &inputs,
         const std::vector<logical_tensor_t> &outputs) {
     const bool is_f32 = inputs[0].data_type == data_type::f32;
-    VCHECK_SDP_BWD_PRIMITIVE(!is_f32,
-            status::unimplemented,
+    VCHECK_SDP_BWD_PRIMITIVE(!is_f32, status::unimplemented,
             "SDPA bwd primitive doesn't support f32 because of performance");
 
     bool has_dropout = false;
@@ -63,8 +62,7 @@ status_t sdp_bwd_primitive_kernel_t::initial_check(
             break;
         }
     }
-    VCHECK_SDP_BWD_PRIMITIVE(!has_dropout,
-            status::unimplemented,
+    VCHECK_SDP_BWD_PRIMITIVE(!has_dropout, status::unimplemented,
             "SDPA bwd primitive doesn't support Dropout for now");
 
     bool has_host_scalar = false;
@@ -74,8 +72,7 @@ status_t sdp_bwd_primitive_kernel_t::initial_check(
             break;
         }
     }
-    VCHECK_SDP_BWD_PRIMITIVE(!has_host_scalar,
-            status::unimplemented,
+    VCHECK_SDP_BWD_PRIMITIVE(!has_host_scalar, status::unimplemented,
             "SDPA bwd primitive doesn't support host scalar inputs for now");
 
     return status::success;

src/graph/backend/dnnl/kernels/sdp_primitive_config.cpp

@@ -56,8 +56,8 @@ status_t sdp_primitive_config_t::initial_check(
                         && opk != graph::op_kind::Quantize,
                 status::unimplemented, "Not support quantized SDPA");
         // SDPA with Dropout is currently unsupported in the ukernel.
-        VCHECK_SDP_PRIMITIVE(opk != graph::op_kind::Dropout, status::unimplemented,
-                "Not support SDPA with Dropout");
+        VCHECK_SDP_PRIMITIVE(opk != graph::op_kind::Dropout,
+                status::unimplemented, "Not support SDPA with Dropout");
         if (opk == graph::op_kind::GenIndex) { has_genindex = true; }
     }
 

src/graph/backend/dnnl/layout_propagator.cpp

@@ -1836,8 +1836,7 @@ status_t layout_propagator_for_sdpa_bwd(std::shared_ptr<op_t> &op,
     // forward input logical tensor. If the input layout is already fixed, reuse
     // it; otherwise fall back to the canonical acbd format used by sdpa.
     auto get_md_for_diff = [](const logical_tensor_t &lt) {
-        if (!ltw(lt).is_any())
-            return make_dnnl_memory_desc(lt);
+        if (!ltw(lt).is_any()) return make_dnnl_memory_desc(lt);
         return dnnl::memory::desc {ltw(lt).vdims(),
                 static_cast<dnnl::memory::data_type>(ltw(lt).data_type()),
                 dnnl::memory::format_tag::acbd};
@@ -1872,12 +1871,10 @@ status_t layout_propagator_for_sdpa_bwd(std::shared_ptr<op_t> &op,
         const bool with_scale = op->get_attr<bool>(op_attr::with_scale);
         const auto mask_type = static_cast<attn_mask_type_t>(
                 op->get_attr<int64_t>(op_attr::mask_type));
-        const bool is_invert_scale
-                = op->has_attr(op_attr::is_invert_scale)
+        const bool is_invert_scale = op->has_attr(op_attr::is_invert_scale)
                 ? op->get_attr<bool>(op_attr::is_invert_scale)
                 : false;
-        const bool with_explicit_mask
-                = mask_type == attn_mask_type::buffer;
+        const bool with_explicit_mask = mask_type == attn_mask_type::buffer;
 
         auto md_q = make_dnnl_memory_desc(op->get_input_logical_tensor(0));
         auto md_k = make_dnnl_memory_desc(op->get_input_logical_tensor(1));
@@ -1898,8 +1895,7 @@ status_t layout_propagator_for_sdpa_bwd(std::shared_ptr<op_t> &op,
             md_attn_mask = make_dnnl_memory_desc(
                     op->get_input_logical_tensor(idx++));
             if (op->num_outputs() > 4)
-                md_dS = make_dnnl_memory_desc(
-                        op->get_output_logical_tensor(4));
+                md_dS = make_dnnl_memory_desc(op->get_output_logical_tensor(4));
         }
 
         const auto &sdpa_fusion_info = op->has_attr(op_attr::fusion_info)
@@ -1917,18 +1913,17 @@ status_t layout_propagator_for_sdpa_bwd(std::shared_ptr<op_t> &op,
         vs_attr.set_accumulation_mode(str2accumulation_mode(
                 op->get_attr<std::string>(op_attr::vs_acc_mode)));
         attr.set_scratchpad_mode(dnnl::scratchpad_mode::user);
-        attr.set_fpmath_mode(
-                static_cast<dnnl::fpmath_mode>(fpmath.mode_));
+        attr.set_fpmath_mode(static_cast<dnnl::fpmath_mode>(fpmath.mode_));
 
         dim_t kv_head_number = op->get_input_logical_tensor(1).dims[1];
-        const alg_kind_t softmax_alg
-                = alg_kind::softmax_accurate_inf_as_zero;
+        const alg_kind_t softmax_alg = alg_kind::softmax_accurate_inf_as_zero;
 
         std::shared_ptr<primitive_desc_t> hint_fwd_pd;
         status = create_sdpa_pd(hint_fwd_pd, p_engine.get(), md_q.get(),
                 md_k.get(), md_v.get(), md_dst.get(), md_attn_mask.get(),
                 md_scale.get(), is_invert_scale, kv_head_number, mask_type,
-                softmax_alg, impl::prop_kind::forward_training, attr.get(), qk_attr.get(), vs_attr.get());
+                softmax_alg, impl::prop_kind::forward_training, attr.get(),
+                qk_attr.get(), vs_attr.get());
         VCHECK_LAYOUT_PROPAGATOR(status == status::success, status,
                 "failed to create hint fwd pd for sdpa_bwd scratchpad");
 
@@ -1938,8 +1933,7 @@ status_t layout_propagator_for_sdpa_bwd(std::shared_ptr<op_t> &op,
                 md_diff_k.get(), md_diff_v.get(), md_diff_dst.get(),
                 md_dS.get(), md_attn_mask.get(), md_scale.get(),
                 is_invert_scale, kv_head_number, mask_type, softmax_alg,
-                attr.get(), hint_fwd_pd.get(), qk_attr.get(),
-                vs_attr.get());
+                attr.get(), hint_fwd_pd.get(), qk_attr.get(), vs_attr.get());
         VCHECK_LAYOUT_PROPAGATOR(status == status::success, status,
                 "failed to create pd for sdpa_bwd scratchpad");
 

src/graph/backend/dnnl/passes/compile_ops.cpp

@@ -69,7 +69,7 @@ status_t compile_ops(std::shared_ptr<subgraph_t> &sg) {
                     "failed to create executable for op %s",
                     op->get_name().c_str());
         }
-        
+
         sg->execs_.emplace_back(exec);
 
         sg->is_constant_.push_back(op->has_attr(op_attr::is_constant)

src/graph/backend/dnnl/passes/insert_ops.cpp

@@ -666,9 +666,8 @@ status_t insert_reshape_for_sdpa(std::shared_ptr<subgraph_t> &sg) {
         // Insert reshape for optional stats output (output 2)
         if (cur_op->get_attr<bool>(op_attr::is_training)) {
             auto stats_dims = ltw(cur_op->get_output_logical_tensor(2)).vdims();
-            dims expected_stats_dims = stats_dims;
-            op_ptr reshape_stats
-                    = std::make_shared<op_t>(op_kind::_reshape);
+            const dims &expected_stats_dims = stats_dims;
+            op_ptr reshape_stats = std::make_shared<op_t>(op_kind::_reshape);
             reshape_stats->set_attr<bool>(op_attr::special_zero, false);
             reshape_stats->set_attr<std::vector<int64_t>>(
                     op_attr::shape, expected_stats_dims);
@@ -728,8 +727,7 @@ status_t insert_reshape_for_sdpa_bwd(std::shared_ptr<subgraph_t> &sg) {
         size_t index = 6;
         // Insert reshape for scale (optional)
         if (cur_op->get_attr<bool>(op_attr::with_scale)) {
-            int32_t scale_ndims
-                    = cur_op->get_input_logical_tensor(index).ndims;
+            int32_t scale_ndims = cur_op->get_input_logical_tensor(index).ndims;
             if (scale_ndims == 5) {
                 auto scale_dims
                         = ltw(cur_op->get_input_logical_tensor(index)).vdims();
@@ -741,9 +739,8 @@ status_t insert_reshape_for_sdpa_bwd(std::shared_ptr<subgraph_t> &sg) {
         // Insert reshape for mask (optional)
         if (cur_op->get_attr<int64_t>(op_attr::mask_type)
                 == static_cast<int64_t>(attn_mask_type::buffer)) {
-            int32_t mask_ndims
-                    = cur_op->get_input_logical_tensor(index).ndims;
-             
+            int32_t mask_ndims = cur_op->get_input_logical_tensor(index).ndims;
+
             if (mask_ndims == 5) {
                 auto mask_dims
                         = ltw(cur_op->get_input_logical_tensor(index)).vdims();
@@ -753,10 +750,10 @@ status_t insert_reshape_for_sdpa_bwd(std::shared_ptr<subgraph_t> &sg) {
         }
 
         // Insert reshape for diff_query output (output 0) -> 4D to 5D
-        auto diff_query_dims = ltw(cur_op->get_output_logical_tensor(0)).vdims();
+        auto diff_query_dims
+                = ltw(cur_op->get_output_logical_tensor(0)).vdims();
         const dims &expected_diff_query_dims = diff_query_dims;
-        op_ptr reshape_diff_query
-                = std::make_shared<op_t>(op_kind::_reshape);
+        op_ptr reshape_diff_query = std::make_shared<op_t>(op_kind::_reshape);
         reshape_diff_query->set_attr<bool>(op_attr::special_zero, false);
         reshape_diff_query->set_attr<std::vector<int64_t>>(
                 op_attr::shape, expected_diff_query_dims);
@@ -772,26 +769,26 @@ status_t insert_reshape_for_sdpa_bwd(std::shared_ptr<subgraph_t> &sg) {
         rewriter.insert_op_after(reshape_diff_key, cur_op, 1);
 
         // Insert reshape for diff_value output (output 2) -> 4D to 5D
-        auto diff_value_dims = ltw(cur_op->get_output_logical_tensor(2)).vdims();
+        auto diff_value_dims
+                = ltw(cur_op->get_output_logical_tensor(2)).vdims();
         const dims &expected_diff_value_dims = diff_value_dims;
-        op_ptr reshape_diff_value
-                = std::make_shared<op_t>(op_kind::_reshape);
+        op_ptr reshape_diff_value = std::make_shared<op_t>(op_kind::_reshape);
         reshape_diff_value->set_attr<bool>(op_attr::special_zero, false);
         reshape_diff_value->set_attr<std::vector<int64_t>>(
                 op_attr::shape, expected_diff_value_dims);
         rewriter.insert_op_after(reshape_diff_value, cur_op, 2);
 
         // Insert reshape for diff_mask output (output 4) -> 4D to 5D
         if (cur_op->num_outputs() > 4) {
-                auto diff_mask_dims
-                        = ltw(cur_op->get_output_logical_tensor(4)).vdims();
-                const dims &expected_diff_mask_dims = diff_mask_dims;
-                op_ptr reshape_diff_mask
-                        = std::make_shared<op_t>(op_kind::_reshape);
-                reshape_diff_mask->set_attr<bool>(op_attr::special_zero, false);
-                reshape_diff_mask->set_attr<std::vector<int64_t>>(
-                        op_attr::shape, expected_diff_mask_dims);
-                rewriter.insert_op_after(reshape_diff_mask, cur_op, 4);
+            auto diff_mask_dims
+                    = ltw(cur_op->get_output_logical_tensor(4)).vdims();
+            const dims &expected_diff_mask_dims = diff_mask_dims;
+            op_ptr reshape_diff_mask
+                    = std::make_shared<op_t>(op_kind::_reshape);
+            reshape_diff_mask->set_attr<bool>(op_attr::special_zero, false);
+            reshape_diff_mask->set_attr<std::vector<int64_t>>(
+                    op_attr::shape, expected_diff_mask_dims);
+            rewriter.insert_op_after(reshape_diff_mask, cur_op, 4);
         }
     }