Merge branch 'develop' into mem_color_ordering_fix

src/include/migraphx/type_name.hpp

-#ifndef MIGRAPH_GUARD_RTGLIB_TYPE_NAME_HPP
-#define MIGRAPH_GUARD_RTGLIB_TYPE_NAME_HPP
+#ifndef MIGRAPHX_GUARD_RTGLIB_TYPE_NAME_HPP
+#define MIGRAPHX_GUARD_RTGLIB_TYPE_NAME_HPP
 
 #include <string>
 #include <migraphx/config.hpp>
 
 namespace migraphx {
-inline namespace MIGRAPH_INLINE_NS {
+inline namespace MIGRAPHX_INLINE_NS {
 
 template <class PrivateMigraphTypeNameProbe>
 const std::string& get_type_name()
@@ -18,7 +18,7 @@ const std::string& get_type_name()
         name = typeid(PrivateMigraphTypeNameProbe).name();
         name = name.substr(7);
 #else
-        const char parameter_name[] = "PrivateMigraphTypeNameProbe =";
+        const char parameter_name[] = "PrivateMigraphTypeNameProbe ="; // NOLINT
 
         name = __PRETTY_FUNCTION__;
 
@@ -41,7 +41,7 @@ const std::string& get_type_name(const T&)
     return migraphx::get_type_name<T>();
 }
 
-} // namespace MIGRAPH_INLINE_NS
+} // namespace MIGRAPHX_INLINE_NS
 } // namespace migraphx
 
 #endif

src/include/migraphx/type_traits.hpp

@@ -5,32 +5,32 @@
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 ==============================================================================*/
 
