eval.hpp

Go to the documentation of this file.

#include "ade/traveler.hpp"

#include "llo/generated/opmap.hpp"

#include "llo/operator.hpp"

#ifndef LLO_EVAL_HPP
#define LLO_EVAL_HPP

namespace llo
{

struct Evaluator final : public ade::iTraveler
{
    Evaluator (age::_GENERATED_DTYPE dtype) : dtype_(dtype) {}

    void visit (ade::iLeaf* leaf) override
    {
        const char* data = (const char*) leaf->data();
        age::_GENERATED_DTYPE dtype = (age::_GENERATED_DTYPE) leaf->type_code();
        const ade::Shape& shape = leaf->shape();
        out_ = GenericData(shape, dtype_);
        out_.copyover(data, dtype);
    }

    void visit (ade::iFunctor* func) override
    {
        age::_GENERATED_OPCODE opcode = (age::_GENERATED_OPCODE)
            func->get_opcode().code_;
        out_ = GenericData(func->shape(), dtype_);

        ade::ArgsT children = func->get_children();
        uint8_t nargs = children.size();
        DataArgsT argdata = DataArgsT(nargs);
        if (func->get_opcode().code_ == age::RAND_BINO)
        {
            if (nargs != 2)
            {
                logs::fatalf("cannot RAND_BINO without exactly 2 arguments: "
                    "using %d arguments", nargs);
            }
            Evaluator left_eval(dtype_);
            children[0].get_tensor()->accept(left_eval);
            argdata[0] = {
                left_eval.out_.data_,
                left_eval.out_.shape_,
                children[0].get_coorder(),
                children[0].map_io(),
            };

            Evaluator right_eval(age::DOUBLE);
            children[1].get_tensor()->accept(right_eval);
            argdata[1] = DataArg{
                right_eval.out_.data_,
                right_eval.out_.shape_,
                children[1].get_coorder(),
                children[1].map_io(),
            };
        }
        else
        {
            for (uint8_t i = 0; i < nargs; ++i)
            {
                Evaluator evaler(dtype_);
                children[i].get_tensor()->accept(evaler);
                argdata[i] = DataArg{
                    evaler.out_.data_,
                    evaler.out_.shape_,
                    children[i].get_coorder(),
                    children[i].map_io(),
                };
            }
        }

        op_exec(opcode, out_.dtype_, out_.data_.get(), out_.shape_, argdata);
    }

    GenericData out_;

private:
    age::_GENERATED_DTYPE dtype_;
};

GenericData eval (ade::TensptrT tens, age::_GENERATED_DTYPE dtype);

}

#endif // LLO_EVAL_HPP