Formatting

src/schedule.cpp

@@ -15,24 +15,25 @@ void schedule::apply(program& p) const
     std::unordered_map<instruction_ref, std::size_t> weights;
     auto last = std::prev(p.end());
     fix<std::size_t>([&](auto self, auto ins) -> std::size_t {
-        if (weights.count(ins) == 0) 
+        if(weights.count(ins) == 0)
         {
-            weights[ins] = std::accumulate(ins->inputs().begin(), ins->inputs().end(), model.weight(ins->get_operator()), [&](std::size_t w, instruction_ref i) {
-                return w + self(i);
-            });
+            weights[ins] =
+                std::accumulate(ins->inputs().begin(),
+                                ins->inputs().end(),
+                                model.weight(ins->get_operator()),
+                                [&](std::size_t w, instruction_ref i) { return w + self(i); });
         }
         return weights[ins];
     })(last);
 
     // Topo sort
     fix([&](auto self, auto ins) {
-        for(auto i:ins->inputs())
+        for(auto i : ins->inputs())
             p.move_instruction(i, p.begin());
-        for(auto i:ins->inputs())
+        for(auto i : ins->inputs())
             self(i);
     })(last);
 }
 
 } // namespace MIGRAPHX_INLINE_NS
 } // namespace migraphx
-

src/targets/gpu/include/migraphx/gpu/schedule_model.hpp

@@ -18,7 +18,10 @@ struct schedule_model
     std::size_t n = 4;
     std::size_t concurrency() const;
     void schedule_instruction(program& p, instruction_ref ins, std::size_t n) const;
-    void wait(program& p, instruction_ref ins, std::size_t wait_on, const std::vector<std::size_t>& wait_for) const;
+    void wait(program& p,
+              instruction_ref ins,
+              std::size_t wait_on,
+              const std::vector<std::size_t>& wait_for) const;
     std::size_t weight(const operation& op) const;
 };
 

src/targets/gpu/schedule_model.cpp

@@ -6,18 +6,15 @@ namespace migraphx {
 inline namespace MIGRAPHX_INLINE_NS {
 namespace gpu {
 
-std::size_t schedule_model::concurrency() const
+std::size_t schedule_model::concurrency() const { return n; }
+void schedule_model::schedule_instruction(program& p, instruction_ref ins, std::size_t n) const {}
+void schedule_model::wait(program& p,
+                          instruction_ref ins,
+                          std::size_t wait_on,
+                          const std::vector<std::size_t>& wait_for) const
 {
-    return n;
-}
-void schedule_model::schedule_instruction(program& p, instruction_ref ins, std::size_t n) const
-{}
-void schedule_model::wait(program& p, instruction_ref ins, std::size_t wait_on, const std::vector<std::size_t>& wait_for) const
-{}
-std::size_t schedule_model::weight(const operation& op) const
-{
-    return 1;
 }
+std::size_t schedule_model::weight(const operation& op) const { return 1; }
 
 } // namespace gpu
 } // namespace MIGRAPHX_INLINE_NS

tools/include/schedule_model.hpp

@@ -27,8 +27,11 @@ struct schedule_model
     std::size_t concurrency() const;
     /// Schedule a concurrent instruction
     void schedule_instruction(program& p, instruction_ref ins, std::size_t n) const;
-    // Insert necessary waits before an instruction 
-    void wait(program& p, instruction_ref ins, std::size_t wait_on, const std::vector<std::size_t>& wait_for) const;
+    // Insert necessary waits before an instruction
+    void wait(program& p,
+              instruction_ref ins,
+              std::size_t wait_on,
+              const std::vector<std::size_t>& wait_for) const;
     /// Compute weights for an operation
     std::size_t weight(const operation& op) const;
 };