Merge branch 'develop' of github.com:ROCmSoftwarePlatform/AMDMIGraphX into add-conv_bn_add-test

src/include/migraphx/algorithm.hpp

@@ -2,6 +2,7 @@
 #define MIGRAPHX_GUARD_RTGLIB_ALGORITHM_HPP
 
 #include <algorithm>
+#include <numeric>
 #include <migraphx/config.hpp>
 
 namespace migraphx {
@@ -21,6 +22,13 @@ void transform_if(Iterator start, Iterator last, Output out, Predicate pred, F f
     }
 }
 
+template <class Iterator, class T, class BinaryOp, class UnaryOp>
+T transform_accumulate(Iterator first, Iterator last, T init, BinaryOp binop, UnaryOp unaryop)
+{
+    return std::inner_product(
+        first, last, first, init, binop, [&](auto&& x, auto&&) { return unaryop(x); });
+}
+
 template <class Iterator, class Output, class Predicate>
 void group_by(Iterator start, Iterator last, Output out, Predicate pred)
 {

src/include/migraphx/allocation_model.hpp

@@ -26,6 +26,8 @@ struct allocation_model
     std::string copy() const;
     /// Create an allocation operator for the given shape
     operation allocate(const shape& s) const;
+    /// Create a preallocated operator for the given shape
+    operation preallocate(const shape& s, const std::string& id) const;
 };
 
 #else
@@ -38,6 +40,7 @@ struct allocation_model
  *      std::string name() const;
  *      std::string copy() const;
  *      operation allocate(const shape& s) const;
+ *      operation preallocate(const shape& s,std::string id) const;
  * };
  *
  */
@@ -123,6 +126,12 @@ struct allocation_model
         return (*this).private_detail_te_get_handle().allocate(s);
     }
 
+    operation preallocate(const shape& s, std::string id) const
+    {
+        assert((*this).private_detail_te_handle_mem_var);
+        return (*this).private_detail_te_get_handle().preallocate(s, std::move(id));
+    }
+
     friend bool is_shared(const allocation_model& private_detail_x,
                           const allocation_model& private_detail_y)
     {
@@ -137,9 +146,10 @@ struct allocation_model
         virtual std::shared_ptr<private_detail_te_handle_base_type> clone() const = 0;
         virtual const std::type_info& type() const                                = 0;
 
-        virtual std::string name() const                 = 0;
-        virtual std::string copy() const                 = 0;
-        virtual operation allocate(const shape& s) const = 0;
+        virtual std::string name() const                                    = 0;
+        virtual std::string copy() const                                    = 0;
+        virtual operation allocate(const shape& s) const                    = 0;
+        virtual operation preallocate(const shape& s, std::string id) const = 0;
     };
 
     template <typename PrivateDetailTypeErasedT>
@@ -180,6 +190,12 @@ struct allocation_model
             return private_detail_te_value.allocate(s);
         }
 
+        operation preallocate(const shape& s, std::string id) const override
+        {
+
+            return private_detail_te_value.preallocate(s, std::move(id));
+        }
+
         PrivateDetailTypeErasedT private_detail_te_value;
     };
 

src/include/migraphx/apply_alpha_beta.hpp

+#ifndef MIGRAPHX_GUARD_MIGRAPHX_APPLY_ALPHA_BETA_HPP
+#define MIGRAPHX_GUARD_MIGRAPHX_APPLY_ALPHA_BETA_HPP
+
+#include "migraphx/make_op.hpp"
+#include "migraphx/normalize_attributes.hpp"
+#include "migraphx/operation.hpp"
+#include <migraphx/instruction_ref.hpp>
+#include <migraphx/module.hpp>
+
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
+
+instruction_ref insert_apply_alpha_beta(module& m,
+                                        instruction_ref pos,
+                                        const std::vector<instruction_ref>& args,
+                                        const operation& op,
+                                        const literal& alpha,
+                                        const literal& beta);
+
+template <typename T = float>
+instruction_ref insert_apply_alpha_beta(module& m,
+                                        instruction_ref pos,
+                                        const std::vector<instruction_ref>& args,
+                                        const operation& op,
+                                        T alpha = 1,
+                                        T beta  = 0)
+{
+    return insert_apply_alpha_beta(m, pos, args, op, literal{T{alpha}}, literal{T{beta}});
+}
+
+template <typename T = float>
+instruction_ref add_apply_alpha_beta(module& m,
+                                     const std::vector<instruction_ref>& args,
+                                     const operation& op,
+                                     T alpha = 1,
+                                     T beta  = 0)
+{
+    return insert_apply_alpha_beta(m, m.end(), args, op, alpha, beta);
+}
+
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx
+#endif // MIGRAPHX_GUARD_APPLY_ALPHA_BETA_HPP

