onert_micro::import::OMExecutionPlanCreator Struct Reference

#include <OMExecutionPlanCreator.h>

Static Public Member Functions
static OMStatus	createExecutionPlan (core::OMRuntimeStorage &runtime_storage, core::OMRuntimeContext &runtime_context, core::memory::OMRuntimeAllocator &allocator, const OMConfig &configs)
static OMStatus	createForwardExecutionPlan (core::OMRuntimeStorage &runtime_storage, core::OMRuntimeContext &runtime_context, core::memory::OMRuntimeAllocator &allocator, const OMConfig &configs)
static OMStatus	createBackwardExecutionPlan (core::OMRuntimeStorage &runtime_storage, core::OMRuntimeContext &runtime_context, core::memory::OMRuntimeAllocator &allocator, const OMConfig &configs)

Detailed Description

Definition at line 31 of file OMExecutionPlanCreator.h.

Member Function Documentation

createBackwardExecutionPlan()

OMStatus OMExecutionPlanCreator::createBackwardExecutionPlan ( core::OMRuntimeStorage &  runtime_storage, core::OMRuntimeContext &  runtime_context, core::memory::OMRuntimeAllocator &  allocator, const OMConfig &  configs  )

static

Definition at line 336 of file OMExecutionPlanCreator.cpp.

{
  bool keep_input = configs.keep_input;
  bool train_mode = configs.train_mode;
  assert(train_mode);
  if (train_mode == false)
    return UnknownError;
 
  std::vector<std::vector<uint16_t>> &alloc_plan = allocator.getAllocPlan();
  std::vector<std::vector<uint16_t>> &dealloc_plan = allocator.getDeallocPlan();
 
  // First remove prev plan (if it was created)
  alloc_plan.clear();
  dealloc_plan.clear();
 
  using Lifetime = std::pair<int32_t, int32_t>;
  std::map<uint16_t, Lifetime> lifetimes;
 
  const reader::CircleOperators *operators = runtime_context.getCircleOperators();
  const uint32_t num_kernels = operators->size();
 
  uint32_t num_train_layers =
    configs.training_context.num_of_train_layers == 0
      ? num_kernels
      : std::min(num_kernels, configs.training_context.num_of_train_layers);
  auto graph_outputs = runtime_context.getCircleOutputs();
 
  for (const auto output_ind : *graph_outputs)
  {
    assert(lifetimes.count(output_ind) == 0);
    lifetimes[output_ind] = Lifetime(-1, 0);
  }
 
  std::unordered_map<uint16_t, uint8_t> trainable_ops_config =
    runtime_context.getTrainableOpsIndexes();
 
  // If context has config file defined trainable operations
  // than ignore configs.training_context.num_of_train_layers value
  // and use max value from trainable_ops_indexes to define last train op
  uint16_t last_train_op_indx = num_kernels - num_train_layers;
  if (!trainable_ops_config.empty())
  {
    last_train_op_indx = std::numeric_limits<uint16_t>::max();
    // Find op trainable index with min value
    for (auto &p : trainable_ops_config)
    {
      last_train_op_indx = std::min(p.first, last_train_op_indx);
    }
    num_train_layers = (num_kernels - last_train_op_indx);
  }
 
  const auto *op_codes = runtime_context.getCircleOpcodes();
  for (int32_t index = 0; index < num_train_layers; ++index)
  {
    uint32_t cur_op_index = num_kernels - index - 1;
    auto *cur_op = operators->operator[](cur_op_index);
 
    uint32_t cur_opcode_index = cur_op->opcode_index();
 
    assert(cur_opcode_index < op_codes->size());
 
    const auto opcode = op_codes->operator[](cur_opcode_index);
 
    const auto *op_inputs = cur_op->inputs();
    const auto *op_outputs = cur_op->outputs();
 
    bool is_trainable_ops =
      trainable_ops_config.empty() == true
        ? isTrainableWeights(opcode)
        : trainable_ops_config.find(cur_op_index) != trainable_ops_config.end();
 
    // Warning: this is right for Conv2D and for FullyConnected kernels
    const int32_t bias_index = 2;
 
    for (int32_t j = 0; j < op_inputs->size(); ++j)
    {
      const auto input_index = op_inputs->operator[](j);
      const auto is_const = runtime_context.isConstTensor(input_index);
      // Note: we dont need to allocate for last node and for empty tensor
      if (input_index == -1 or (is_const and not is_trainable_ops))
      {
        continue;
      }
 
      if ((index == num_train_layers - 1) and !is_const)
      {
        lifetimes[input_index] = {-1, index};
      }
      else if (is_const and
               trainable_ops_config.find(cur_op_index) != trainable_ops_config.end() and
               trainable_ops_config[cur_op_index] == ONLY_BIAS and j != bias_index)
      {
        // Do nothing, due to update only bias
        continue;
      }
      else
      {
        lifetimes[input_index] = {index, -1};
      }
    }
 
    for (int32_t j = 0; j < op_outputs->size(); ++j)
    {
      const auto output_index = op_outputs->operator[](j);
      if (lifetimes.count(output_index) > 0)
        lifetimes.at(output_index).second = index;
    }
  }
 
  alloc_plan.assign(num_train_layers, std::vector<uint16_t>());
  dealloc_plan.assign(num_train_layers, std::vector<uint16_t>());
 
  for (const auto &item : lifetimes)
  {
    if (item.second.first != -1)
      alloc_plan[item.second.first].push_back(item.first);
    if (item.second.second != -1)
      dealloc_plan[item.second.second].push_back(item.first);
  }
 
  return Ok;
}

