ReductionInterpreterImpl Class Reference

Public Member Functions
	ReductionInterpreterImpl (const std::vector< ReductionInterpreter::EvalValue > &vars)
std::optional < ReductionInterpreter::EvalValue >	ret () const

Static Public Member Functions
static void	runGetElementPtr (const Instruction *instruction, ReductionInterpreterImpl *interpreter)
static void	runLoad (const Instruction *instruction, ReductionInterpreterImpl *interpreter)
static void	runICmp (const Instruction *instruction, ReductionInterpreterImpl *interpreter)
static void	runBinaryOperator (const Instruction *instruction, ReductionInterpreterImpl *interpreter)
static void	runCast (const Instruction *instruction, ReductionInterpreterImpl *interpreter)
static void	runRet (const Instruction *instruction, ReductionInterpreterImpl *interpreter)
static void	runCall (const Instruction *instruction, ReductionInterpreterImpl *interpreter)
static void	runExternalCall (const Instruction *instruction, ReductionInterpreterImpl *interpreter)
static void	runAlloca (const Instruction *instruction, ReductionInterpreterImpl *interpreter)
static void	runMemCpy (const Instruction *instruction, ReductionInterpreterImpl *interpreter)
static void	runReturnEarly (const Instruction *instruction, ReductionInterpreterImpl *interpreter)
static void	runFor (const Instruction *instruction, ReductionInterpreterImpl *interpreter)

Private Member Functions
void	setVar (const Value *var, ReductionInterpreter::EvalValue value)

Static Private Member Functions
template<class Call >
static std::vector < ReductionInterpreter::EvalValue >	getCallInputs (const Call *call, const ReductionInterpreterImpl *interpreter)
template<class Call >
static StubGenerator::Stub	bindStub (const Call *call)

Private Attributes
std::vector < ReductionInterpreter::EvalValue >	vars_
std::vector< std::vector < int8_t > >	alloca_buffers_
std::optional < ReductionInterpreter::EvalValue >	ret_ = std::nullopt

Detailed Description

Definition at line 56 of file ResultSetReductionInterpreter.cpp.

Constructor & Destructor Documentation

ReductionInterpreterImpl::ReductionInterpreterImpl ( const std::vector< ReductionInterpreter::EvalValue > &  vars )

inline

Definition at line 58 of file ResultSetReductionInterpreter.cpp.

      : vars_(vars) {}

Member Function Documentation

template<class Call >

static StubGenerator::Stub ReductionInterpreterImpl::bindStub ( const Call *  call )

inlinestaticprivate

Definition at line 337 of file ResultSetReductionInterpreter.cpp.

References Call::arguments(), Call::cached_callee(), Call::callee_name(), CHECK(), Call::external(), StubGenerator::generateStub(), anonymous_namespace{ResultSetReductionInterpreter.cpp}::get_value_types(), Call::set_cached_callee(), and Value::type().

                                                      {
    const auto func_ptr =
        call->cached_callee()
            ? reinterpret_cast<StubGenerator::Stub>(call->cached_callee())
            : StubGenerator::generateStub(call->callee_name(),
                                          get_value_types(call->arguments()),
                                          call->type(),
                                          call->external());
    CHECK(func_ptr);
    call->set_cached_callee(reinterpret_cast<void*>(func_ptr));
    return func_ptr;
  }

Here is the call graph for this function:

template<class Call >

static std::vector<ReductionInterpreter::EvalValue> ReductionInterpreterImpl::getCallInputs ( const Call *  call, const ReductionInterpreterImpl *  interpreter  )

inlinestaticprivate

Definition at line 324 of file ResultSetReductionInterpreter.cpp.

References Call::arguments(), and vars_.

                                                   {
    std::vector<ReductionInterpreter::EvalValue> inputs;
    inputs.reserve(interpreter->vars_.size());
    for (const auto argument : call->arguments()) {
      inputs.push_back(interpreter->vars_[argument->id()]);
    }
    return inputs;
  }

Here is the call graph for this function:

std::optional<ReductionInterpreter::EvalValue> ReductionInterpreterImpl::ret ( ) const

inline

Definition at line 61 of file ResultSetReductionInterpreter.cpp.

References ret_.

{ return ret_; }

