UdfCompiler Class Reference

#include <UDFCompiler.h>

Collaboration diagram for UdfCompiler:

Public Member Functions
	UdfCompiler (const std::string &)
int	compileUdf ()
const std::string &	getAstFileName () const

Private Member Functions
std::string	removeFileExtension (const std::string &path)
std::string	getFileExt (std::string &s)
int	parseToAst (const char *file_name)
std::string	genGpuIrFilename (const char *udf_file_name)
std::string	genCpuIrFilename (const char *udf_file_name)
int	compileToGpuByteCode (const char *udf_file_name, bool cpu_mode)
int	compileToCpuByteCode (const char *udf_file_name)
void	replaceExtn (std::string &s, const std::string &new_ext)
int	compileFromCommandLine (std::vector< const char * > &command_line)
void	readCompiledModules ()
void	readGpuCompiledModule ()
void	readCpuCompiledModule ()
int	compileForGpu ()

Private Attributes
std::string	udf_file_name_
std::string	udf_ast_file_name_

Detailed Description

Definition at line 51 of file UDFCompiler.h.

Constructor & Destructor Documentation

UdfCompiler::UdfCompiler

(

const std::string &

file_name

)

Definition at line 292 of file UDFCompiler.cpp.

References replaceExtn(), and udf_ast_file_name_.

    : udf_file_name_(file_name), udf_ast_file_name_(file_name) {
  replaceExtn(udf_ast_file_name_, "ast");
}

Here is the call graph for this function:

Member Function Documentation

int UdfCompiler::compileForGpu ( )

private

Definition at line 318 of file UDFCompiler.cpp.

References compileToGpuByteCode(), anonymous_namespace{UDFCompiler.cpp}::on_search_path(), and udf_file_name_.

