Function generic_eval

src/program.cpp:464–551

template <class F>
static std::vector<argument> generic_eval(const module* mod,
                                          std::vector<context>& ctx,
                                          const std::unordered_map<std::string, argument>& params,
                                          pmr::unordered_map<instruction_ref, argument>& results,
                                          F trace)
{
    assert(mod->validate() == mod->end());
    std::vector<argument> values;
    values.reserve(16);
    for(auto ins : iterator_for(*mod))
    {
        assert(mod->name() != "main" or results.find(ins) == results.end());
#ifndef NDEBUG
        results.emplace(ins, argument{});
#endif
        const auto& name = ins->name();
        if(name == "@literal")
        {
            results.insert_or_assign(ins,
                                     trace(ins, [&] { return ins->get_literal().get_argument(); }));
        }
        else if(name == "@param")
        {
            results.insert_or_assign(
                ins, trace(ins, [&] {
                    auto param_name = any_cast<builtin::param>(ins->get_operator()).parameter;
                    if(not contains(params, param_name))
                        MIGRAPHX_THROW("Parameter not found: " + param_name);
                    auto param = params.at(param_name);
                    // TODO: may want to check correct number of dimensions and/or was within bounds
                    if(not ins->get_shape().any_of_dynamic() and
                       param.get_shape() != ins->get_shape())
                    {
                        MIGRAPHX_THROW("Incorrect shape {" + to_string(param.get_shape()) +
                                       "} for parameter: " + param_name +
                                       " should be: " + to_string(ins->get_shape()));
                    }
                    return param;
                }));
        }
        else if(name == "@outline")
        {
            results.insert_or_assign(
                ins, trace(ins, [&] { return argument{ins->get_shape(), nullptr}; }));
        }
        else if(name == "@return")
        {
            std::vector<argument> prog_outputs;
            std::transform(ins->inputs().begin(),
                           ins->inputs().end(),
                           std::back_inserter(prog_outputs),
                           [&](instruction_ref i) {
                               assert(results.find(i) != results.end());
                               return results[i];
                           });

            return prog_outputs;
        }