src/include/migraphx/argument.hpp

@@ -27,29 +27,29 @@ struct argument : raw_data<argument>
 
     template <class F, MIGRAPHX_REQUIRES(std::is_pointer<decltype(std::declval<F>()())>{})>
     argument(shape s, F d)
-        : m_shape(std::move(s)),
-          m_data({[f = std::move(d)]() mutable { return reinterpret_cast<char*>(f()); }})
+        : m_shape(std::move(s))
 
     {
+        assign_buffer([f = std::move(d)]() mutable { return reinterpret_cast<char*>(f()); });
     }
     template <class T>
     argument(shape s, T* d)
-        : m_shape(std::move(s)), m_data({[d] { return reinterpret_cast<char*>(d); }})
+        : m_shape(std::move(s))
     {
+        assign_buffer([d] { return reinterpret_cast<char*>(d); });
     }
 
     template <class T>
     argument(shape s, std::shared_ptr<T> d)
-        : m_shape(std::move(s)), m_data({[d] { return reinterpret_cast<char*>(d.get()); }})
+        : m_shape(std::move(s))
     {
+        assign_buffer([d] { return reinterpret_cast<char*>(d.get()); });
     }
 
     argument(shape s, std::nullptr_t);
     
     argument(const std::vector<argument>& args);
 
-    static argument load(const shape& s, char* buffer);
-
     /// Provides a raw pointer to the data
     char* data() const;
 
@@ -60,12 +60,15 @@ struct argument : raw_data<argument>
 
     argument reshape(const shape& s) const;
 
+    argument copy() const;
+
     /// Make copy of the argument that is always sharing the data
     argument share() const;
 
     std::vector<argument> get_sub_objects() const;
 
     private:
+    void assign_buffer(std::function<char*()> d);
     struct data_t
     {
         std::function<char*()> get = nullptr;

src/include/migraphx/builtin.hpp

@@ -43,6 +43,7 @@ struct outline
 struct param
 {
     std::string parameter;
+    uint32_t order = 0;
 
     template <class Self, class F>
     static auto reflect(Self& self, F f)

src/include/migraphx/check_shapes.hpp

@@ -158,6 +158,13 @@ struct check_shapes
         return *this;
     }
 
+    const check_shapes& tuple_type() const
+    {
+        if(!this->all_of([](const shape& s) { return s.type() == shape::tuple_type; }))
+            MIGRAPHX_THROW(prefix() + "Shapes are not tuple!");
+        return *this;
+    }
+
     const check_shapes& not_transposed() const
     {
         if(!this->all_of([](const shape& s) { return not s.transposed(); }))

src/include/migraphx/common.hpp

+#ifndef MIGRAPHX_GUARD_MIGRAPHX_COMMON_HPP
+#define MIGRAPHX_GUARD_MIGRAPHX_COMMON_HPP
+
+#include <migraphx/config.hpp>
+#include <migraphx/shape.hpp>
+#include <migraphx/instruction_ref.hpp>
+
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
+
+struct module;
+struct operation;
+
+std::vector<std::size_t> compute_broadcasted_lens(std::vector<std::size_t> s0,
+                                                  std::vector<std::size_t> s1);
+shape common_shape(const std::vector<shape>& shapes);
+
+instruction_ref insert_common_op(module& m,
+                                 instruction_ref ins,
+                                 const operation& op,
+                                 std::vector<instruction_ref> inputs);
+instruction_ref add_common_op(module& m, const operation& op, std::vector<instruction_ref> inputs);
+
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx
+#endif // MIGRAPHX_GUARD_MIGRAPHX_COMMON_HPP

src/include/migraphx/dom_info.hpp

+
+#ifndef MIGRAPHX_GUARD_RTGLIB_DOM_INFO_HPP
+#define MIGRAPHX_GUARD_RTGLIB_DOM_INFO_HPP
+
+#include <migraphx/config.hpp>
+#include <migraphx/instruction.hpp>
+#include <unordered_map>
+
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
+
+struct module;
+
+struct dominator_info
+{
+    bool strictly_dominate(instruction_ref ins1, instruction_ref ins2);
+
+    std::unordered_map<instruction_ref, instruction_ref> ins2idom;
+};
+
+dominator_info compute_dominator(module& m);
+// dominator_info compute_dominator_naive(const module& m);
+
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx
+
+#endif

src/include/migraphx/eliminate_pad.hpp

@@ -20,10 +20,7 @@ struct eliminate_pad
 {
     std::string name() const { return "eliminate_pad"; }
 
-    void apply(module& p) const;
-    void update_op(const instruction_ref& input, const instruction_ref& ins, module& p) const;
-
-    void update_pooling(const instruction_ref& input, const instruction_ref& ins, module& p) const;
+    void apply(module& m) const;
 };
 
 } // namespace MIGRAPHX_INLINE_NS

src/include/migraphx/erase.hpp

@@ -25,12 +25,19 @@ auto erase(R&& r, const T& value)
  *
  * @param r The container to erase elements from
  * @param pred Predicate function that selects which elements should be erased.
- * @return Returns iterator to erased element
  */
 template <class R, class P>
-auto erase_if(R&& r, P&& pred)
+void erase_if(R&& r, P&& pred)
 {
-    return r.erase(std::remove_if(r.begin(), r.end(), pred), r.end());
+    auto first = r.begin();
+    auto last  = r.end();
+    while(first != last)
+    {
+        if(pred(*first))
+            first = r.erase(first);
+        else
+            first++;
+    }
 }
 
 } // namespace MIGRAPHX_INLINE_NS

src/include/migraphx/errors.hpp

@@ -49,12 +49,13 @@ inline std::string make_source_context(const std::string& file, int line, const
     return file + ":" + std::to_string(line) + ": " + fname;
 }
 
+// NOLINTNEXTLINE
+#define MIGRAPHX_MAKE_SOURCE_CTX() migraphx::make_source_context(__FILE__, __LINE__, __func__)
+
 /**
  * @brief Throw an exception with context information
  */
-#define MIGRAPHX_THROW(...)                                                                     \
-    throw migraphx::make_exception(migraphx::make_source_context(__FILE__, __LINE__, __func__), \
-                                   __VA_ARGS__)
+#define MIGRAPHX_THROW(...) throw migraphx::make_exception(MIGRAPHX_MAKE_SOURCE_CTX(), __VA_ARGS__)
 
 } // namespace MIGRAPHX_INLINE_NS
 } // namespace migraphx

src/include/migraphx/file_buffer.hpp

