clang format

src/include/migraphx/op/broadcast.hpp

@@ -43,9 +43,8 @@ struct broadcast
 
         std::vector<size_t> bcast_strides(broadcast_lens.size(), 0);
 
-        if(std::all_of(broadcast_lens.cbegin(), broadcast_lens.cend(), [&](auto x) {
-               return x == 1;
-           }))
+        if(std::all_of(
+               broadcast_lens.cbegin(), broadcast_lens.cend(), [&](auto x) { return x == 1; }))
         {
             if(axis != 0)
                 MIGRAPHX_THROW("when broadcasting tensor of size 1, axis should be 0");
@@ -54,8 +53,7 @@ struct broadcast
         else
         {
             assert(broadcast_lens.size() - axis >= input.lens().size());
-            if(!std::equal(
-                   input.lens().begin(), input.lens().end(), broadcast_lens.begin() + axis))
+            if(!std::equal(input.lens().begin(), input.lens().end(), broadcast_lens.begin() + axis))
                 MIGRAPHX_THROW("when broadcasting success sizes must match");
             std::copy(input.strides().begin(), input.strides().end(), bcast_strides.begin() + axis);
             return {t, broadcast_lens, std::move(bcast_strides)};

src/onnx/onnx.cpp

@@ -141,8 +141,8 @@ struct onnx_parser
                 if(broadcasted != 0)
                 {
                     uint64_t axis = parse_value(attributes.at("axis")).at<uint64_t>();
-                    auto l =
-                        prog.add_instruction(op::broadcast{axis, args[0]->get_shape().lens()}, args[1]);
+                    auto l = prog.add_instruction(op::broadcast{axis, args[0]->get_shape().lens()},
+                                                  args[1]);
                     return prog.add_instruction(x, args[0], l);
                 }
                 return prog.add_instruction(x, args);
@@ -306,7 +306,7 @@ struct onnx_parser
         {
             uint64_t axis = 1;
             auto l1       = prog.add_instruction(op, args[0], args[1]);
-            auto l2       = prog.add_instruction(op::broadcast{axis, l1->get_shape().lens()}, args[2]);
+            auto l2 = prog.add_instruction(op::broadcast{axis, l1->get_shape().lens()}, args[2]);
             return prog.add_instruction(op::add{}, l1, l2);
         }
         return prog.add_instruction(op, l0, args[1]);
@@ -679,7 +679,8 @@ struct onnx_parser
 
         auto scale_tensor = prog.add_instruction(migraphx::op::scalar{input_shape}, scale_val);
         auto img_scaled   = prog.add_instruction(migraphx::op::mul{}, args.front(), scale_tensor);
-        auto bias_bcast = prog.add_instruction(migraphx::op::broadcast{1, input_shape.lens()}, bias_vals);
+        auto bias_bcast =
+            prog.add_instruction(migraphx::op::broadcast{1, input_shape.lens()}, bias_vals);
         return prog.add_instruction(migraphx::op::add{}, img_scaled, bias_bcast);
     }
 

src/rewrite_rnn.cpp

@@ -521,11 +521,11 @@ std::vector<instruction_ref> rewrite_rnn::gru_cell(bool is_forward,
     if(bias != prog.end())
     {
         auto broadcast_lens = sih->get_shape().lens();
-        auto sbias = prog.insert_instruction(ins, op::squeeze{{0}}, bias);
-        auto wbz   = prog.insert_instruction(ins, op::slice{{0}, {0}, {hs}}, sbias);
-        auto wbr   = prog.insert_instruction(ins, op::slice{{0}, {hs}, {2 * hs}}, sbias);
-        auto wbh   = prog.insert_instruction(ins, op::slice{{0}, {2 * hs}, {3 * hs}}, sbias);
-        brcst_wbh  = prog.insert_instruction(ins, op::broadcast{1, broadcast_lens}, wbh);
+        auto sbias          = prog.insert_instruction(ins, op::squeeze{{0}}, bias);
+        auto wbz            = prog.insert_instruction(ins, op::slice{{0}, {0}, {hs}}, sbias);
+        auto wbr            = prog.insert_instruction(ins, op::slice{{0}, {hs}, {2 * hs}}, sbias);
+        auto wbh  = prog.insert_instruction(ins, op::slice{{0}, {2 * hs}, {3 * hs}}, sbias);
+        brcst_wbh = prog.insert_instruction(ins, op::broadcast{1, broadcast_lens}, wbh);
 
         auto rbz  = prog.insert_instruction(ins, op::slice{{0}, {3 * hs}, {4 * hs}}, sbias);
         auto rbr  = prog.insert_instruction(ins, op::slice{{0}, {4 * hs}, {5 * hs}}, sbias);
@@ -946,7 +946,7 @@ std::vector<instruction_ref> rewrite_rnn::lstm_cell(bool is_forward,
     auto sih = prog.insert_instruction(ins, op::squeeze{{0}}, ih);
 
     // initial cell state
-    auto sic      = prog.insert_instruction(ins, op::squeeze{{0}}, ic);
+    auto sic     = prog.insert_instruction(ins, op::squeeze{{0}}, ic);
     auto ic_lens = sic->get_shape().lens();
 
     // bias

src/tf/tf.cpp

@@ -235,7 +235,7 @@ struct tf_parser
     parse_biasadd(const std::string&, const attribute_map&, std::vector<instruction_ref> args)
     {
         uint64_t axis = 1; // assume output of previous layer is in NCHW (broadcast on channel)
-        auto l0       = prog.add_instruction(op::broadcast{axis, args[0]->get_shape().lens()}, args[1]);
+        auto l0 = prog.add_instruction(op::broadcast{axis, args[0]->get_shape().lens()}, args[1]);
         return prog.add_instruction(op::add{}, args[0], l0);
     }
 

test/cpu_ops_test.cpp

@@ -671,7 +671,7 @@ TEST_CASE(add_broadcast_test)
         uint64_t axis = 0;
         auto l1       = p.add_literal(migraphx::literal{a_shape, a_data});
         auto l2       = p.add_literal(migraphx::literal{b_shape, b_data});
-        auto l3       = p.add_instruction(migraphx::op::broadcast{axis, l1->get_shape().lens()}, l2);
+        auto l3 = p.add_instruction(migraphx::op::broadcast{axis, l1->get_shape().lens()}, l2);
         p.add_instruction(migraphx::op::add{}, l1, l3);
         p.compile(migraphx::cpu::target{});
         auto result = p.eval({});