-#ifndef MIGRAPH_GUARD_RTGLIB_TYPE_TRAITS_HPP
-#define MIGRAPH_GUARD_RTGLIB_TYPE_TRAITS_HPP
+#ifndef MIGRAPHX_GUARD_RTGLIB_TYPE_TRAITS_HPP
+#define MIGRAPHX_GUARD_RTGLIB_TYPE_TRAITS_HPP
 
 #include <type_traits>
 #include <migraphx/half.hpp>
 #include <migraphx/config.hpp>
 
 namespace migraphx {
-inline namespace MIGRAPH_INLINE_NS {
+inline namespace MIGRAPHX_INLINE_NS {
 
-#define MIGRAPH_DETAIL_EXTEND_TRAIT_FOR(trait, T) \
-    template <class X>                            \
-    struct trait : std::trait<X>                  \
-    {                                             \
-    };                                            \
-                                                  \
-    template <>                                   \
-    struct trait<T> : std::true_type              \
-    {                                             \
+#define MIGRAPHX_DETAIL_EXTEND_TRAIT_FOR(trait, T) \
+    template <class X>                             \
+    struct trait : std::trait<X>                   \
+    {                                              \
+    };                                             \
+                                                   \
+    template <>                                    \
+    struct trait<T> : std::true_type               \
+    {                                              \
     };
 
-MIGRAPH_DETAIL_EXTEND_TRAIT_FOR(is_floating_point, half)
-MIGRAPH_DETAIL_EXTEND_TRAIT_FOR(is_signed, half)
-MIGRAPH_DETAIL_EXTEND_TRAIT_FOR(is_arithmetic, half)
+MIGRAPHX_DETAIL_EXTEND_TRAIT_FOR(is_floating_point, half)
+MIGRAPHX_DETAIL_EXTEND_TRAIT_FOR(is_signed, half)
+MIGRAPHX_DETAIL_EXTEND_TRAIT_FOR(is_arithmetic, half)
 
-} // namespace MIGRAPH_INLINE_NS
+} // namespace MIGRAPHX_INLINE_NS
 } // namespace migraphx
 
 #endif

src/include/migraphx/verify.hpp

-#ifndef MIGRAPH_GUARD_VERIFY_HPP
-#define MIGRAPH_GUARD_VERIFY_HPP
+#ifndef MIGRAPHX_GUARD_VERIFY_HPP
+#define MIGRAPHX_GUARD_VERIFY_HPP
 
 #include <algorithm>
 #include <cmath>
@@ -11,7 +11,7 @@
 #include <migraphx/config.hpp>
 
 namespace migraphx {
-inline namespace MIGRAPH_INLINE_NS {
+inline namespace MIGRAPHX_INLINE_NS {
 
 // Compute the value of a range
 template <class R>
@@ -173,6 +173,6 @@ bool verify_range(R1&& r1, R2&& r2, double tolerance = 80, double* out_error = n
     return error <= threshold;
 }
 
-} // namespace MIGRAPH_INLINE_NS
+} // namespace MIGRAPHX_INLINE_NS
 } // namespace migraphx
 #endif

src/include/migraphx/verify_args.hpp

-#ifndef MIGRAPH_GUARD_RTGLIB_VERIFY_ARGS_HPP
-#define MIGRAPH_GUARD_RTGLIB_VERIFY_ARGS_HPP
+#ifndef MIGRAPHX_GUARD_RTGLIB_VERIFY_ARGS_HPP
+#define MIGRAPHX_GUARD_RTGLIB_VERIFY_ARGS_HPP
 
 #include <migraphx/verify.hpp>
 #include <migraphx/argument.hpp>
 #include <migraphx/config.hpp>
 
 namespace migraphx {
-inline namespace MIGRAPH_INLINE_NS {
+inline namespace MIGRAPHX_INLINE_NS {
 
 inline bool verify_args(const std::string& name,
                         const argument& cpu_arg,
@@ -84,7 +84,7 @@ inline bool verify_args(const std::string& name,
     return passed;
 }
 
-} // namespace MIGRAPH_INLINE_NS
+} // namespace MIGRAPHX_INLINE_NS
 } // namespace migraphx
 
 #endif

src/instruction.cpp

@@ -3,7 +3,7 @@
 #include <migraphx/erase.hpp>
 
 namespace migraphx {
-inline namespace MIGRAPH_INLINE_NS {
+inline namespace MIGRAPHX_INLINE_NS {
 
 instruction::instruction(operation o, shape r, std::vector<instruction_ref> args)
     : op(std::move(o)), result(std::move(r)), arguments(std::move(args))
@@ -97,7 +97,7 @@ const std::vector<instruction_ref>& instruction::outputs() const { return output
 
 bool operator==(const instruction& x, const instruction& y)
 {
-    if(not(x.result == y.result and x.op == y.op and x.arguments == y.arguments))
+    if(std::tie(x.result, x.op, x.arguments) != std::tie(y.result, y.op, y.arguments))
         return false;
     if(x.name() == "@literal")
         return x.lit == y.lit;
@@ -162,26 +162,55 @@ void instruction::replace_argument(instruction_ref old, instruction_ref new_ins)
     old->remove_output(*this);
 }
 
-std::vector<shape> compute_shapes(const std::vector<instruction_ref>& args)
+argument instruction::eval() const
 {
-    std::vector<shape> shapes(args.size());
-    std::transform(
-        args.begin(), args.end(), shapes.begin(), [](instruction_ref i) { return i->get_shape(); });
-    return shapes;
+    if(op.name() == "@literal")
+    {
+        return this->get_literal().get_argument();
+    }
+    if(is_context_free(op))
+    {
+        std::vector<argument> args;
+        for(auto&& arg : this->inputs())
+        {
+            argument a = arg->eval();
+            if(a.empty())
+                return {};
+            args.push_back(a);
+        }
+        return op.compute(result, args);
+    }
+    return {};
 }
 
-instruction_ref instruction::get_output_alias(instruction_ref ins)
+void instruction::finalize(context& ctx)
 {
-    auto i = ins->get_operator().output_alias(compute_shapes(ins->inputs()));
+    if(has_finalize(this->op))
+        this->op.finalize(ctx, this->get_shape(), to_shapes(this->inputs()));
+}
+
+instruction_ref instruction::get_output_alias(instruction_ref ins, bool shallow)
+{
+    auto i = ins->get_operator().output_alias(to_shapes(ins->inputs()));
     if(i < 0)
         return ins;
+    if(shallow)
+        return ins->inputs().at(i);
     return get_output_alias(ins->inputs().at(i));
 }
 
+std::vector<shape> to_shapes(const std::vector<instruction_ref>& args)
+{
+    std::vector<shape> shapes(args.size());
+    std::transform(
+        args.begin(), args.end(), shapes.begin(), [](instruction_ref i) { return i->get_shape(); });
+    return shapes;
+}
+
 shape compute_shape(const operation& op, const std::vector<instruction_ref>& args)
 {
-    return op.compute_shape(compute_shapes(args));
+    return op.compute_shape(to_shapes(args));
 }
 
-} // namespace MIGRAPH_INLINE_NS
+} // namespace MIGRAPHX_INLINE_NS
 } // namespace migraphx

src/onnx/CMakeLists.txt

@@ -22,7 +22,7 @@ rocm_clang_tidy_check(read_onnx)
 target_link_libraries(read_onnx migraphx_onnx)
 
 
-if(MIGRAPH_ENABLE_GPU)
+if(MIGRAPHX_ENABLE_GPU)
 add_executable(mnist mnist.cpp)
 rocm_clang_tidy_check(mnist)
 target_link_libraries(mnist migraphx_cpu migraphx_gpu migraphx_onnx)

src/onnx/mnist.cpp

@@ -14,7 +14,10 @@
 
 auto reverse_int(unsigned int i)
 {
-    unsigned char c1, c2, c3, c4;
+    unsigned char c1;
+    unsigned char c2;
+    unsigned char c3;
+    unsigned char c4;
     c1 = i & 255u;
     c2 = (i >> 8u) & 255u;
     c3 = (i >> 16u) & 255u;
@@ -32,7 +35,9 @@ read_mnist_images(const std::string& full_path, int& number_of_images, int& imag
 
     if(file.is_open())
     {
-        int magic_number = 0, n_rows = 0, n_cols = 0;
+        int magic_number = 0;
+        int n_rows       = 0;
+        int n_cols       = 0;
 
         file.read(reinterpret_cast<char*>(&magic_number), sizeof(magic_number));
         magic_number = reverse_int(magic_number);

src/onnx/verify_onnx.cpp

@@ -116,7 +116,7 @@ void verify_reduced_program(F f, double tolerance = 80)
 {
     migraphx::program p = f();
     auto n              = std::distance(p.begin(), p.end());
-    for(int i = 0; i < n; i++)
+    for(std::size_t i = 0; i < n; i++)
     {
         verify_reduced(f, i, tolerance);
     }

src/opt/common_header.hpp

-#ifndef MIGRAPH_GUARD_RTGLIB_COMMON_HEADER_HPP
-#define MIGRAPH_GUARD_RTGLIB_COMMON_HEADER_HPP
+#ifndef MIGRAPHX_GUARD_RTGLIB_COMMON_HEADER_HPP
+#define MIGRAPHX_GUARD_RTGLIB_COMMON_HEADER_HPP
 #include <migraphx/program.hpp>
 #include <migraphx/stringutils.hpp>
 #include <migraphx/instruction.hpp>
@@ -14,17 +14,17 @@
 #include <queue>
 
 namespace migraphx {
-inline namespace MIGRAPH_INLINE_NS {
+inline namespace MIGRAPHX_INLINE_NS {
 
-//#define MIGRAPH_DEBUG_OPT
+//#define MIGRAPHX_DEBUG_OPT
 
-#ifdef MIGRAPH_DEBUG_OPT
-#define MIGRAPH_DEBUG(s) s
+#ifdef MIGRAPHX_DEBUG_OPT
+#define MIGRAPHX_DEBUG(s) s
 #else
-#define MIGRAPH_DEBUG(s)
-#endif // MIGRAPH_DEBUG_OPT
+#define MIGRAPHX_DEBUG(s)
+#endif // MIGRAPHX_DEBUG_OPT
 
-} // namespace MIGRAPH_INLINE_NS
+} // namespace MIGRAPHX_INLINE_NS
 } // namespace migraphx
 
-#endif // MIGRAPH_GUARD_RTGLIB_COMMON_HEADER_HPP
+#endif // MIGRAPHX_GUARD_RTGLIB_COMMON_HEADER_HPP

src/opt/memory_coloring.cpp

@@ -2,16 +2,16 @@
 #include "memory_coloring_impl.hpp"
 
 namespace migraphx {
-inline namespace MIGRAPH_INLINE_NS {
+inline namespace MIGRAPHX_INLINE_NS {
 
 void memory_coloring::apply(program& p) const
 {
-    if(!enabled(MIGRAPH_DISABLE_MEMORY_COLORING{}))
+    if(!enabled(MIGRAPHX_DISABLE_MEMORY_COLORING{}))
     {
         memory_coloring_impl opt(&p, allocation_op, verify);
         opt.run();
     }
 }
 
-} // namespace MIGRAPH_INLINE_NS
+} // namespace MIGRAPHX_INLINE_NS
 } // namespace migraphx

src/opt/memory_coloring_impl.cpp

 #include "memory_coloring_impl.hpp"
 
 namespace migraphx {
-inline namespace MIGRAPH_INLINE_NS {
+inline namespace MIGRAPHX_INLINE_NS {
 
 void memory_coloring_impl::run()
 {
-    MIGRAPH_DEBUG(dump("---Before memory coloring---"));
-    MIGRAPH_DEBUG(dump_program());
+    MIGRAPHX_DEBUG(dump("---Before memory coloring---"));
+    MIGRAPHX_DEBUG(dump_program());
     build();
     if(num_of_lives != 0)
     {
-        MIGRAPH_DEBUG(dump_intervals());
+        MIGRAPHX_DEBUG(dump_intervals());
         // Coloring
         while(!alloc_queue.empty())
         {
@@ -85,7 +85,7 @@ bool memory_coloring_impl::allocate(interval_ptr interval)
         conflict_queue.pop();
     }
     segment.offset = offset;
-    MIGRAPH_DEBUG(segment.dump());
+    MIGRAPHX_DEBUG(segment.dump());
     required_bytes = std::max(required_bytes, offset + segment.size);
     return true;
 }
@@ -218,8 +218,8 @@ void memory_coloring_impl::rewrite()
             }
         }
     }
-    MIGRAPH_DEBUG(dump("---After rewrite---"));
-    MIGRAPH_DEBUG(dump_program());
+    MIGRAPHX_DEBUG(dump("---After rewrite---"));
+    MIGRAPHX_DEBUG(dump_program());
 }
 
 void memory_coloring_impl::verify()
@@ -235,7 +235,7 @@ void memory_coloring_impl::verify()
             {
                 // TODO: This check breaks on the tests
                 // if(!interval.is_live_on_entry)
-                // MIGRAPH_THROW("interval is not live on entry");
+                // MIGRAPHX_THROW("interval is not live on entry");
                 continue;
             }
 
@@ -253,14 +253,14 @@ void memory_coloring_impl::verify()
                     if(range->offset == invalid_offset)
                         continue;
                     if(!is_disjoin(*range, segment))
-                        MIGRAPH_THROW("range and segment is not disjoined");
+                        MIGRAPHX_THROW("range and segment is not disjoined");
                 }
             }
         }
     }
 }
 
-#ifdef MIGRAPH_DEBUG_OPT
+#ifdef MIGRAPHX_DEBUG_OPT
 
 void memory_coloring_impl::dump(const std::string& str) { std::cout << str << std::endl; }
 
@@ -334,5 +334,5 @@ void live_interval::dump()
 
 #endif
 
-} // namespace MIGRAPH_INLINE_NS
+} // namespace MIGRAPHX_INLINE_NS
 } // namespace migraphx