@@ -9,6 +9,7 @@ namespace migraphx {
 inline namespace MIGRAPHX_INLINE_NS {
 
 std::vector<char> read_buffer(const std::string& filename);
+std::string read_string(const std::string& filename);
 
 void write_buffer(const std::string& filename, const char* buffer, std::size_t size);
 void write_buffer(const std::string& filename, const std::vector<char>& buffer);

src/include/migraphx/remap.hpp → src/include/migraphx/inline_module.hpp

-#ifndef MIGRAPHX_GUARD_RTGLIB_REMAP_HPP
-#define MIGRAPHX_GUARD_RTGLIB_REMAP_HPP
+#ifndef MIGRAPHX_GUARD_RTGLIB_INLINE_MODULE_HPP
+#define MIGRAPHX_GUARD_RTGLIB_INLINE_MODULE_HPP
 
 #include <string>
 #include <migraphx/instruction_ref.hpp>
@@ -10,13 +10,10 @@ inline namespace MIGRAPHX_INLINE_NS {
 
 struct module;
 
-/**
- * Decompose operators.
- */
-struct remap
+struct inline_module
 {
-    std::string name() const { return "remap"; }
-    void apply(module& p) const;
+    std::string name() const { return "inline_module"; }
+    void apply(module& m) const;
 };
 
 } // namespace MIGRAPHX_INLINE_NS

src/include/migraphx/decompose.hpp → src/include/migraphx/insert_pad.hpp

-#ifndef MIGRAPHX_GUARD_RTGLIB_DECOMPOSE_HPP
-#define MIGRAPHX_GUARD_RTGLIB_DECOMPOSE_HPP
+#ifndef MIGRAPHX_GUARD_RTGLIB_INSERT_PAD_HPP
+#define MIGRAPHX_GUARD_RTGLIB_INSERT_PAD_HPP
 
 #include <string>
+#include <vector>
+#include <array>
 #include <migraphx/instruction_ref.hpp>
 #include <migraphx/config.hpp>
 
@@ -11,12 +13,13 @@ inline namespace MIGRAPHX_INLINE_NS {
 struct module;
 
 /**
- * Decompose operators.
+ * insert pads if attribute of padding is asymmetrical
  */
-struct decompose
+struct insert_pad
 {
-    std::string name() const { return "decompose"; }
-    void apply(module& p) const;
+    std::string name() const { return "insert_pad"; }
+
+    void apply(module& m) const;
 };
 
 } // namespace MIGRAPHX_INLINE_NS

src/include/migraphx/instruction.hpp

@@ -164,6 +164,18 @@ struct hash<migraphx::instruction_ref>
     }
 };
 
+template <>
+struct equal_to<migraphx::instruction_ref>
+{
+    using argument_type = migraphx::instruction_ref;
+    using result_type   = bool;
+    result_type operator()(const migraphx::instruction_ref& x,
+                           const migraphx::instruction_ref& y) const noexcept
+    {
+        return &*x == &*y;
+    }
+};
+
 } // namespace std
 
 #endif

src/include/migraphx/iota_iterator.hpp

@@ -2,14 +2,15 @@
 #define MIGRAPHX_GUARD_RTGLIB_IOTA_ITERATOR_HPP
 
 #include <migraphx/config.hpp>
