#include <CompilerOptions.h>

Collaboration diagram for onert::compiler::CompilerOptions:

Public Member Functions
void	forceInternalOptions ()
	Force default values of CompilerOptions for correct compilations.

void	verboseOptions ()
	Print option value.

Static Public Member Functions
static std::unique_ptr< CompilerOptions >	fromGlobalConfig ()
	Set default values for CompilerOptions.

Data Fields
std::vector< std::string >	backend_list

std::unordered_map< ir::IOIndex, ir::Layout >	input_layout

std::unordered_map< ir::IOIndex, ir::Layout >	output_layout

std::unordered_map< ir::IOIndex, ir::TypeInfo >	input_type

std::unordered_map< ir::IOIndex, ir::TypeInfo >	output_type

int	graph_dump_level

std::string	executor

ManualSchedulerOptions	manual_scheduler_options

bool	he_scheduler

bool	he_profiling_mode

bool	internal_output_alloc

bool	fp16_enable

std::string	workspace_dir

Detailed Description

Definition at line 42 of file CompilerOptions.h.

Member Function Documentation

◆ forceInternalOptions()

void onert::compiler::CompilerOptions::forceInternalOptions ( )

Force default values of CompilerOptions for correct compilations.

Note: This should be called after CompilerOptions setting is finished to prevent value overwriting

Definition at line 111 of file CompilerOptions.cc.

{
  // Set control flow backend for control flow operators
  auto &builtin_id = backend::builtin::Config::ID;
  manual_scheduler_options.opcode_to_backend[ir::OpCode::If] = builtin_id;
  manual_scheduler_options.opcode_to_backend[ir::OpCode::While] = builtin_id;
  manual_scheduler_options.opcode_to_backend[ir::OpCode::Call] = builtin_id;
  manual_scheduler_options.opcode_to_backend[ir::OpCode::Permute] = builtin_id;
 
  // FIXME This is a workaround for bcq operations, should remove it
  manual_scheduler_options.opcode_to_backend[ir::OpCode::BCQFullyConnected] = "bcq";
  manual_scheduler_options.opcode_to_backend[ir::OpCode::BCQGather] = "bcq";
 
  // FIXME This is a workaround for bulk operations, should remove it
  manual_scheduler_options.opcode_to_backend[ir::OpCode::Bulk] = "trix";
}

References onert::backend::builtin::Config::ID, manual_scheduler_options, and onert::compiler::ManualSchedulerOptions::opcode_to_backend.

Referenced by onert::compiler::Compiler::compile(), and onert::compiler::train::TrainingCompiler::compile().

◆ fromGlobalConfig()

std::unique_ptr< CompilerOptions > onert::compiler::CompilerOptions::fromGlobalConfig ( )

static

Set default values for CompilerOptions.

Returns: Generated CompileOption

Note: All these default values should not be fetched from Env when we stop supporting Android NNAPI.

Definition at line 75 of file CompilerOptions.cc.

{
  auto o = std::make_unique<CompilerOptions>();
  o->backend_list = nnfw::misc::split(util::getConfigString(util::config::BACKENDS), ';');
  o->graph_dump_level = util::getConfigInt(util::config::GRAPH_DOT_DUMP);
  o->executor = util::getConfigString(util::config::EXECUTOR);
  o->he_scheduler = util::getConfigBool(util::config::USE_SCHEDULER);
  o->he_profiling_mode = util::getConfigBool(util::config::PROFILING_MODE);
  o->fp16_enable = util::getConfigBool(util::config::FP16_ENABLE);
  o->workspace_dir = util::getConfigString(util::config::WORKSPACE_DIR);
  {
    // Backend for all
    auto &ms_options = o->manual_scheduler_options;
 
    // Default value for op_backend_all is first element in the backend list
    ms_options.backend_for_all = util::getConfigString(util::config::OP_BACKEND_ALLOPS);
 
// Opcode to Backend
#define OP(OpName)                                                                      \
  {                                                                                     \
    const auto &backend_str = util::getConfigString(util::config::OP_BACKEND_##OpName); \
    if (!backend_str.empty())                                                           \
    {                                                                                   \
      ms_options.opcode_to_backend[ir::OpCode::OpName] = backend_str;                   \
    }                                                                                   \
  }
#include "ir/Operations.lst"
#undef OP
 
    // Index to Backend
    auto map_str = util::getConfigString(util::config::OP_BACKEND_MAP);
    ms_options.setBackendMap(map_str);
  }
  return o;
}

References onert::util::getConfigBool(), onert::util::getConfigInt(), onert::util::getConfigString(), and nnfw::misc::split().

◆ verboseOptions()

void onert::compiler::CompilerOptions::verboseOptions ( )

Print option value.

Definition at line 128 of file CompilerOptions.cc.

{
  VERBOSE(Compiler) << std::boolalpha << "==== Compiler Options ====" << std::endl;
  VERBOSE(Compiler) << "backend_list             : "
                    << nnfw::misc::join(backend_list.begin(), backend_list.end(), "/") << std::endl;
  VERBOSE(Compiler) << "graph_dump_level         : " << graph_dump_level << std::endl;
  VERBOSE(Compiler) << "executor                 : " << executor << std::endl;
  VERBOSE(Compiler) << "manual backend_for_all   : " << manual_scheduler_options.backend_for_all
                    << std::endl;
  VERBOSE(Compiler) << "manual_scheduler_options : "
                    << getOpBackends(manual_scheduler_options.opcode_to_backend) << std::endl;
  VERBOSE(Compiler) << "he_scheduler             : " << he_scheduler << std::endl;
  VERBOSE(Compiler) << "he_profiling_mode        : " << he_profiling_mode << std::endl;
  VERBOSE(Compiler) << "internal_output_alloc    : " << internal_output_alloc << std::endl;
  VERBOSE(Compiler) << "fp16_enable              : " << fp16_enable << std::endl
                    << std::noboolalpha;
}