Referenced by compileUdf().

                               {
  int gpu_compile_result = 1;

  if (on_search_path("nvcc")) {
    gpu_compile_result = compileToGpuByteCode(udf_file_name_.c_str(), false);
  }

  // If gpu compilation fails but cpu compilation has succeeded, try compiling
  // for the cpu with the assumption the user does not have the CUDA toolkit
  // installed
  if (gpu_compile_result != 0) {
    gpu_compile_result = compileToGpuByteCode(udf_file_name_.c_str(), true);
  }

  return gpu_compile_result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int UdfCompiler::compileFromCommandLine ( std::vector< const char * > &  command_line )

private

Definition at line 188 of file UDFCompiler.cpp.

References logger::FATAL, UdfClangDriver::getClangDriver(), LOG, and run_benchmark_import::res.

Referenced by compileToCpuByteCode(), and compileToGpuByteCode().

                                                                            {
  UdfClangDriver compiler_driver;
  auto the_driver(compiler_driver.getClangDriver());

  the_driver->CCPrintOptions = 0;
  std::unique_ptr<driver::Compilation> compilation(
      the_driver->BuildCompilation(command_line));

  if (!compilation) {
    LOG(FATAL) << "failed to build compilation object!\n";
  }

  llvm::SmallVector<std::pair<int, const driver::Command*>, 10> failing_commands;
  int res = the_driver->ExecuteCompilation(*compilation, failing_commands);

  if (res < 0) {
    for (const std::pair<int, const driver::Command*>& p : failing_commands) {
      if (p.first) {
        the_driver->generateCompilationDiagnostics(*compilation, *p.second);
      }
    }
  }

  return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int UdfCompiler::compileToCpuByteCode ( const char *  udf_file_name )

private

Definition at line 242 of file UDFCompiler.cpp.

References compileFromCommandLine(), and genCpuIrFilename().

Referenced by compileUdf().

                                                               {
  auto a_path = llvm::sys::findProgramByName("clang++");
  auto clang_path = a_path.get();

  std::string cpu_outName(genCpuIrFilename(udf_file_name));

  std::vector<const char*> command_line{clang_path.c_str(),
                                        "-c",
                                        "-O2",
                                        "-emit-llvm",
                                        "-o",
                                        cpu_outName.c_str(),
                                        "-std=c++14",
                                        udf_file_name};

  return compileFromCommandLine(command_line);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int UdfCompiler::compileToGpuByteCode ( const char *  udf_file_name, bool  cpu_mode  )

private

Definition at line 214 of file UDFCompiler.cpp.

References compileFromCommandLine(), and genGpuIrFilename().

Referenced by compileForGpu().

                                                                              {
  auto a_path = llvm::sys::findProgramByName("clang++");
  auto clang_path = a_path.get();

  std::string gpu_outName(genGpuIrFilename(udf_file_name));

  std::vector<const char*> command_line{clang_path.c_str(),
                                        "-c",
                                        "-O2",
                                        "-emit-llvm",
                                        "-o",
                                        gpu_outName.c_str(),
                                        "-std=c++14"};

  // If we are not compiling for cpu mode, then target the gpu
  // Otherwise assume we can generic ir that will
  // be translated to gpu code during target code generation
  if (!cpu_mode) {
    command_line.emplace_back("--cuda-gpu-arch=sm_30");
    command_line.emplace_back("--cuda-device-only");
    command_line.emplace_back("-xcuda");
  }

  command_line.emplace_back(udf_file_name);

  return compileFromCommandLine(command_line);
}

Here is the call graph for this function:

Here is the caller graph for this function:

int UdfCompiler::compileUdf

(

)

Definition at line 335 of file UDFCompiler.cpp.

References compileForGpu(), compileToCpuByteCode(), logger::FATAL, logger::INFO, LOG, anonymous_namespace{UDFCompiler.cpp}::on_search_path(), parseToAst(), readCpuCompiledModule(), readGpuCompiledModule(), and udf_file_name_.

                            {
  if (on_search_path("clang++")) {
    LOG(INFO) << "UDFCompiler filename to compiler: " << udf_file_name_ << std::endl;
    if (!boost::filesystem::exists(udf_file_name_)) {
      LOG(FATAL) << "User defined function file " << udf_file_name_ << " does not exist.";
      return 1;
    }

    auto ast_result = parseToAst(udf_file_name_.c_str());

    if (ast_result == 0) {
      // Compile udf file to generate cpu and gpu bytecode files

      int cpu_compile_result = compileToCpuByteCode(udf_file_name_.c_str());
#ifdef HAVE_CUDA
      int gpu_compile_result = 1;
#endif

      if (cpu_compile_result == 0) {
        readCpuCompiledModule();
#ifdef HAVE_CUDA
        gpu_compile_result = compileForGpu();

        if (gpu_compile_result == 0) {
          readGpuCompiledModule();
        } else {
          LOG(FATAL) << "Unable to compile UDF file for gpu" << std::endl;
          return 1;
        }
#endif
      } else {
        LOG(FATAL) << "Unable to compile UDF file for cpu" << std::endl;
        return 1;
      }
    } else {
      LOG(FATAL) << "Unable to create AST file for udf compilation" << std::endl;
      return 1;
    }
  } else {
    LOG(FATAL) << "Unable to compile udfs due to absence of clang++" << std::endl;
    return 1;
  }

  return 0;
}

Here is the call graph for this function:

std::string UdfCompiler::genCpuIrFilename ( const char *  udf_file_name )

private

Definition at line 181 of file UDFCompiler.cpp.

References removeFileExtension().

Referenced by compileToCpuByteCode(), and readCpuCompiledModule().

                                                                {
  std::string cpu_file_name(removeFileExtension(udf_fileName));

  cpu_file_name += "_cpu.bc";
  return cpu_file_name;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::string UdfCompiler::genGpuIrFilename ( const char *  udf_file_name )

private

Definition at line 174 of file UDFCompiler.cpp.

References removeFileExtension().

Referenced by compileToGpuByteCode(), and readGpuCompiledModule().

                                                                 {
  std::string gpu_file_name(removeFileExtension(udf_file_name));

  gpu_file_name += "_gpu.bc";
  return gpu_file_name;
}

Here is the call graph for this function:

Here is the caller graph for this function:

const std::string & UdfCompiler::getAstFileName

(

)

const

Definition at line 288 of file UDFCompiler.cpp.

References udf_ast_file_name_.

                                                   {
  return udf_ast_file_name_;
}

std::string UdfCompiler::getFileExt ( std::string &  s )

private

Definition at line 159 of file UDFCompiler.cpp.

Referenced by replaceExtn().

                                              {
  size_t i = s.rfind('.', s.length());
  if (1 != std::string::npos) {
    return (s.substr(i + 1, s.length() - i));
  }
}

Here is the caller graph for this function:

int UdfCompiler::parseToAst ( const char *  file_name )

private

Definition at line 260 of file UDFCompiler.cpp.

References error_code, UdfClangDriver::getClangDriver(), replaceExtn(), and ToolingSampleCategory().

Referenced by compileUdf().

                                                 {
  UdfClangDriver the_driver;
  std::string resource_path = the_driver.getClangDriver()->ResourceDir;
  std::string include_option =
      std::string("-I") + resource_path + std::string("/include");

  const char arg0[] = "astparser";
  const char* arg1 = file_name;
  const char arg2[] = "--";
  const char* arg3 = include_option.c_str();
  const char* arg_vector[] = {arg0, arg1, arg2, arg3};

  int num_args = sizeof(arg_vector) / sizeof(arg_vector[0]);
  CommonOptionsParser op(num_args, arg_vector, ToolingSampleCategory);
  ClangTool tool(op.getCompilations(), op.getSourcePathList());

  std::string out_name(file_name);
  std::string file_ext("ast");
  replaceExtn(out_name, file_ext);

  std::error_code out_error_info;
  llvm::raw_fd_ostream out_file(
      llvm::StringRef(out_name), out_error_info, llvm::sys::fs::F_None);

  auto factory = llvm::make_unique<ToolFactory>(out_file);
  return tool.run(factory.get());
}

Here is the call graph for this function:

Here is the caller graph for this function:

void UdfCompiler::readCompiledModules ( )

private

Definition at line 313 of file UDFCompiler.cpp.

References readCpuCompiledModule(), and readGpuCompiledModule().

                                      {
  readCpuCompiledModule();
  readGpuCompiledModule();
}

Here is the call graph for this function:

void UdfCompiler::readCpuCompiledModule ( )

private

Definition at line 297 of file UDFCompiler.cpp.

References genCpuIrFilename(), read_udf_cpu_module(), udf_file_name_, and VLOG.

Referenced by compileUdf(), and readCompiledModules().

                                        {
  std::string cpu_ir_file(genCpuIrFilename(udf_file_name_.c_str()));

  VLOG(1) << "UDFCompiler cpu bc file = " << cpu_ir_file << std::endl;

  read_udf_cpu_module(cpu_ir_file);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void UdfCompiler::readGpuCompiledModule ( )

private

Definition at line 305 of file UDFCompiler.cpp.

References genGpuIrFilename(), read_udf_gpu_module(), udf_file_name_, and VLOG.

Referenced by compileUdf(), and readCompiledModules().

                                        {
  std::string gpu_ir_file(genGpuIrFilename(udf_file_name_.c_str()));

  VLOG(1) << "UDFCompiler gpu bc file = " << gpu_ir_file << std::endl;

  read_udf_gpu_module(gpu_ir_file);
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::string UdfCompiler::removeFileExtension ( const std::string &  path )

private

Definition at line 146 of file UDFCompiler.cpp.

Referenced by genCpuIrFilename(), and genGpuIrFilename().

                                                                {
  if (path == "." || path == "..") {
    return path;
  }

  size_t pos = path.find_last_of("\\/.");
  if (pos != std::string::npos && path[pos] == '.') {
    return path.substr(0, pos);
  }

  return path;
}

Here is the caller graph for this function:

void UdfCompiler::replaceExtn ( std::string &  s, const std::string &  new_ext  )

private

Definition at line 166 of file UDFCompiler.cpp.

References getFileExt().

Referenced by parseToAst(), and UdfCompiler().

                                                                    {
  std::string::size_type i = s.rfind('.', s.length());

  if (i != std::string::npos) {
    s.replace(i + 1, getFileExt(s).length(), new_ext);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

std::string UdfCompiler::udf_ast_file_name_

private

Definition at line 74 of file UDFCompiler.h.

Referenced by getAstFileName(), and UdfCompiler().

std::string UdfCompiler::udf_file_name_

private

Definition at line 73 of file UDFCompiler.h.

Referenced by compileForGpu(), compileUdf(), readCpuCompiledModule(), and readGpuCompiledModule().

---

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

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