Refactor to make more clear

src/instruction.cpp

@@ -77,10 +77,10 @@ bool operator==(const instruction& i, instruction_ref ref)
 bool instruction::valid(const module& m, bool check_order) const
 {
     return valid() && std::all_of(arguments.begin(), arguments.end(), [&](instruction_ref i) {
+               (*i).debug_print();
                auto self = std::find(i->outputs().begin(), i->outputs().end(), *this);
                bool ret  = self != i->outputs().end();
-               // assume argument is in previous module if m.has_instruction(i) is false
-               if(check_order and m.has_instruction(i))
+               if(check_order)
                {
                    // check arguments for this instruction before this instruction
                    ret = ret and (std::distance(m.begin(), i) < std::distance(m.begin(), *self));

src/module.cpp

@@ -505,14 +505,22 @@ std::vector<shape> module::get_output_shapes() const
 
 instruction_ref module::validate() const
 {
-    return std::find_if(
-        impl->instructions.begin(), impl->instructions.end(), [&](const instruction& i) {
-            auto inputs      = i.inputs();
-            bool check_order = std::all_of(inputs.begin(), inputs.end(), [&](auto in) {
-                return contains(impl->instructions, *in);
-            });
-            return !i.valid(*this, check_order);
-        });
+
+    auto check_invalid = [&](instruction_ref i) {
+        auto inputs      = (*i).inputs();
+        bool check_order = std::all_of(
+            inputs.begin(), inputs.end(), [&](instruction_ref in) { return has_instruction(in); });
+        return not(*i).valid(*this, check_order);
+    };
+
+    for(instruction_ref i = impl->instructions.begin(); i != impl->instructions.end(); ++i)
+    {
+        if(check_invalid(i))
+        {
+            return i;
+        }
+    }
+    return impl->instructions.end();
 }
 
 bool is_borrowed(instruction_ref ins)

src/program.cpp

@@ -154,6 +154,8 @@ void program::compile(const target& t, compile_options options)
 
     auto mods = this->get_modules();
 
+    std::cout << "mods size: " << mods.size() << std::endl;
+
     // Validate and finalize
     for(const auto& mod : reverse(mods))
     {

test/module_test.cpp

@@ -319,10 +319,12 @@ TEST_CASE(multiple_module_dependency)
     migraphx::program p;
     auto* mm  = p.get_main_module();
     auto* sub = p.create_module("sub");
-    auto l1 = mm->add_literal(migraphx::literal(3));
-    sub->add_instruction(migraphx::make_op("multibroadcast", {{"out_lens", {2, 2 ,3}}}), l1);
-    p.compile(migraphx::ref::target{});
-    p.eval({});
+    auto l1   = mm->add_literal(migraphx::literal(3));
+    // second same literal to make sure instruction_ref is being compared, rahter than the
+    // instructions
+    sub->add_literal(migraphx::literal(3));
+    sub->add_instruction(sum_op{}, l1, l1);
+    sub->validate();
 }
 
 int main(int argc, const char* argv[]) { test::run(argc, argv); }