Merge branch 'develop' into jit-concat-pointwise

src/include/migraphx/tune_axis.hpp

@@ -34,7 +34,7 @@ inline namespace MIGRAPHX_INLINE_NS {
 
 inline int tune_axis(const int n_dim, const int axis, const std::string& op_name = "OPERATOR")
 {
-    if(axis >= n_dim || std::abs(axis) > n_dim)
+    if(axis >= n_dim or std::abs(axis) > n_dim)
     {
         MIGRAPHX_THROW(to_upper(op_name) + ": axis is out of range.");
     }

src/instruction.cpp

@@ -176,13 +176,13 @@ bool operator==(const instruction& x, const instruction& y)
     return true;
 }
 
-bool operator!=(const instruction& x, const instruction& y) { return !(x == y); }
+bool operator!=(const instruction& x, const instruction& y) { return not(x == y); }
 
 bool operator==(instruction_ref ref, const instruction& i) { return i == ref; }
 
-bool operator!=(const instruction& i, instruction_ref ref) { return !(i == ref); }
+bool operator!=(const instruction& i, instruction_ref ref) { return not(i == ref); }
 
-bool operator!=(instruction_ref ref, const instruction& i) { return !(i == ref); }
+bool operator!=(instruction_ref ref, const instruction& i) { return not(i == ref); }
 
 void instruction::add_output(instruction_ref ins)
 {
@@ -361,7 +361,7 @@ void instruction::print(std::ostream& os,
             os << "{" << ins->get_literal() << "}";
     }
 
-    if(!ins->inputs().empty())
+    if(not ins->inputs().empty())
     {
         char delim = '(';
         for(auto&& arg : ins->inputs())
@@ -374,7 +374,7 @@ void instruction::print(std::ostream& os,
     }
 
     // print module inputs
-    if(!ins->module_inputs().empty())
+    if(not ins->module_inputs().empty())
     {
         std::string delim = ", [";
         for(auto&& mod_arg : ins->module_inputs())
@@ -446,7 +446,7 @@ operation instruction::normalized_operator() const
     if(this->need_normalization())
     {
         auto s = this->inputs().front()->get_shape();
-        if(!normalize_attributes(o, s.max_lens()))
+        if(not normalize_attributes(o, s.max_lens()))
             return this->get_operator();
     }
     return o;

src/module.cpp

@@ -141,12 +141,12 @@ void module::set_bypass(bool b) { impl->bypass = b; }
 void module::assign(const module& m)
 {
     // copy the impl
-    if(!impl)
+    if(not impl)
         impl = std::make_unique<module_impl>();
     *impl = *m.impl;
 
     // clear instructions
-    if(!impl->instructions.empty())
+    if(not impl->instructions.empty())
     {
         impl->clear();
     }
@@ -346,7 +346,7 @@ instruction_ref module::replace_instruction(instruction_ref ins, instruction_ref
         assert(out->valid(begin()));
     }
     // Replacement should not be dead code unless its the last instruction
-    assert(!rep->outputs().empty() or rep == std::prev(end()));
+    assert(not rep->outputs().empty() or rep == std::prev(end()));
     // Output of the original instruction should only be the replacement or empty
     assert(ins->outputs().empty() or std::all_of(ins->outputs().begin(),
                                                  ins->outputs().end(),
@@ -598,7 +598,7 @@ instruction_ref module::validate() const
             auto inputs      = i.inputs();
             bool check_order = std::all_of(
                 inputs.begin(), inputs.end(), [&](auto in) { return has_instruction(in); });
-            return !i.valid(impl->instructions.begin(), check_order);
+            return not i.valid(impl->instructions.begin(), check_order);
         });
 }
 
@@ -754,7 +754,7 @@ void module::print_graph(std::ostream& os, bool brief) const
             label = to_string(ins->get_operator());
         os << "\t" << enclose_name(ins_names.at(ins)) << "[label=" << enclose_name(label) << "]";
         os << ";" << std::endl;
-        if(!ins->inputs().empty())
+        if(not ins->inputs().empty())
         {
             for(auto&& arg : ins->inputs())
             {
@@ -908,7 +908,7 @@ module& module::sort()
         this->move_instruction(ins, this->begin());
         for(auto child : ins->inputs())
         {
-            if(!contains(this->impl->instructions, child))
+            if(not contains(this->impl->instructions, child))
             {
                 continue;
             }

src/normalize_attributes.cpp

@@ -79,14 +79,14 @@ auto tune_attribute(const std::vector<int64_t>& vec,
     {
         if(contains(vec_attrs, op::normalize_attribute::include_max))
         {
-            if(!std::equal(result.begin(), result.end(), max_vals.begin(), std::less_equal<>{}))
+            if(not std::equal(result.begin(), result.end(), max_vals.begin(), std::less_equal<>{}))
             {
                 MIGRAPHX_THROW("TUNE_VECTOR: value out of range!");
             }
         }
         else
         {
-            if(!std::equal(result.begin(), result.end(), max_vals.begin(), std::less<>{}))
+            if(not std::equal(result.begin(), result.end(), max_vals.begin(), std::less<>{}))
             {
                 MIGRAPHX_THROW("TUNE_VECTOR: value out of range!");
             }
@@ -118,14 +118,15 @@ auto tune_attribute(const std::vector<int64_t>& vec,
     {
         if(contains(vec_attrs, op::normalize_attribute::include_min))
         {
-            if(!std::equal(min_vals.begin(), min_vals.end(), result.begin(), std::less_equal<>{}))
+            if(not std::equal(
+                   min_vals.begin(), min_vals.end(), result.begin(), std::less_equal<>{}))
             {
                 MIGRAPHX_THROW("TUNE_VECTOR: attribute out of range!");
             }
         }
         else
         {
-            if(!std::equal(result.begin(), result.end(), min_vals.begin(), std::less<>{}))
+            if(not std::equal(result.begin(), result.end(), min_vals.begin(), std::less<>{}))
             {
                 MIGRAPHX_THROW("TUNE_VECTOR: attribute out of range!");
             }
@@ -174,7 +175,7 @@ bool normalize_attributes(operation& op, const std::vector<std::size_t>& lens)
             tuned = true;
         }
     }
-    if(!attrs.contains("normalize_axes"))
+    if(not attrs.contains("normalize_axes"))
     {
         return tuned;
     }

src/onnx/onnx_parser.cpp

@@ -187,7 +187,7 @@ operation onnx_parser::load(const std::string& name, const node_info& info) cons
 
 void onnx_parser::parse_undefined(module* mod, const std::string& name)
 {
-    if(!contains(instructions, name))
+    if(not contains(instructions, name))
     {
         auto ins           = mod->add_instruction(make_op("undefined"));
         instructions[name] = ins;
@@ -267,7 +267,7 @@ void onnx_parser::parse_graph(module* mod, const onnx::GraphProto& graph)
     {
         const std::string& name = input.name();
         // input not in initializer_data, so it is a real input
-        if(!contains(mod_insts, name))
+        if(not contains(mod_insts, name))
         {
             // ONNX specification does not specify how to deal with the
             // scenario that a nested subgraph contains a parameter with the
@@ -354,7 +354,7 @@ void onnx_parser::parse_graph(module* mod, const onnx::GraphProto& graph)
         all_output_names.begin(),
         all_output_names.end(),
         std::back_inserter(prog_output_names),
-        [&](const auto& name) { return !(name.empty() or instructions.count(name) == 0); });
+        [&](const auto& name) { return not(name.empty() or instructions.count(name) == 0); });
 
     std::vector<instruction_ref> output_ins;
     std::transform(prog_output_names.begin(),
@@ -444,7 +444,7 @@ shape onnx_parser::parse_type(const onnx::TypeProto& t,
                               const std::vector<std::size_t>& input_dims) const
 {
     shape::type_t shape_type = get_type(t.tensor_type().elem_type());
-    if(!input_dims.empty())
+    if(not input_dims.empty())
     {
         return {shape_type, input_dims};
     }
@@ -511,7 +511,7 @@ shape::type_t get_type(int dtype)
 bool is_type_float(shape::type_t dtype)
 {
     bool r = false;
-    if(dtype == shape::float_type || dtype == shape::double_type || dtype == shape::half_type)
+    if(dtype == shape::float_type or dtype == shape::double_type or dtype == shape::half_type)
     {
         r = true;
     }

src/onnx/padding.cpp

@@ -42,7 +42,7 @@ void cal_auto_padding_size(onnx_parser::node_info info,
     size_t kdims = in_lens.size() - 2;
     assert(k_lens.size() == kdims and dilation.size() == kdims);
 
-    if(!contains(info.attributes, "auto_pad"))
+    if(not contains(info.attributes, "auto_pad"))
     {
         return;
     }
@@ -124,7 +124,7 @@ void tune_padding_size(const value& v,
     }
 
     // if padding is symmetric, return directly
-    if(!is_asym_padding(padding))
+    if(not is_asym_padding(padding))
     {
         return;
     }

src/onnx/parse_cast.cpp

@@ -38,7 +38,7 @@ struct parse_cast : op_parser<parse_cast>
                           onnx_parser::node_info info,
                           const std::vector<instruction_ref>& args) const
     {
-        if(!contains(info.attributes, "to"))
+        if(not contains(info.attributes, "to"))
         {
             MIGRAPHX_THROW("PARSE_CAST: missing to type attribute!");
         }

src/onnx/parse_constant_fill.cpp

@@ -93,7 +93,7 @@ struct parse_constant_fill : op_parser<parse_constant_fill>
         }
         else if(input_as_shape == 0)
         {
-            if(!contains(info.attributes, "shape"))
+            if(not contains(info.attributes, "shape"))
             {
                 MIGRAPHX_THROW("ConstantFill: attribute output shape is needed");
             }

src/onnx/parse_gemm.cpp

@@ -94,7 +94,7 @@ struct parse_gemm : op_parser<parse_gemm>
                 out_lens.back() = l2->get_shape().lens().back();
                 auto l3         = args[2];
                 auto l3_lens    = l3->get_shape().lens();
-                if(!std::equal(out_lens.begin(), out_lens.end(), l3_lens.begin(), l3_lens.end()))
+                if(not std::equal(out_lens.begin(), out_lens.end(), l3_lens.begin(), l3_lens.end()))
                 {
                     l3 = info.add_instruction(make_op("multibroadcast", {{"out_lens", out_lens}}),
                                               args[2]);

src/onnx/parse_lpnormalization.cpp

@@ -31,7 +31,7 @@ namespace migraphx {
 inline namespace MIGRAPHX_INLINE_NS {
 namespace onnx {
 
-//!  Parser for LpNormalization ONNX operator.
+// Parser for LpNormalization ONNX operator.
 /*!
   Normalizes a tensor by the L1 or L2 norms along a given axis.
   Norms that evaluate to 0 are changed to 1 to prevent division by zero.

src/onnx/parse_matmul.cpp

@@ -67,7 +67,8 @@ struct parse_matmul : op_parser<parse_matmul>
 
         instruction_ref bl0 = l0;
         instruction_ref bl1 = l1;
-        if(!std::equal(l0_lens.rbegin() + 2, l0_lens.rend(), l1_lens.rbegin() + 2, l1_lens.rend()))
+        if(not std::equal(
+               l0_lens.rbegin() + 2, l0_lens.rend(), l1_lens.rbegin() + 2, l1_lens.rend()))
         {
             auto l0_it = l0_lens.begin() + l0_lens.size() - 2;
             std::vector<std::size_t> l0_broadcasted_lens(l0_lens.begin(), l0_it);

src/onnx/parse_mod.cpp

@@ -40,9 +40,9 @@ struct parse_mod : op_parser<parse_mod>
                           std::vector<instruction_ref> args) const
     {
         std::string mod = "mod";
-        if(is_type_float(args[0]->get_shape().type()) || is_type_float(args[1]->get_shape().type()))
+        if(is_type_float(args[0]->get_shape().type()) or is_type_float(args[1]->get_shape().type()))
         {
-            if(!contains(info.attributes, "fmod"))
+            if(not contains(info.attributes, "fmod"))
             {
                 MIGRAPHX_THROW("Mod operator with float args and fmod=0 invalid");
             }

src/onnx/parse_nonzero.cpp

@@ -37,7 +37,7 @@ static std::vector<std::size_t> nonzero_indices(const std::vector<T>& data)
     std::vector<std::size_t> indices;
     for(std::size_t i = 0; i < data.size(); ++i)
     {
-        if(!float_equal(data[i], 0))
+        if(not float_equal(data[i], 0))
             indices.push_back(i);
     }
 

src/onnx/parse_pad.cpp

@@ -160,7 +160,7 @@ struct parse_pad : op_parser<parse_pad>
         if(args.size() == 3)
         {
             auto val_ins = args.at(2);
-            if(!val_ins->can_eval())
+            if(not val_ins->can_eval())
             {
                 MIGRAPHX_THROW("PARSE_PAD: input value must be constant");
             }

src/onnx/parse_pooling.cpp

@@ -157,7 +157,7 @@ struct parse_pooling : op_parser<parse_pooling>
         std::vector<int64_t> slice_end;
         tune_padding_size(values, paddings, count_include_pad, slice_start);
 
-        if(!slice_start.empty())
+        if(not slice_start.empty())
         {
             // calculate expected output shape
             orig_padding.insert(orig_padding.begin() + kdims, 2, 0);
@@ -180,7 +180,7 @@ struct parse_pooling : op_parser<parse_pooling>
         op.from_value(values);
 
         auto l1 = info.add_instruction(op, l0);
-        if(!slice_start.empty())
+        if(not slice_start.empty())
         {
             std::vector<int64_t> axes(kdims);
             std::iota(axes.begin(), axes.end(), 2);

src/onnx/parse_pow.cpp

@@ -46,7 +46,7 @@ auto compute_type(shape::type_t t1, shape::type_t t2)
 
     int it1 = t1;
     int it2 = t2;
-    if(!contains(op_order, it1) or !contains(op_order, it2))
+    if(not contains(op_order, it1) or not contains(op_order, it2))
     {
         MIGRAPHX_THROW("PARSE_POW: Input data type not supported!");
     }

src/onnx/parse_resize.cpp

@@ -56,7 +56,7 @@ const auto& get_nearest_op(const std::string& mode)
              return static_cast<std::size_t>(std::ceil((val)));
          }}};
 
-    if(!contains(nearest_ops, mode))
+    if(not contains(nearest_ops, mode))
     {
         MIGRAPHX_THROW("PARSE_RESIZE: nearest_mode " + mode + " not supported!");
     }
@@ -86,7 +86,7 @@ const auto& get_original_idx_op(const std::string& mode)
              return (idx + 0.5) / scale;
          }}};
 
-    if(!contains(idx_ops, mode))
+    if(not contains(idx_ops, mode))
     {
         MIGRAPHX_THROW("PARSE_RESIZE: coordinate_transformation_mode " + mode + " not supported!");
     }

src/onnx/parse_reversesequence.cpp

@@ -31,7 +31,7 @@ namespace migraphx {
 inline namespace MIGRAPHX_INLINE_NS {
 namespace onnx {
 
-//!  Parser for ReverseSequence ONNX operator.
+// Parser for ReverseSequence ONNX operator.
 /*!
   Reverses the data along the time axis for the batches along the batch axis.
   The sequence lengths can be given to reverse up to the given length for each batch, keeping the

src/opt/memory_coloring.cpp

@@ -29,7 +29,7 @@ inline namespace MIGRAPHX_INLINE_NS {
 
 void memory_coloring::apply(module& m) const
 {
-    if(!enabled(MIGRAPHX_DISABLE_MEMORY_COLORING{}))
+    if(not enabled(MIGRAPHX_DISABLE_MEMORY_COLORING{}))
     {
         memory_coloring_impl opt(&m, allocation_op, verify);
         opt.run();

src/opt/memory_coloring_impl.cpp

@@ -42,7 +42,7 @@ void memory_coloring_impl::run()
     {
         MIGRAPHX_DEBUG(dump_intervals());
         // Coloring
-        while(!alloc_queue.empty())
+        while(not alloc_queue.empty())
         {
             interval_ptr interval = alloc_queue.top();
             allocate(interval);
@@ -96,7 +96,7 @@ bool memory_coloring_impl::allocate(interval_ptr interval)
     }
 
     std::size_t offset = 0;
-    while(!conflict_queue.empty())
+    while(not conflict_queue.empty())
     {
         live_range* range       = conflict_queue.top();
         std::size_t iter_offset = range->offset;
@@ -149,7 +149,7 @@ void memory_coloring_impl::build()
         {
             def_interval = instr2_live[p_iter];
             bool is_lit  = is_literal(iter);
-            if(is_allocate(iter) || is_lit)
+            if(is_allocate(iter) or is_lit)
             {
                 live_range& range        = def_interval->segment;
                 def_interval->result     = iter->get_shape();
@@ -157,12 +157,12 @@ void memory_coloring_impl::build()
                 range.begin              = cur_points;
                 def_interval->def_point  = cur_points;
                 range.size               = (iter->get_shape()).bytes();
-                if(!is_lit || unify_literals)
+                if(not is_lit or unify_literals)
                     alloc_queue.push(def_interval);
                 live_set.erase(range.vn);
             }
         }
-        else if(!is_param(iter) && !is_outline(iter) && !is_check_context(iter))
+        else if(not is_param(iter) && not is_outline(iter) && not is_check_context(iter))
         {
             is_dead = true;
         }
@@ -179,7 +179,7 @@ void memory_coloring_impl::build()
             if(not p_mod->has_instruction(arg))
                 continue;
 
-            if(is_param(arg) || is_outline(arg))
+            if(is_param(arg) or is_outline(arg))
             {
                 if(is_output_param(arg))
                     is_dead = false;
@@ -235,7 +235,7 @@ void memory_coloring_impl::rewrite()
             if(interval->get_begin() == invalid_offset)
                 continue;
 
-            if(!unify_literals && interval->is_literal)
+            if(not unify_literals && interval->is_literal)
                 continue;
 
             std::size_t offset = 0;
@@ -272,7 +272,7 @@ void memory_coloring_impl::verify()
 
             if(segment.begin == invalid_offset)
             {
-                // if(!interval.is_live_on_entry)
+                // if(not interval.is_live_on_entry)
                 // MIGRAPHX_THROW("interval is not live on entry");
                 continue;
             }
@@ -290,7 +290,7 @@ void memory_coloring_impl::verify()
                     live_range* range = live_ranges[iter];
                     if(range->offset == invalid_offset)
                         continue;
-                    if(!is_disjoin(*range, segment))
+                    if(not is_disjoin(*range, segment))
                         MIGRAPHX_THROW("range and segment is not disjoined");
                 }
             }