UdfCompiler Class Reference

#include <UdfCompiler.h>

Collaboration diagram for UdfCompiler:

Public Member Functions
	UdfCompiler (CudaMgr_Namespace::NvidiaDeviceArch target_arch, const std::string &clang_path_override="")
	UdfCompiler (CudaMgr_Namespace::NvidiaDeviceArch target_arch, const std::string &clang_path_override, const std::vector< std::string > clang_options)
std::pair< std::string, std::string >	compileUdf (const std::string &udf_file_name) const

Static Public Member Functions
static std::string	getAstFileName (const std::string &udf_file_name)

Private Member Functions
void	generateAST (const std::string &file_name) const
std::string	compileToLLVMIR (const std::string &udf_file_name) const
int	compileFromCommandLine (const std::vector< std::string > &command_line) const

Static Private Member Functions
static std::string	genLLVMIRFilename (const std::string &udf_file_name)
static std::string	genNVVMIRFilename (const std::string &udf_file_name)

Private Attributes
std::string	clang_path_
std::vector< std::string >	clang_options_

Detailed Description

Driver for calling clang/clang++ to compile C++ programs to LLVM IR for use as a UDF. Default initialization will find Clang using the clang library invocations. An optional clang override and additional arguments to the clang binary can be added. Once initialized the class holds the state for calling clang until destruction.

Definition at line 31 of file UdfCompiler.h.

Constructor & Destructor Documentation

UdfCompiler::UdfCompiler	(	CudaMgr_Namespace::NvidiaDeviceArch	target_arch,
		const std::string &	clang_path_override = ""
	)

Definition at line 293 of file UdfCompiler.cpp.

References clang_options_.

    : clang_path_(get_clang_path(clang_path_override))
#ifdef HAVE_CUDA
    , target_arch_(target_arch)
#endif
{
  // To ifguard unsupported code included in heavydbTypes.h (i.e. <shared_mutex>)
  clang_options_.emplace_back(std::string("-D UDF_COMPILED"));
}

UdfCompiler::UdfCompiler	(	CudaMgr_Namespace::NvidiaDeviceArch	target_arch,
		const std::string &	clang_path_override,
		const std::vector< std::string >	clang_options
	)

Definition at line 304 of file UdfCompiler.cpp.

References clang_options_.

    : clang_path_(get_clang_path(clang_path_override))
    , clang_options_(clang_options)
#ifdef HAVE_CUDA
    , target_arch_(target_arch)
#endif
{
  // To ifguard unsupported code included in heavydbTypes.h (i.e. <shared_mutex>)
  clang_options_.emplace_back(std::string("-D UDF_COMPILED"));
}

Member Function Documentation

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

private

Formulate the full compile command and call the compiler.

Definition at line 387 of file UdfCompiler.cpp.

References CHECK_EQ, clang_options_, clang_path_, anonymous_namespace{UdfCompiler.cpp}::exec_output(), logger::init(), run_benchmark_import::res, and shared::transform().