src/opt/memory_coloring_impl.hpp

-#ifndef MIGRAPH_GUARD_RTGLIB_MEMORY_COLORING_IMPL_HPP
-#define MIGRAPH_GUARD_RTGLIB_MEMORY_COLORING_IMPL_HPP
+#ifndef MIGRAPHX_GUARD_RTGLIB_MEMORY_COLORING_IMPL_HPP
+#define MIGRAPHX_GUARD_RTGLIB_MEMORY_COLORING_IMPL_HPP
 #include "common_header.hpp"
 #include <migraphx/config.hpp>
 
 namespace migraphx {
-inline namespace MIGRAPH_INLINE_NS {
+inline namespace MIGRAPHX_INLINE_NS {
 
 static const int invalid_offset = -1;
 
@@ -15,7 +15,7 @@ struct live_range
     long long offset; // offset to base pointer of allocated memory trunk.
     int vn;           // value number that identifies this live_range.
     long long size;   // size of required memory in bytes
-#ifdef MIGRAPH_DEBUG_OPT
+#ifdef MIGRAPHX_DEBUG_OPT
     void dump();
 #endif
 };
@@ -35,7 +35,7 @@ struct live_interval
     int get_end() const { return segment.end; }
     long long get_offset() const { return segment.offset; }
 
-#ifdef MIGRAPH_DEBUG_OPT
+#ifdef MIGRAPHX_DEBUG_OPT
     void dump();
 #endif
 
@@ -84,7 +84,7 @@ struct memory_coloring_impl
     {
         return is_param(ins) && any_cast<builtin::param>(ins->get_operator()).parameter == "output";
     }
-    bool is_allocate(const instruction_ref ins) { return ins->name() == allocation_op; }
+    bool is_allocate(const instruction_ref ins) const { return ins->name() == allocation_op; }
     static bool is_outline(const instruction_ref ins) { return ins->name() == "@outline"; }
     static bool is_literal(const instruction_ref ins) { return ins->name() == "@literal"; }
     static bool is_check_context(const instruction_ref ins)
@@ -101,7 +101,7 @@ struct memory_coloring_impl
         return ((end1 < range2.offset) || (end2 < range1.offset));
     }
     void verify();
-#ifdef MIGRAPH_DEBUG_OPT
+#ifdef MIGRAPHX_DEBUG_OPT
     void dump(const std::string&);
     void dump_program();
     void dump_intervals();
@@ -154,6 +154,6 @@ struct memory_coloring_impl
     bool enable_verify;
 };
 
-} // namespace MIGRAPH_INLINE_NS
+} // namespace MIGRAPHX_INLINE_NS
 } // namespace migraphx
 #endif