anonymous_namespace{JoinLoopTest.cpp} Namespace Reference

Functions
void	verify_function_ir (const llvm::Function *func)
llvm::Value *	emit_external_call (const std::string &fname, llvm::Type *ret_type, const std::vector< llvm::Value * > args, llvm::Module *llvm_module, llvm::IRBuilder<> &builder)
llvm::Function *	create_loop_test_function (llvm::LLVMContext &context, llvm::Module *llvm_module, const std::vector< JoinLoop > &join_loops)
std::unique_ptr< llvm::Module >	create_loop_test_module ()
std::pair< void *, std::unique_ptr < llvm::ExecutionEngine > >	native_codegen (std::unique_ptr< llvm::Module > &llvm_module, llvm::Function *func)
std::vector< JoinLoop >	generate_descriptors (const unsigned mask, const unsigned cond_mask, const std::vector< int64_t > &upper_bounds)

Variables
llvm::LLVMContext	g_global_context

Function Documentation

llvm::Function* anonymous_namespace{JoinLoopTest.cpp}::create_loop_test_function	(	llvm::LLVMContext &	context,
		llvm::Module *	llvm_module,
		const std::vector< JoinLoop > &	join_loops
	)

Definition at line 73 of file JoinLoopTest.cpp.

References run_benchmark_import::args, JoinLoop::codegen(), emit_external_call(), and verify_function_ir().