static void ReductionInterpreterImpl::runAlloca ( const Instruction *  instruction, ReductionInterpreterImpl *  interpreter  )

inlinestatic

Definition at line 252 of file ResultSetReductionInterpreter.cpp.

References alloca_buffers_, CHECK(), anonymous_namespace{ResultSetReductionInterpreter.cpp}::get_element_size(), is_integer_type(), ReductionInterpreter::EvalValue::mutable_ptr, ret_, setVar(), and vars_.

Referenced by Alloca::run().

                                                               {
    CHECK(!interpreter->ret_) << "Function has already returned";
    const auto alloca = static_cast<const Alloca*>(instruction);
    const auto element_size = get_element_size(alloca->type());
    CHECK(is_integer_type(alloca->array_size()->type()));
    const auto array_size = interpreter->vars_[alloca->array_size()->id()];
    interpreter->alloca_buffers_.emplace_back(element_size * array_size.int_val);
    interpreter->setVar(alloca,
                        ReductionInterpreter::EvalValue{
                            .mutable_ptr = interpreter->alloca_buffers_.back().data()});
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static void ReductionInterpreterImpl::runBinaryOperator ( const Instruction *  instruction, ReductionInterpreterImpl *  interpreter  )

inlinestatic

Definition at line 148 of file ResultSetReductionInterpreter.cpp.

References BinaryOperator::Add, CHECK(), logger::FATAL, ReductionInterpreter::EvalValue::int_val, is_integer_type(), LOG, BinaryOperator::Mul, run_benchmark_import::result, ret_, setVar(), and vars_.

Referenced by BinaryOperator::run().

                                                                       {
    CHECK(!interpreter->ret_) << "Function has already returned";
    const auto binary_operator = static_cast<const BinaryOperator*>(instruction);
    CHECK(is_integer_type(binary_operator->type()));
    const auto lhs = interpreter->vars_[binary_operator->lhs()->id()];
    const auto rhs = interpreter->vars_[binary_operator->rhs()->id()];
    int64_t result = 0;
    switch (binary_operator->op()) {
      case BinaryOperator::BinaryOp::Add: {
        result = lhs.int_val + rhs.int_val;
        break;
      }
      case BinaryOperator::BinaryOp::Mul: {
        result = lhs.int_val * rhs.int_val;
        break;
      }
      default: {
        LOG(FATAL) << "Binary operator not supported: "
                   << static_cast<int>(binary_operator->op());
      }
    }
    interpreter->setVar(binary_operator,
                        ReductionInterpreter::EvalValue{.int_val = result});
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static void ReductionInterpreterImpl::runCall ( const Instruction *  instruction, ReductionInterpreterImpl *  interpreter  )

inlinestatic

Definition at line 213 of file ResultSetReductionInterpreter.cpp.

References CHECK(), ret_, ReductionInterpreter::run(), setVar(), and Void.

Referenced by Call::run().

                                                             {
    CHECK(!interpreter->ret_) << "Function has already returned";
    const auto call = static_cast<const Call*>(instruction);
    if (call->callee()) {
      // Call one of the functions generated to implement reduction.
      const auto inputs = getCallInputs(call, interpreter);
      auto ret = ReductionInterpreter::run(call->callee(), inputs);
      if (call->type() != Type::Void) {
        // Assign the returned value.
        interpreter->setVar(call, ret);
      }
    } else {
      // Call an internal runtime function.
      const auto func_ptr = bindStub(call);
      const auto inputs = getCallInputs(call, interpreter);
      ReductionInterpreter::EvalValue ret;
      func_ptr(&ret, &inputs);
      if (call->type() != Type::Void) {
        // Assign the returned value.
        interpreter->setVar(call, ret);
      }
    }
    return;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static void ReductionInterpreterImpl::runCast ( const Instruction *  instruction, ReductionInterpreterImpl *  interpreter  )

inlinestatic

Definition at line 174 of file ResultSetReductionInterpreter.cpp.

References Cast::BitCast, CHECK(), logger::FATAL, ReductionInterpreter::EvalValue::int_val, is_integer_type(), is_pointer_type(), LOG, ReductionInterpreter::EvalValue::ptr, ret_, setVar(), Cast::SExt, Cast::Trunc, and vars_.

Referenced by Cast::run().

                                                             {
    CHECK(!interpreter->ret_) << "Function has already returned";
    const auto cast = static_cast<const Cast*>(instruction);
    const auto source = interpreter->vars_[cast->source()->id()];
    // Given that evaluated values store all values as int64_t or void*, Trunc and SExt
    // are no-op. The information about the type is already part of the destination.
    switch (cast->op()) {
      case Cast::CastOp::Trunc:
      case Cast::CastOp::SExt: {
        CHECK(is_integer_type(cast->source()->type()));
        interpreter->setVar(cast,
                            ReductionInterpreter::EvalValue{.int_val = source.int_val});
        break;
      }
      case Cast::CastOp::BitCast: {
        CHECK(is_pointer_type(cast->source()->type()));
        interpreter->setVar(cast, ReductionInterpreter::EvalValue{.ptr = source.ptr});
        break;
      }
      default: {
        LOG(FATAL) << "Cast operator not supported: " << static_cast<int>(cast->op());
      }
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static void ReductionInterpreterImpl::runExternalCall ( const Instruction *  instruction, ReductionInterpreterImpl *  interpreter  )

inlinestatic

Definition at line 239 of file ResultSetReductionInterpreter.cpp.

References ExternalCall::arguments(), CHECK(), anonymous_namespace{ResultSetReductionInterpreter.cpp}::get_value_types(), ret_, and setVar().

Referenced by ExternalCall::run().

                                                                     {
    CHECK(!interpreter->ret_) << "Function has already returned";
    const auto external_call = static_cast<const ExternalCall*>(instruction);
    const auto& arguments = external_call->arguments();
    const auto argument_types = get_value_types(arguments);
    const auto func_ptr = bindStub(external_call);
    const auto inputs = getCallInputs(external_call, interpreter);
    ReductionInterpreter::EvalValue output;
    func_ptr(&output, &inputs);
    interpreter->setVar(external_call, output);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static void ReductionInterpreterImpl::runFor ( const Instruction *  instruction, ReductionInterpreterImpl *  interpreter  )

inlinestatic

Definition at line 293 of file ResultSetReductionInterpreter.cpp.

References alloca_buffers_, CHECK(), is_integer_type(), ret_, ReductionInterpreter::run(), and vars_.

Referenced by For::run().

                                                            {
    CHECK(!interpreter->ret_) << "Function has already returned";
    const size_t saved_alloca_count = interpreter->alloca_buffers_.size();
    const auto for_loop = static_cast<const For*>(instruction);
    CHECK(is_integer_type(for_loop->start()->type()));
    CHECK(is_integer_type(for_loop->end()->type()));
    const auto start = interpreter->vars_[for_loop->start()->id()];
    const auto end = interpreter->vars_[for_loop->end()->id()];
    for (int64_t i = start.int_val; i < end.int_val; ++i) {
      // The start and end indices are absolute, but the iteration happens from 0.
      // Subtract the start index before setting the iterator.
      interpreter->vars_[for_loop->iter()->id()] = {.int_val = i - start.int_val};
      auto ret = ReductionInterpreter::run(for_loop->body(), interpreter->vars_);
      if (ret) {
        interpreter->ret_ = *ret;
        break;
      }
    }
    // Pop all the alloca buffers allocated by the code in the loop.
    interpreter->alloca_buffers_.resize(saved_alloca_count);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static void ReductionInterpreterImpl::runGetElementPtr ( const Instruction *  instruction, ReductionInterpreterImpl *  interpreter  )

inlinestatic

Definition at line 64 of file ResultSetReductionInterpreter.cpp.

References CHECK(), anonymous_namespace{ResultSetReductionInterpreter.cpp}::get_element_size(), ReductionInterpreter::EvalValue::ptr, ret_, setVar(), and vars_.

Referenced by GetElementPtr::run().

                                                                      {
    CHECK(!interpreter->ret_) << "Function has already returned";
    const auto gep = static_cast<const GetElementPtr*>(instruction);
    const auto element_size = get_element_size(gep->base()->type());
    const auto base = interpreter->vars_[gep->base()->id()];
    const auto index = interpreter->vars_[gep->index()->id()];
    auto result_ptr =
        reinterpret_cast<const int8_t*>(base.ptr) + index.int_val * element_size;
    interpreter->setVar(gep, ReductionInterpreter::EvalValue{.ptr = result_ptr});
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static void ReductionInterpreterImpl::runICmp ( const Instruction *  instruction, ReductionInterpreterImpl *  interpreter  )

inlinestatic

Definition at line 123 of file ResultSetReductionInterpreter.cpp.

References CHECK(), ICmp::EQ, logger::FATAL, ReductionInterpreter::EvalValue::int_val, is_integer_type(), LOG, ICmp::NE, run_benchmark_import::result, ret_, setVar(), and vars_.

Referenced by ICmp::run().

                                                             {
    CHECK(!interpreter->ret_) << "Function has already returned";
    const auto icmp = static_cast<const ICmp*>(instruction);
    CHECK(is_integer_type(icmp->lhs()->type()));
    CHECK(is_integer_type(icmp->rhs()->type()));
    const auto lhs = interpreter->vars_[icmp->lhs()->id()];
    const auto rhs = interpreter->vars_[icmp->rhs()->id()];
    bool result = false;
    switch (icmp->predicate()) {
      case ICmp::Predicate::EQ: {
        result = lhs.int_val == rhs.int_val;
        break;
      }
      case ICmp::Predicate::NE: {
        result = lhs.int_val != rhs.int_val;
        break;
      }
      default: {
        LOG(FATAL) << "Predicate not supported: " << static_cast<int>(icmp->predicate());
      }
    }
    interpreter->setVar(icmp, ReductionInterpreter::EvalValue{.int_val = result});
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static void ReductionInterpreterImpl::runLoad ( const Instruction *  instruction, ReductionInterpreterImpl *  interpreter  )

inlinestatic

Definition at line 76 of file ResultSetReductionInterpreter.cpp.

References CHECK(), ReductionInterpreter::EvalValue::double_val, DoublePtr, logger::FATAL, ReductionInterpreter::EvalValue::float_val, FloatPtr, Int32Ptr, Int64Ptr, Int64PtrPtr, Int8Ptr, ReductionInterpreter::EvalValue::int_val, is_pointer_type(), LOG, ReductionInterpreter::EvalValue::ptr, ret_, setVar(), Load::source(), Value::type(), and vars_.

Referenced by Load::run().

                                                             {
    CHECK(!interpreter->ret_) << "Function has already returned";
    const auto load = static_cast<const Load*>(instruction);
    const auto source_type = load->source()->type();
    CHECK(is_pointer_type(source_type));
    const auto source = interpreter->vars_[load->source()->id()];
    switch (source_type) {
      case Type::Int8Ptr: {
        const auto int_val = *reinterpret_cast<const int8_t*>(source.ptr);
        interpreter->setVar(load, ReductionInterpreter::EvalValue{.int_val = int_val});
        break;
      }
      case Type::Int32Ptr: {
        const auto int_val = *reinterpret_cast<const int32_t*>(source.ptr);
        interpreter->setVar(load, ReductionInterpreter::EvalValue{.int_val = int_val});
        break;
      }
      case Type::Int64Ptr: {
        const auto int_val = *reinterpret_cast<const int64_t*>(source.ptr);
        interpreter->setVar(load, ReductionInterpreter::EvalValue{.int_val = int_val});
        break;
      }
      case Type::FloatPtr: {
        const auto float_val = *reinterpret_cast<const float*>(source.ptr);
        interpreter->setVar(load,
                            ReductionInterpreter::EvalValue{.float_val = float_val});
        break;
      }
      case Type::DoublePtr: {
        const auto double_val = *reinterpret_cast<const double*>(source.ptr);
        interpreter->setVar(load,
                            ReductionInterpreter::EvalValue{.double_val = double_val});
        break;
      }
      case Type::Int64PtrPtr: {
        const auto int_ptr_val = *reinterpret_cast<const int64_t* const*>(source.ptr);
        interpreter->setVar(load, ReductionInterpreter::EvalValue{.ptr = int_ptr_val});
        break;
      }
      default: {
        LOG(FATAL) << "Source pointer type not supported: "
                   << static_cast<int>(source_type);
      }
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static void ReductionInterpreterImpl::runMemCpy ( const Instruction *  instruction, ReductionInterpreterImpl *  interpreter  )

inlinestatic

Definition at line 265 of file ResultSetReductionInterpreter.cpp.

References CHECK(), run_benchmark_import::dest, is_integer_type(), is_pointer_type(), ret_, and vars_.

Referenced by MemCpy::run().

                                                               {
    CHECK(!interpreter->ret_) << "Function has already returned";
    const auto memcpy = static_cast<const MemCpy*>(instruction);
    CHECK(is_pointer_type(memcpy->dest()->type()));
    CHECK(is_pointer_type(memcpy->source()->type()));
    CHECK(is_integer_type(memcpy->size()->type()));
    const auto dest = interpreter->vars_[memcpy->dest()->id()];
    const auto source = interpreter->vars_[memcpy->source()->id()];
    const auto size = interpreter->vars_[memcpy->size()->id()];
    ::memcpy(dest.mutable_ptr, source.ptr, size.int_val);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static void ReductionInterpreterImpl::runRet ( const Instruction *  instruction, ReductionInterpreterImpl *  interpreter  )

inlinestatic

Definition at line 200 of file ResultSetReductionInterpreter.cpp.

References CHECK(), ret_, vars_, and Void.

Referenced by Ret::run().

                                                            {
    CHECK(!interpreter->ret_) << "Function has already returned";
    const auto ret = static_cast<const Ret*>(instruction);
    if (ret->type() == Type::Void) {
      // Even if the returned type is void, the return value still needs to be set to
      // something to inform the caller that it should stop evaluating.
      interpreter->ret_ = ReductionInterpreter::EvalValue{};
    } else {
      interpreter->ret_ = interpreter->vars_[ret->value()->id()];
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static void ReductionInterpreterImpl::runReturnEarly ( const Instruction *  instruction, ReductionInterpreterImpl *  interpreter  )

inlinestatic

Definition at line 278 of file ResultSetReductionInterpreter.cpp.

References CHECK(), error_code, Int1, ReductionInterpreter::EvalValue::int_val, ret_, and vars_.

Referenced by ReturnEarly::run().

                                                                    {
    CHECK(!interpreter->ret_) << "Function has already returned";
    const auto ret_early = static_cast<const ReturnEarly*>(instruction);
    CHECK(ret_early->cond()->type() == Type::Int1);
    const auto cond = interpreter->vars_[ret_early->cond()->id()];

    auto error_code = ret_early->error_code();

    if (cond.int_val) {
      auto rc = interpreter->vars_[error_code->id()].int_val;
      interpreter->ret_ = ReductionInterpreter::EvalValue{.int_val = rc};
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

void ReductionInterpreterImpl::setVar ( const Value *  var, ReductionInterpreter::EvalValue  value  )

inlineprivate

Definition at line 318 of file ResultSetReductionInterpreter.cpp.

References Value::id().

Referenced by runAlloca(), runBinaryOperator(), runCall(), runCast(), runExternalCall(), runGetElementPtr(), runICmp(), and runLoad().

                                                                     {
    vars_[var->id()] = value;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

std::vector<std::vector<int8_t> > ReductionInterpreterImpl::alloca_buffers_

private

Definition at line 353 of file ResultSetReductionInterpreter.cpp.

Referenced by runAlloca(), and runFor().

std::optional<ReductionInterpreter::EvalValue> ReductionInterpreterImpl::ret_ = std::nullopt

private

Definition at line 355 of file ResultSetReductionInterpreter.cpp.

Referenced by ret(), runAlloca(), runBinaryOperator(), runCall(), runCast(), runExternalCall(), runFor(), runGetElementPtr(), runICmp(), runLoad(), runMemCpy(), runRet(), and runReturnEarly().

std::vector<ReductionInterpreter::EvalValue> ReductionInterpreterImpl::vars_

private

Definition at line 351 of file ResultSetReductionInterpreter.cpp.

Referenced by getCallInputs(), runAlloca(), runBinaryOperator(), runCast(), runFor(), runGetElementPtr(), runICmp(), runLoad(), runMemCpy(), runRet(), and runReturnEarly().

---

The documentation for this class was generated from the following file:

• /home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/ResultSetReductionInterpreter.cpp