References onert_micro::core::memory::OMRuntimeAllocator::getAllocPlan(), onert_micro::core::OMRuntimeContext::getCircleOpcodes(), onert_micro::core::OMRuntimeContext::getCircleOperators(), onert_micro::core::OMRuntimeContext::getCircleOutputs(), onert_micro::core::memory::OMRuntimeAllocator::getDeallocPlan(), onert_micro::core::OMRuntimeContext::getTrainableOpsIndexes(), onert_micro::core::OMRuntimeContext::isConstTensor(), onert_micro::OMConfig::keep_input, onert_micro::OMTrainingContext::num_of_train_layers, onert_micro::Ok, onert_micro::core::ONLY_BIAS, flatbuffers::Vector< T >::size(), size, onert_micro::OMConfig::train_mode, onert_micro::OMConfig::training_context, and onert_micro::UnknownError.

Referenced by onert_micro::core::OMTrainingRuntimeModule::importTrainModel().

createExecutionPlan()

OMStatus OMExecutionPlanCreator::createExecutionPlan ( core::OMRuntimeStorage &  runtime_storage, core::OMRuntimeContext &  runtime_context, core::memory::OMRuntimeAllocator &  allocator, const OMConfig &  configs  )

static

Definition at line 83 of file OMExecutionPlanCreator.cpp.

{
  // Check is non trainable mode
  assert(configs.train_mode != true);
  if (configs.train_mode == true)
    return UnknownError;
 
  bool keep_input = configs.keep_input;
 
  std::vector<std::vector<uint16_t>> &alloc_plan = allocator.getAllocPlan();
  std::vector<std::vector<uint16_t>> &dealloc_plan = allocator.getDeallocPlan();
 
  // First remove prev plan (if it was created)
  alloc_plan.clear();
  dealloc_plan.clear();
 
  using Lifetime = std::pair<int32_t, int32_t>;
 
  std::map<uint16_t, Lifetime> lifetimes;
 
  const reader::CircleOperators *operators = runtime_context.getCircleOperators();
 
  const size_t num_kernels = operators->size();
 
  if (not keep_input)
  {
    auto graph_inputs = runtime_context.getCircleInputs();
    for (const auto input_ind : *graph_inputs)
    {
      assert(lifetimes.count(input_ind) == 0);
      lifetimes[input_ind] = Lifetime(-1, 0);
    }
  }
 
  for (int32_t index = 0; index < num_kernels; ++index)
  {
    auto *cur_op = operators->operator[](index);
 
    const auto *op_inputs = cur_op->inputs();
    const auto *op_outputs = cur_op->outputs();
    auto kernel_type = runtime_storage.getKernelType(index);
    for (int32_t j = 0; j < op_inputs->size(); ++j)
    {
      const auto input_index = op_inputs->operator[](j);
 
      if (input_index == -1)
        continue;
 
      // Pass constant tensors
      if (runtime_context.isConstTensor(input_index))
        continue;
 
      if (lifetimes.count(input_index) > 0)
      {
        if (kernel_type == Inplace)
          lifetimes.at(input_index).second = -1;
        else
          lifetimes.at(input_index).second = index;
      }
    }
 
    for (int32_t j = 0; j < op_outputs->size(); ++j)
    {
      const auto output_index = op_outputs->operator[](j);
 
      if (kernel_type == Inplace)
        lifetimes[output_index] = Lifetime(-1, index);
      else
        lifetimes[output_index] = Lifetime(index, index);
    }
  }
  auto graph_outputs = runtime_context.getCircleOutputs();
  for (const auto output_ind : *graph_outputs)
  {
    if (lifetimes.count(output_ind) > 0)
      lifetimes.at(output_ind).second = static_cast<int32_t>(num_kernels);
  }
 
  alloc_plan.assign(num_kernels, std::vector<uint16_t>());
  dealloc_plan.assign(num_kernels + 1, std::vector<uint16_t>());
 
  for (const auto &item : lifetimes)
  {
    if (item.second.first != -1)
      alloc_plan[item.second.first].push_back(item.first);
    if (item.second.second != -1)
      dealloc_plan[item.second.second].push_back(item.first);
  }
 
  return Ok;
}

