Method submit_sscp_kernel_from_code_object

src/runtime/omp/omp_queue.cpp:427–553

}

result omp_queue::submit_sscp_kernel_from_code_object(
    hcf_object_id hcf_object, std::string_view kernel_name,
    const rt::hcf_kernel_info *kernel_info, const rt::range<3> &num_groups,
    const rt::range<3> &group_size, unsigned local_mem_size, void **args,
    std::size_t *arg_sizes, std::size_t num_args,
    const kernel_configuration &initial_config) {
#ifdef HIPSYCL_WITH_SSCP_COMPILER
  common::spin_lock_guard lock{_sscp_submission_spin_lock};

  if (!kernel_info) {
    return make_error(
        __acpp_here(),
        error_info{"omp_queue: Could not obtain hcf kernel info for kernel " +
                   std::string{kernel_name}});
  }


  _arg_mapper.construct_mapping(*kernel_info, args, arg_sizes, num_args);

  if (!_arg_mapper.mapping_available()) {
    return make_error(
        __acpp_here(),
        error_info{
            "omp_queue: Could not map C++ arguments to kernel arguments"});
  }

  kernel_adaptivity_engine adaptivity_engine{
      hcf_object, kernel_name, kernel_info, _arg_mapper, num_groups,
      group_size, args,        arg_sizes,   num_args, local_mem_size};

  _config = initial_config;

  _config.append_base_configuration(
      kernel_base_config_parameter::backend_id, backend_id::omp);
  _config.append_base_configuration(
      kernel_base_config_parameter::compilation_flow,
      compilation_flow::sscp);
  _config.append_base_configuration(
      kernel_base_config_parameter::hcf_object_id, hcf_object);

  for(const auto& flag : kernel_info->get_compilation_flags())
    _config.set_build_flag(flag);
  for(const auto& opt : kernel_info->get_compilation_options())
    _config.set_build_option(opt.first, opt.second);

  auto binary_configuration_id =
      adaptivity_engine.finalize_binary_configuration(_config);
  auto code_object_configuration_id = binary_configuration_id;

  auto get_image_and_kernel_names =
      [&](std::vector<std::string> &contained_kernels) -> std::string {
    return adaptivity_engine.select_image_and_kernels(&contained_kernels);
  };

  auto jit_compiler = [&](std::string &compiled_image) -> bool {
    const common::hcf_container *hcf = rt::hcf_cache::get().get_hcf(hcf_object);

    std::vector<std::string> kernel_names;