+#include <migraphx/functional.hpp>
 #include <iterator>
 #include <type_traits>
 
 namespace migraphx {
 inline namespace MIGRAPHX_INLINE_NS {
 
-template <class F, class Iterator = std::size_t>
-struct iota_iterator
+template <class F, class Iterator = std::ptrdiff_t>
+struct basic_iota_iterator
 {
     Iterator index;
     F f;
@@ -20,40 +21,40 @@ struct iota_iterator
     using pointer           = typename std::add_pointer<value_type>::type;
     using iterator_category = std::random_access_iterator_tag;
 
-    iota_iterator& operator+=(int n)
+    basic_iota_iterator& operator+=(int n)
     {
         index += n;
         return *this;
     }
 
-    iota_iterator& operator-=(int n)
+    basic_iota_iterator& operator-=(int n)
     {
         index -= n;
         return *this;
     }
 
-    iota_iterator& operator++()
+    basic_iota_iterator& operator++()
     {
         index++;
         return *this;
     }
 
-    iota_iterator& operator--()
+    basic_iota_iterator& operator--()
     {
         index--;
         return *this;
     }
 
-    iota_iterator operator++(int) // NOLINT
+    basic_iota_iterator operator++(int) // NOLINT
     {
-        iota_iterator it = *this;
+        basic_iota_iterator it = *this;
         index++;
         return it;
     }
 
-    iota_iterator operator--(int) // NOLINT
+    basic_iota_iterator operator--(int) // NOLINT
     {
-        iota_iterator it = *this;
+        basic_iota_iterator it = *this;
         index--;
         return it;
     }
@@ -61,55 +62,71 @@ struct iota_iterator
     reference operator*() const { return f(index); }
 };
 
+template <class T, class F>
+inline basic_iota_iterator<F, T> make_basic_iota_iterator(T x, F f)
+{
+    return basic_iota_iterator<F, T>{x, f};
+}
+
+template <class F, class Iterator>
+inline basic_iota_iterator<F, Iterator> operator+(basic_iota_iterator<F, Iterator> x,
+                                                  std::ptrdiff_t y)
+{
+    return x += y;
+}
+
 template <class F, class Iterator>
-inline iota_iterator<F, Iterator> operator+(iota_iterator<F, Iterator> x,
-                                            iota_iterator<F, Iterator> y)
+inline basic_iota_iterator<F, Iterator> operator+(std::ptrdiff_t x,
+                                                  basic_iota_iterator<F, Iterator> y)
 {
-    return iota_iterator<F, Iterator>(x.index + y.index, x.f);
+    return y + x;
 }
 
 template <class F, class Iterator>
-inline std::ptrdiff_t operator-(iota_iterator<F, Iterator> x, iota_iterator<F, Iterator> y)
+inline std::ptrdiff_t operator-(basic_iota_iterator<F, Iterator> x,
+                                basic_iota_iterator<F, Iterator> y)
 {
     return x.index - y.index;
 }
 
 template <class F, class Iterator>
-inline bool operator==(iota_iterator<F, Iterator> x, iota_iterator<F, Iterator> y)
+inline bool operator==(basic_iota_iterator<F, Iterator> x, basic_iota_iterator<F, Iterator> y)
 {
     return x.index == y.index;
 }
 
 template <class F, class Iterator>
-inline bool operator!=(iota_iterator<F, Iterator> x, iota_iterator<F, Iterator> y)
+inline bool operator!=(basic_iota_iterator<F, Iterator> x, basic_iota_iterator<F, Iterator> y)
 {
     return x.index != y.index;
 }
 
 template <class F, class Iterator>
-inline bool operator<(iota_iterator<F, Iterator> x, iota_iterator<F, Iterator> y)
+inline bool operator<(basic_iota_iterator<F, Iterator> x, basic_iota_iterator<F, Iterator> y)
 {
     return x.index < y.index;
 }
 
 template <class F, class Iterator>
-inline bool operator>(iota_iterator<F, Iterator> x, iota_iterator<F, Iterator> y)
+inline bool operator>(basic_iota_iterator<F, Iterator> x, basic_iota_iterator<F, Iterator> y)
 {
     return x.index > y.index;
 }
 
 template <class F, class Iterator>
-inline bool operator>=(iota_iterator<F, Iterator> x, iota_iterator<F, Iterator> y)
+inline bool operator>=(basic_iota_iterator<F, Iterator> x, basic_iota_iterator<F, Iterator> y)
 {
     return x.index >= y.index;
 }
 
 template <class F, class Iterator>
-inline bool operator<=(iota_iterator<F, Iterator> x, iota_iterator<F, Iterator> y)
+inline bool operator<=(basic_iota_iterator<F, Iterator> x, basic_iota_iterator<F, Iterator> y)
 {
     return x.index <= y.index;
 }
 
+using iota_iterator = basic_iota_iterator<id>;
+
 } // namespace MIGRAPHX_INLINE_NS
 } // namespace migraphx
 

src/include/migraphx/iterator.hpp

+#ifndef MIGRAPHX_GUARD_MIGRAPHX_ITERATOR_HPP
+#define MIGRAPHX_GUARD_MIGRAPHX_ITERATOR_HPP
+
+#include <migraphx/config.hpp>
+#include <migraphx/rank.hpp>
+
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
+
+template <class Iterator, class EndIterator>
+auto is_end(rank<2>, Iterator it, EndIterator) -> decltype(!it._M_dereferenceable())
+{
+    return !it._M_dereferenceable();
+}
+
+template <class Iterator, class EndIterator>
+auto is_end(rank<1>, Iterator it, EndIterator last)
+{
+    return it == last;
+}
+
+template <class Iterator, class EndIterator>
+bool is_end(Iterator it, EndIterator last)
+{
+    return is_end(rank<2>{}, it, last);
+}
+
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx
+#endif // MIGRAPHX_GUARD_MIGRAPHX_ITERATOR_HPP