References onert_micro::core::memory::OMRuntimeAllocator::getAllocPlan(), onert_micro::core::OMRuntimeContext::getCircleInputs(), onert_micro::core::OMRuntimeContext::getCircleOperators(), onert_micro::core::OMRuntimeContext::getCircleOutputs(), onert_micro::core::memory::OMRuntimeAllocator::getDeallocPlan(), onert_micro::core::OMRuntimeStorage::getKernelType(), onert_micro::core::Inplace, onert_micro::core::OMRuntimeContext::isConstTensor(), onert_micro::OMConfig::keep_input, onert_micro::Ok, flatbuffers::Vector< T >::size(), onert_micro::OMConfig::train_mode, and onert_micro::UnknownError.

Referenced by onert_micro::core::OMRuntimeModule::importModel().

createForwardExecutionPlan()

OMStatus OMExecutionPlanCreator::createForwardExecutionPlan ( core::OMRuntimeStorage &  runtime_storage, core::OMRuntimeContext &  runtime_context, core::memory::OMRuntimeAllocator &  allocator, const OMConfig &  configs  )

static

Definition at line 182 of file OMExecutionPlanCreator.cpp.

{
  // Check is trainable mode
  assert(configs.train_mode == true);
  if (configs.train_mode != true)
    return UnknownError;
 
  bool keep_input = configs.keep_input;
  std::vector<std::vector<uint16_t>> &alloc_plan = allocator.getAllocPlan();
  std::vector<std::vector<uint16_t>> &dealloc_plan = allocator.getDeallocPlan();
 
  // First remove prev plan (if it was created)
  alloc_plan.clear();
  dealloc_plan.clear();
 
  using Lifetime = std::pair<int32_t, int32_t>;
 
  std::map<uint16_t, Lifetime> lifetimes;
 
  const reader::CircleOperators *operators = runtime_context.getCircleOperators();
 
  const size_t num_kernels = operators->size();
 
  uint32_t num_train_layers = configs.training_context.num_of_train_layers;
  if (num_train_layers == 0)
    num_train_layers = num_kernels;
 
  std::unordered_map<uint16_t, uint8_t> trainable_ops_config =
    runtime_context.getTrainableOpsIndexes();
 
  // If context has config file defined trainable operations
  // than ignore configs.training_context.num_of_train_layers value
  // and use max value from trainable_ops_indexes to define last train op
  uint16_t last_train_op_indx = num_kernels - num_train_layers;
  if (!trainable_ops_config.empty())
  {
    last_train_op_indx = std::numeric_limits<uint16_t>::max();
    // Find op trainable index with min value
    for (auto &p : trainable_ops_config)
    {
      last_train_op_indx = std::min(p.first, last_train_op_indx);
    }
    num_train_layers = (num_kernels - last_train_op_indx);
  }
 
  if (not keep_input)
  {
    auto graph_inputs = runtime_context.getCircleInputs();
    for (const auto input_ind : *graph_inputs)
    {
      assert(lifetimes.count(input_ind) == 0);
      lifetimes[input_ind] = Lifetime(-1, 0);
    }
  }
 
  const auto *op_codes = runtime_context.getCircleOpcodes();
 
  for (int32_t index = 0; index < num_kernels; ++index)
  {
    auto *cur_op = operators->operator[](index);
 
    const auto *op_inputs = cur_op->inputs();
    const auto *op_outputs = cur_op->outputs();
    auto kernel_type = runtime_storage.getKernelType(index);
 
    uint32_t cur_opcode_index = cur_op->opcode_index();
 
    assert(cur_opcode_index < op_codes->size());
 
    const auto opcode = op_codes->operator[](cur_opcode_index);
 
    // Flag to determine is current operation needed to save input data (is this op in training part
    // of the graph)
    bool need_to_save_input_data =
      (index >= last_train_op_indx) and
      ((trainable_ops_config.empty() or
        trainable_ops_config.find(index) != trainable_ops_config.end() and
          trainable_ops_config[index] != ONLY_BIAS) or
       isOpNeedSaveInputData(opcode));
 
    // Flag to determine is current operation needed to save output data (is this op in training
    // part of the graph)
    bool need_to_save_output_data =
      (index >= last_train_op_indx) and
      ((trainable_ops_config.find(index) != trainable_ops_config.end() and
        trainable_ops_config[index] != ONLY_BIAS) or
       isOpNeedSaveOutputData(opcode, cur_op));
 
    for (int32_t j = 0; j < op_inputs->size(); ++j)
    {
      const auto input_index = op_inputs->operator[](j);
 
      if (input_index == -1)
        continue;
 
      // Pass constant tensors
      if (runtime_context.isConstTensor(input_index))
        continue;
 
      if (lifetimes.count(input_index) > 0)
      {
        // lifetimes.at(input_index).second == -2 - Means need to save data for input_index tensor
        if (kernel_type == Inplace or need_to_save_input_data or
            (lifetimes.at(input_index).second == -2))
          lifetimes.at(input_index).second = -1;
        else
          lifetimes.at(input_index).second = index;
      }
    }
 
    for (int32_t j = 0; j < op_outputs->size(); ++j)
    {
      const auto output_index = op_outputs->operator[](j);
 
      if (kernel_type == Inplace)
        lifetimes[output_index] = Lifetime(-1, index);
      else if (need_to_save_output_data)
        lifetimes[output_index] = Lifetime(index, -2);
      else
        lifetimes[output_index] = Lifetime(index, index);
    }
  }
  auto graph_outputs = runtime_context.getCircleOutputs();
  for (const auto output_ind : *graph_outputs)
  {
    if (lifetimes.count(output_ind) > 0)
      lifetimes.at(output_ind).second = static_cast<int32_t>(num_kernels);
  }
 
  alloc_plan.assign(num_kernels, std::vector<uint16_t>());
  dealloc_plan.assign(num_kernels + 1, std::vector<uint16_t>());
 
  for (const auto &item : lifetimes)
  {
    if (item.second.first >= 0)
      alloc_plan[item.second.first].push_back(item.first);
    if (item.second.second >= 0)
      dealloc_plan[item.second.second].push_back(item.first);
  }
 
  return Ok;
}

References onert_micro::core::memory::OMRuntimeAllocator::getAllocPlan(), onert_micro::core::OMRuntimeContext::getCircleInputs(), onert_micro::core::OMRuntimeContext::getCircleOpcodes(), onert_micro::core::OMRuntimeContext::getCircleOperators(), onert_micro::core::OMRuntimeContext::getCircleOutputs(), onert_micro::core::memory::OMRuntimeAllocator::getDeallocPlan(), onert_micro::core::OMRuntimeStorage::getKernelType(), onert_micro::core::OMRuntimeContext::getTrainableOpsIndexes(), onert_micro::core::Inplace, onert_micro::core::OMRuntimeContext::isConstTensor(), onert_micro::OMConfig::keep_input, onert_micro::OMTrainingContext::num_of_train_layers, onert_micro::Ok, onert_micro::core::ONLY_BIAS, flatbuffers::Vector< T >::size(), size, onert_micro::OMConfig::train_mode, onert_micro::OMConfig::training_context, and onert_micro::UnknownError.

Referenced by onert_micro::core::OMRuntimeModule::importModel().

---

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

• onert-micro/onert-micro/include/import/OMExecutionPlanCreator.h
• onert-micro/onert-micro/src/import/OMExecutionPlanCreator.cpp