Split cpu and reference implementation (#671)

* Add all_targets cmake target

* Rename target

* Add ref target

* Rename tests

* Refactor compiler target

* Formatting

* Verify for every target

* Formatting

* Add verify test suite

* Formatting

* Add initial test programs

* Formatting

* Add rnn tests

* Formatting

* Validate gpu

* Formatting

* Remove old gpu tests

* Fix gpu tests

* Fix ref error

* Fix tidy issues

* Formatting

* Tidy fixes

* Fix header in python api

* Rename to ref

* Use ref in verify_onnx

* Fix tidy issue

* Build with verbose on

* Fix typo

* Remove verbose

* rename some cpu prefix to ref
Co-authored-by: Shucai Xiao <Shucai.Xiao@amd.com>

test/verify/test_var_sl_gru_forward.cpp

+
+#include "verify_program.hpp"
+#include <migraphx/program.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/operators.hpp>
+
+struct test_var_sl_gru_forward : verify_program<test_var_sl_gru_forward>
+{
+    migraphx::program create_program() const
+    {
+        std::size_t batch_size  = 3;
+        std::size_t seq_len     = 3;
+        std::size_t hidden_size = 5;
+        std::size_t input_size  = 8;
+        std::size_t num_dirct   = 1;
+        float clip              = 0.0f;
+
+        migraphx::program p;
+        migraphx::shape in_shape{migraphx::shape::float_type, {seq_len, batch_size, input_size}};
+        migraphx::shape w_shape{migraphx::shape::float_type,
+                                {num_dirct, 3 * hidden_size, input_size}};
+        migraphx::shape r_shape{migraphx::shape::float_type,
+                                {num_dirct, 3 * hidden_size, hidden_size}};
+        migraphx::shape b_shape{migraphx::shape::float_type, {num_dirct, 6 * hidden_size}};
+        migraphx::shape sl_shape{migraphx::shape::int32_type, {batch_size}};
+        migraphx::shape ih_shape{migraphx::shape::float_type, {num_dirct, batch_size, hidden_size}};
+
+        auto seq  = p.add_parameter("seq", in_shape);
+        auto w    = p.add_parameter("w", w_shape);
+        auto r    = p.add_parameter("r", r_shape);
+        auto bias = p.add_parameter("bias", b_shape);
+        auto ih   = p.add_parameter("ih", ih_shape);
+        std::vector<int> sl_data{3, 2, 1};
+        auto sql = p.add_literal(migraphx::literal{sl_shape, sl_data});
+
+        auto hs =
+            p.add_instruction(migraphx::op::gru{hidden_size,
+                                                {migraphx::op::sigmoid{}, migraphx::op::tanh{}},
+                                                migraphx::op::rnn_direction::forward,
+                                                clip},
+                              seq,
+                              w,
+                              r,
+                              bias,
+                              sql,
+                              ih);
+        auto lho = p.add_instruction(migraphx::op::rnn_last_hs_output{}, hs);
+        p.add_return({lho, hs});
+
+        return p;
+    }
+    std::string section() const { return "rnn"; }
+};

test/verify/verify_program.cpp

+#include "verify_program.hpp"
+
+std::vector<program_info>& get_programs_vector()
+{
+    static std::vector<program_info> result; // NOLINT
+    return result;
+}
+
+void register_program_info(const program_info& pi) { get_programs_vector().push_back(pi); }
+const std::vector<program_info>& get_programs() { return get_programs_vector(); }

test/verify/verify_program.hpp

+#ifndef MIGRAPHX_GUARD_AUTO_REGISTER_VERIFY_PROGRAM_HPP
+#define MIGRAPHX_GUARD_AUTO_REGISTER_VERIFY_PROGRAM_HPP
+
+#include <migraphx/auto_register.hpp>
+#include <migraphx/program.hpp>
+#include <functional>
+
+struct program_info
+{
+    std::string name;
+    std::string section;
+    std::function<migraphx::program()> get_program;
+};
+
+void register_program_info(const program_info& pi);
+const std::vector<program_info>& get_programs();
+
+struct register_verify_program_action
+{
+    template <class T>
+    static void apply()
+    {
+        T x;
+        program_info pi;
+        pi.name        = migraphx::get_type_name<T>();
+        pi.section     = x.section();
+        pi.get_program = [x] { return x.create_program(); };
+        register_program_info(pi);
+    }
+};
+
+template <class T>
+using auto_register_verify_program = migraphx::auto_register<register_verify_program_action, T>;
+
+template <class T>
+struct verify_program : auto_register_verify_program<T>
+{
+    std::string section() const { return "general"; };
+};
+
+#endif

tools/api/api.cpp

@@ -6,7 +6,7 @@
 #include <migraphx/register_target.hpp>
 #include <migraphx/generate.hpp>
 #include <migraphx/quantization.hpp>
-#include <migraphx/cpu/target.hpp>
+#include <migraphx/ref/target.hpp>
 #include <migraphx/load_save.hpp>
 #include <migraphx/make_op.hpp>
 #include <migraphx/json.hpp>