Referenced by main().

                                                                                 {
  std::vector<llvm::Type*> argument_types;
  const auto ft =
      llvm::FunctionType::get(llvm::Type::getVoidTy(context), argument_types, false);
  const auto func = llvm::Function::Create(
      ft, llvm::Function::ExternalLinkage, "loop_test_func", llvm_module);
  const auto entry_bb = llvm::BasicBlock::Create(context, "entry", func);
  const auto exit_bb = llvm::BasicBlock::Create(context, "exit", func);
  llvm::IRBuilder<> builder(context);
  builder.SetInsertPoint(exit_bb);
  builder.CreateRetVoid();
  const auto loop_body_bb = JoinLoop::codegen(
      join_loops,
      [&builder, llvm_module](const std::vector<llvm::Value*>& iterators) {
        const auto loop_body_bb = llvm::BasicBlock::Create(
            builder.getContext(), "loop_body", builder.GetInsertBlock()->getParent());
        builder.SetInsertPoint(loop_body_bb);
        const std::vector<llvm::Value*> args(iterators.begin() + 1, iterators.end());
        emit_external_call("print_iterators",
                           llvm::Type::getVoidTy(builder.getContext()),
                           args,
                           llvm_module,
                           builder);
        return loop_body_bb;
      },
      nullptr,
      exit_bb,
      builder);
  builder.SetInsertPoint(entry_bb);
  builder.CreateBr(loop_body_bb);
  verify_function_ir(func);
  return func;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::unique_ptr<llvm::Module> anonymous_namespace{JoinLoopTest.cpp}::create_loop_test_module

(

)

Definition at line 109 of file JoinLoopTest.cpp.

References anonymous_namespace{LLVMGlobalContext.cpp}::g_global_context.

Referenced by main().

                                                    {
  return std::make_unique<llvm::Module>("Nested loops JIT", g_global_context);
}

Here is the caller graph for this function:

llvm::Value* anonymous_namespace{JoinLoopTest.cpp}::emit_external_call	(	const std::string &	fname,
		llvm::Type *	ret_type,
		const std::vector< llvm::Value * >	args,
		llvm::Module *	llvm_module,
		llvm::IRBuilder<> &	builder
	)

Definition at line 55 of file JoinLoopTest.cpp.

References CHECK, CHECK_EQ, and run_benchmark_import::result.

Referenced by create_loop_test_function().

                                                          {
  std::vector<llvm::Type*> arg_types;
  for (const auto arg : args) {
    arg_types.push_back(arg->getType());
  }
  auto func_ty = llvm::FunctionType::get(ret_type, arg_types, false);
  auto func_p = llvm_module->getOrInsertFunction(fname, func_ty);
  CHECK(func_p);
  llvm::Value* result = builder.CreateCall(func_p, args);
  // check the assumed type
  CHECK_EQ(result->getType(), ret_type);
  return result;
}

Here is the caller graph for this function:

std::vector<JoinLoop> anonymous_namespace{JoinLoopTest.cpp}::generate_descriptors	(	const unsigned	mask,
		const unsigned	cond_mask,
		const std::vector< int64_t > &	upper_bounds
	)

Definition at line 142 of file JoinLoopTest.cpp.

References CHECK, CHECK_EQ, anonymous_namespace{LLVMGlobalContext.cpp}::g_global_context, INNER, ll_int(), Singleton, JoinLoopDomain::slot_lookup_result, to_string(), JoinLoopDomain::upper_bound, gpu_enabled::upper_bound(), and UpperBound.

Referenced by main().

                                                                                   {
  std::vector<JoinLoop> join_loops;
  size_t cond_idx{0};
  for (size_t i = 0; i < upper_bounds.size(); ++i) {
    if (mask & (1 << i)) {
      const bool cond_is_true = cond_mask & (1 << cond_idx);
      join_loops.emplace_back(
          JoinLoopKind::Singleton,
          JoinType::INNER,
          [i, cond_is_true](const std::vector<llvm::Value*>& v) {
            CHECK_EQ(i + 1, v.size());
            CHECK(!v.front());
            JoinLoopDomain domain{{0}};
            domain.slot_lookup_result = cond_is_true
                                            ? ll_int(int64_t(99), g_global_context)
                                            : ll_int(int64_t(-1), g_global_context);
            return domain;
          },
          nullptr,
          nullptr,
          nullptr,
          false,
          "i" + std::to_string(i));
      ++cond_idx;
    } else {
      const auto upper_bound = upper_bounds[i];
      join_loops.emplace_back(
          JoinLoopKind::UpperBound,
          JoinType::INNER,
          [i, upper_bound](const std::vector<llvm::Value*>& v) {
            CHECK_EQ(i + 1, v.size());
            CHECK(!v.front());
            JoinLoopDomain domain{{0}};
            domain.upper_bound = ll_int<int64_t>(upper_bound, g_global_context);
            return domain;
          },
          nullptr,
          nullptr,
          nullptr,
          false,
          "i" + std::to_string(i));
    }
  }
  return join_loops;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::pair<void*, std::unique_ptr<llvm::ExecutionEngine> > anonymous_namespace{JoinLoopTest.cpp}::native_codegen	(	std::unique_ptr< llvm::Module > &	llvm_module,
		llvm::Function *	func
	)

Definition at line 113 of file JoinLoopTest.cpp.

References CHECK.

Referenced by main().

                        {
  llvm::ExecutionEngine* execution_engine{nullptr};

  auto init_err = llvm::InitializeNativeTarget();
  CHECK(!init_err);

  llvm::InitializeAllTargetMCs();
  llvm::InitializeNativeTargetAsmPrinter();
  llvm::InitializeNativeTargetAsmParser();

  std::string err_str;
  llvm::EngineBuilder eb(std::move(llvm_module));
  eb.setErrorStr(&err_str);
  eb.setEngineKind(llvm::EngineKind::JIT);
  llvm::TargetOptions to;
  to.EnableFastISel = true;
  eb.setTargetOptions(to);
  execution_engine = eb.create();
  CHECK(execution_engine);

  execution_engine->finalizeObject();
  auto native_code = execution_engine->getPointerToFunction(func);

  CHECK(native_code);
  return {native_code, std::unique_ptr<llvm::ExecutionEngine>(execution_engine)};
}

Here is the caller graph for this function:

void anonymous_namespace{JoinLoopTest.cpp}::verify_function_ir

(

const llvm::Function *

func

)

Definition at line 46 of file JoinLoopTest.cpp.

References logger::FATAL, and LOG.

                                                  {
  std::stringstream err_ss;
  llvm::raw_os_ostream err_os(err_ss);
  if (llvm::verifyFunction(*func, &err_os)) {
    func->print(llvm::outs());
    LOG(FATAL) << err_ss.str();
  }
}

Variable Documentation

llvm::LLVMContext anonymous_namespace{JoinLoopTest.cpp}::g_global_context

Definition at line 44 of file JoinLoopTest.cpp.