Referenced by compileToLLVMIR().

                                                    {
  UdfClangDriver compiler_driver = UdfClangDriver::init(clang_path_);
  auto the_driver(compiler_driver.getClangDriver());

  std::vector<const char*> clang_command_opts;
  clang_command_opts.reserve(command_line.size() + clang_options_.size());
  // add required options first
  std::transform(std::begin(command_line),
                 std::end(command_line),
                 std::back_inserter(clang_command_opts),
                 [&](const std::string& str) { return str.c_str(); });

  // If there were additional clang options passed to the system, append them here
  if (!clang_options_.empty()) {
    std::transform(std::begin(clang_options_),
                   std::end(clang_options_),
                   std::back_inserter(clang_command_opts),
                   [&](const std::string& str) { return str.c_str(); });
  }

  std::unique_ptr<driver::Compilation> compilation(
      the_driver->BuildCompilation(clang_command_opts));
  if (!compilation) {
    throw std::runtime_error("failed to build compilation object!");
  }
  auto [clang_version_major, clang_version_minor, clang_version_patchlevel] =
      compiler_driver.getClangVersion();
  if (clang_version_major != CLANG_VERSION_MAJOR
      // mismatch of clang driver and compulier versions requires
      // modified workflow that removes incompatible driver flags for
      // compiler.
      || CLANG_VERSION_MAJOR == 9
      // clang driver 9 requires cudatoolkit 8 that we don't support,
      // hence switching to modified clang compiler 9 workflow that is
      // able to produce bytecode to GPU when using cudatoolkit 11.
  ) {
    /* Fix incompatibilities when driver and clang versions differ.
     */
    auto& jobs = compilation->getJobs();
    CHECK_EQ(jobs.size(), size_t(1));
    auto& job = *jobs.begin();

    std::string cmd = job.getExecutable();
    int skip = 0;
    std::string last = "";

    for (auto& arg : job.getArguments()) {
      const std::string& s = arg;
      if (skip > 0) {
        skip--;
        last = s;
        continue;
      }

      // inclusion of __clang_cuda_runtime_wrapper.h leads to either
      // clang >9 compilation failure or clang 9 failure for using
      // cuda >8 (unsupported CUDA version).
      if (s == "-include") {
        last = s;
        continue;
      }
      if (last == "-include") {
        if (s != "__clang_cuda_runtime_wrapper.h") {
          cmd += " -include " + s;
        }
        last = s;
        continue;
      }

      // Using -ffcuda-is-device flag produces empty gpu module
      if (s == "-fcuda-is-device") {
        last = s;
        continue;
      }

      if constexpr (CLANG_VERSION_MAJOR == 9) {
        if (clang_version_major > 9) {
          // The following clang 9 flags are unknown to clang >9:
          if (s == "-masm-verbose" || s == "-fuse-init-array" ||
              s == "-dwarf-column-info" || s == "-momit-leaf-frame-pointer" ||
              s == "-fdiagnostics-show-option" || s == "-mdisable-fp-elim") {
            last = s;
            continue;
          }
          if (s == "-fmessage-length") {
            skip = 1;
            last = s;
            continue;
          }
        }
      }

      if constexpr (CLANG_VERSION_MAJOR == 10) {
        if (clang_version_major > 10) {
          // The following clang 10 flags are unknown to clang >10:
          if (s == "-masm-verbose" || s == "-dwarf-column-info" ||
              s == "-fdiagnostics-show-option") {
            last = s;
            continue;
          }
          if (s == "-fmessage-length") {
            skip = 1;
            last = s;
            continue;
          }
        }
      }

      if constexpr (CLANG_VERSION_MAJOR >= 10) {
        if (clang_version_major < 10) {
          // The following clang >10 flags are unknown to clang <10:
          if (s == "-fno-rounding-math" || s.rfind("-mframe-pointer=", 0) == 0 ||
              s.rfind("-fgnuc-version=", 0) == 0) {
            last = s;
            continue;
          }
        }
      }

      if constexpr (CLANG_VERSION_MAJOR == 11) {
        if (clang_version_major < 11) {
          // The following clang 11 flags are unknown to clang <11:
          if (s == "-fno-verbose-asm") {
            last = s;
            continue;
          }
          if (s == "-aux-target-cpu") {
            last = s;
            skip = 1;
            continue;
          }
        }
      }

      cmd += " " + s;
      last = s;
    }
    // TODO: Here we don't use the_driver->ExecuteCompilation because
    // could not find a better way to modify driver arguments. As a
    // workaround, we run clang compiler via pipe (it could be run
    // also via shell).
    exec_output(cmd);
    return 0;
  }

  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:

std::string UdfCompiler::compileToLLVMIR ( const std::string &  udf_file_name ) const

private

Formulate Clang command line command and call clang binary to generate LLVM IR for the C/C++ file.

Definition at line 584 of file UdfCompiler.cpp.

References clang_path_, compileFromCommandLine(), genLLVMIRFilename(), run_benchmark_import::res, and to_string().

Referenced by compileUdf().

                                                                           {
  std::string cpu_out_filename = genLLVMIRFilename(udf_file_name);

  std::vector<std::string> command_line{clang_path_,
                                        "-c",
                                        "-O2",
                                        "-emit-llvm",
                                        "-o",
                                        cpu_out_filename,
                                        "-std=c++17",
                                        "-DNO_BOOST",
                                        udf_file_name};
  auto res = compileFromCommandLine(command_line);
  if (res != 0) {
    throw std::runtime_error("Failed to compile CPU UDF (status code " +
                             std::to_string(res) + ")");
  }
  if (!boost::filesystem::exists(cpu_out_filename)) {
    throw std::runtime_error("udf compile did not produce output file " +
                             cpu_out_filename);
  }
  return cpu_out_filename;
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::pair< std::string, std::string > UdfCompiler::compileUdf

(

const std::string &

udf_file_name

)

const

Compile a C++ file to LLVM IR, and generate an AST file. Both artifacts exist as files on disk. Three artifacts will be generated; the AST file, the CPU LLVM IR, and GPU LLVM IR (if CUDA is enabled and compilation succeeds). These LLVM IR files can be loaded by the Executor. The AST will be processed by Calcite.

Definition at line 317 of file UdfCompiler.cpp.

References compileToLLVMIR(), generateAST(), logger::INFO, LOG, and logger::WARNING.

Referenced by DBHandler::initialize().

                                          {
  LOG(INFO) << "UDFCompiler filename to compile: " << udf_file_name;
  if (!boost::filesystem::exists(udf_file_name)) {
    throw std::runtime_error("User defined function file " + udf_file_name +
                             " does not exist.");
  }

  // create the AST file  for the input function
  generateAST(udf_file_name);

  // Compile udf file to generate cpu and gpu bytecode files
  std::string cpu_file_name = "";
  std::string cuda_file_name = "";

  cpu_file_name = compileToLLVMIR(udf_file_name);

#ifdef HAVE_CUDA
  try {
    cuda_file_name = compileToNVVMIR(udf_file_name);
  } catch (const std::exception& e) {
    LOG(WARNING)
        << "Failed to generate GPU IR for UDF " + udf_file_name +
               ", attempting to use CPU compiled IR for GPU.\nUDF Compiler exception: " +
               e.what();
  }
#endif
  return std::make_pair(cpu_file_name, cuda_file_name);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void UdfCompiler::generateAST ( const std::string &  file_name ) const

private

Call clang binary to generate abstract syntax tree file for registration in Calcite.

Definition at line 608 of file UdfCompiler.cpp.

References clang_options_, clang_path_, anonymous_namespace{UdfCompiler.cpp}::convert(), gpu_enabled::copy(), File_Namespace::create(), logger::init(), anonymous_namespace{UdfCompiler.cpp}::replace_extension(), run_benchmark_import::result, to_string(), ToolingSampleCategory(), and shared::transform().

Referenced by compileUdf().

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

  std::vector<std::string> arg_vector;
  arg_vector.emplace_back("astparser");
  arg_vector.emplace_back(file_name);
  arg_vector.emplace_back("--");
  arg_vector.emplace_back("-DNO_BOOST");
  arg_vector.emplace_back(include_option);
  arg_vector.emplace_back("-std=c++17");

  if (clang_options_.size() > 0) {
    std::copy(
        clang_options_.begin(), clang_options_.end(), std::back_inserter(arg_vector));
  }
  std::vector<const char*> arg_vec2;
  std::transform(
      arg_vector.begin(), arg_vector.end(), std::back_inserter(arg_vec2), convert);

  int num_args = arg_vec2.size();
#if LLVM_VERSION_MAJOR > 12
  auto op = CommonOptionsParser::create(num_args, &arg_vec2[0], ToolingSampleCategory);
  ClangTool tool(op->getCompilations(), op->getSourcePathList());
#else
  CommonOptionsParser op(num_args, &arg_vec2[0], ToolingSampleCategory);
  ClangTool tool(op.getCompilations(), op.getSourcePathList());
#endif

  std::string out_name(file_name);
  std::string file_ext("ast");
  replace_extension(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::OF_None);

  auto factory = std::make_unique<ToolFactory>(out_file);
  const auto result = tool.run(factory.get());
  if (result != 0) {
    throw std::runtime_error(
        "Unable to create AST file for udf compilation (error code " +
        std::to_string(result) + ")");
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::string UdfCompiler::genLLVMIRFilename ( const std::string &  udf_file_name )

staticprivate

Definition at line 383 of file UdfCompiler.cpp.

References anonymous_namespace{UdfCompiler.cpp}::remove_file_extension().

Referenced by compileToLLVMIR().

                                                                       {
  return remove_file_extension(udf_file_name) + "_cpu.bc";
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::string UdfCompiler::genNVVMIRFilename ( const std::string &  udf_file_name )

staticprivate

Definition at line 379 of file UdfCompiler.cpp.

References anonymous_namespace{UdfCompiler.cpp}::remove_file_extension().

                                                                       {
  return remove_file_extension(udf_file_name) + "_gpu.bc";
}

Here is the call graph for this function:

std::string UdfCompiler::getAstFileName ( const std::string &  udf_file_name )

static

Definition at line 656 of file UdfCompiler.cpp.

References anonymous_namespace{UdfCompiler.cpp}::replace_extension().

Referenced by DBHandler::initialize().

                                                                    {
  auto ast_file_name = udf_file_name;
  replace_extension(ast_file_name, "ast");
  return ast_file_name;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

std::vector<std::string> UdfCompiler::clang_options_

private

Definition at line 73 of file UdfCompiler.h.

Referenced by compileFromCommandLine(), generateAST(), and UdfCompiler().

std::string UdfCompiler::clang_path_

private

Definition at line 72 of file UdfCompiler.h.

Referenced by compileFromCommandLine(), compileToLLVMIR(), and generateAST().

---

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

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