clang format.

src/targets/gpu/lowering.cpp

@@ -47,8 +47,7 @@ struct miopen_apply
 {
     program* prog = nullptr;
     context ctx{};
-    std::unordered_map<std::string, std::function<instruction_ref(instruction_ref)>>
-        apply_map{};
+    std::unordered_map<std::string, std::function<instruction_ref(instruction_ref)>> apply_map{};
 
     void check_shape(shape x, instruction_ref i)
     {
@@ -115,7 +114,8 @@ struct miopen_apply
         }
     }
 
-    void add_convolution_op() {
+    void add_convolution_op()
+    {
         apply_map.emplace("convolution", [=](instruction_ref ins) {
             auto&& op = any_cast<op::convolution>(ins->get_operator());
 
@@ -130,7 +130,8 @@ struct miopen_apply
         });
     }
 
-    void add_pooling_op() {
+    void add_pooling_op()
+    {
         apply_map.emplace("pooling", [=](instruction_ref ins) {
             auto&& op   = any_cast<op::pooling>(ins->get_operator());
             auto pd     = make_pooling(op);
@@ -141,7 +142,7 @@ struct miopen_apply
         });
     }
 
-    template<class T>
+    template <class T>
     void add_generic_op(std::string name, T x)
     {
         apply_map.emplace(name, [=](instruction_ref ins) {
@@ -154,7 +155,7 @@ struct miopen_apply
         (void)x;
     }
 
-    template<class T, class Op>
+    template <class T, class Op>
     void add_extend_op(std::string name, T x, Op o)
     {
         apply_map.emplace(name, [=](instruction_ref ins) {
@@ -169,34 +170,35 @@ struct miopen_apply
         (void)o;
     }
 
-    template<class T, class Op, class F>
-    void add_miopen_extend_op(std::string name, T x, Op o, F f) {
+    template <class T, class Op, class F>
+    void add_miopen_extend_op(std::string name, T x, Op o, F f)
+    {
         apply_map.emplace(name, [=](instruction_ref ins) {
             auto&& op = any_cast<Op>(ins->get_operator());
             auto ad   = f(op.alpha);
 
             auto output = insert_allocation(ins, ins->get_shape());
-            return prog->replace_instruction(
-                ins, T{std::move(ad)}, ins->inputs().at(0), output);
+            return prog->replace_instruction(ins, T{std::move(ad)}, ins->inputs().at(0), output);
         });
         (void)x;
         (void)o;
         (void)f;
     }
 
-    template<class T, class F>
-    void add_miopen_simple_op(std::string name, T x, F f) {
+    template <class T, class F>
+    void add_miopen_simple_op(std::string name, T x, F f)
+    {
         apply_map.emplace(name, [=](instruction_ref ins) {
             auto ad     = f();
             auto output = insert_allocation(ins, ins->get_shape());
-            return prog->replace_instruction(
-                ins, T{std::move(ad)}, ins->inputs().at(0), output);
+            return prog->replace_instruction(ins, T{std::move(ad)}, ins->inputs().at(0), output);
         });
         (void)x;
         (void)f;
     }
 
-    void add_batch_norm_inference_op() {
+    void add_batch_norm_inference_op()
+    {
         apply_map.emplace("batch_norm_inference", [=](instruction_ref ins) {
             auto&& op       = any_cast<op::batch_norm_inference>(ins->get_operator());
             auto output     = insert_allocation(ins, ins->get_shape());