path: root/runtime/neurun/core/src/compiler/ExecutorFactory.cc

/*
 * Copyright (c) 2019 Samsung Electronics Co., Ltd. All Rights Reserved
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "ExecutorFactory.h"

#include <functional>
#include "exec/ExecutionObservers.h"
#include "exec/LinearExecutor.h"
#include "exec/DataflowExecutor.h"
#include "exec/ParallelExecutor.h"
#include "compiler/BackendResolver.h"
#include "backend/ExecTime.h"
#include "compiler/Linear.h"
#include "ir/dumper/Dumper.h"
#include "SubTensorAnalyzer.h"
#include "backend/IConstantInitializer.h"
#include "backend/IKernelGenerator.h"
#include "backend/IShapeFixer.h"
#include "backend/ITensorRegister.h"
#include "cpp14/memory.h"
#include "CodeWithInfo.h"

namespace neurun
{
namespace compiler
{

ExecutorFactory &ExecutorFactory::get()
{
  static ExecutorFactory singleton;
  return singleton;
}

ExecutorFactory::ExecutorFactory()
{
  _map["Linear"] = createLinearExecutor;
  _map["Dataflow"] = std::bind(createDataflowExecutor, std::placeholders::_1, false);
  _map["Parallel"] = std::bind(createDataflowExecutor, std::placeholders::_1, true);
}

exec::IExecutor *ExecutorFactory::create(const std::string &id, ir::Graph &graph)
{
  return _map.at(id)(graph);
}

exec::IExecutor *ExecutorFactory::createLinearExecutor(ir::Graph &graph)
{
  auto operand_context = std::make_shared<OperandContext>();

  // linearize
  assert(!graph.isBuildingPhase());
  auto linear = nnfw::cpp14::make_unique<Linear>(graph);

  // Dump ops
  linear->accept(ir::dumper::Dumper{});

  /*************************************************
   * Backend dependent analysis & optimization phase
   *************************************************/

  // SubTensorInfo should be generated after lower, before shape correction and finalize
  // because SubTensorAnalyzer assume that insert permutation is already finished
  //    lower: decide backend and insert permutation
  //    fix shapes: prepare codegen to optimization
  //    generate tensor objects: generate tensor using subtensor info
  //    generate kernels
  //    allocate tesor memory
  //    constant intialization: fill the constants with values
  // Generated SubTensorInfo is in operand(Object)
  // for easy pass SubTensorInfo to plan builder and tensor builder
  linear->accept(SubTensorAnalyzer{graph});

  /**********************************************************
   * Backend dependent analysis & optimization phase finished
   **********************************************************/

  /***********************
   * Code generation phase
   ***********************/

  // Fix shapes
  linear->iterate([&](const compiler::Linear::Element &element) {
    auto backend = element.lower_info->backend();
    auto shape_fixer = graph.backend_resolver()->getBackendContext(backend)->shape_fixer;
    shape_fixer->fix(*element.op_seq);
  });

  linear->planTensors();

  auto tensor_builders = graph.backend_resolver()->tensor_builders();

  // Prepare tensors
  for (auto &tensor_builder : tensor_builders)
  {
    tensor_builder->prepare();
  }

  // Generate initializers
  linear->generateConstantInitializers();

  class ExecutionBuilder final : public IExecutionBuilder
  {
  public:
    void append(std::unique_ptr<exec::IFunction> &&f) override
    {
      _code.emplace_back(_next_elem, std::move(f));
    }

    void setNextElem(const compiler::Linear::Element &next_elem) { _next_elem = next_elem; }
    std::vector<CodeWithInfo> releaseCode() { return std::move(_code); }

  private:
    compiler::Linear::Element _next_elem;
    std::vector<CodeWithInfo> _code;
  };

  ExecutionBuilder builder;

  // Generate kernels
  linear->iterate([&](const compiler::Linear::Element &element) {
    auto backend = element.lower_info->backend();
    builder.setNextElem(element);
    auto kernel_gen = graph.backend_resolver()->getBackendContext(backend)->kernel_gen;
    kernel_gen->generate(*element.op_seq, &builder);
  });

  auto code = builder.releaseCode();

  for (auto &tensor_builder : tensor_builders)
  {
    tensor_builder->allocateConsts();
  }

  // TODO Add optimization passes

  // Initialize constant tensors
  for (const auto backend : backend::BackendManager::get().getAll())
  {
    graph.backend_resolver()->getBackendContext(backend)->constant_initializer->run();
  }

  for (auto &&e : code)
  {
    e.fn->prepare();
    auto backend = e.elem.lower_info->backend();
    auto tensor_builder = graph.backend_resolver()->getBackendContext(backend)->tensor_builder;
    tensor_builder->postFunctionPrepare();
  }

  for (auto &tensor_builder : tensor_builders)
  {
    tensor_builder->allocateNonconsts();
  }

  for (auto &tensor_builder : tensor_builders)
  {
    tensor_builder->finalize();
  }

  // Wrap tensors as Object and store them to plan
  for (auto &tensor_builder : tensor_builders)
  {
    tensor_builder->iterate([&](const ir::OperandIndex &index) {
      auto object = tensor_builder->tensorAt(index);
      operand_context->set(index, object);
    });
  }

  // Prepare each TensorManager on each backend
  auto tensor_mgrs = nnfw::cpp14::make_unique<backend::TensorManagerSet>();
  for (auto &tensor_builder : tensor_builders)
  {
    tensor_mgrs->insert(tensor_builder->releaseTensorManager());
  }

  auto exec =
      new exec::LinearExecutor{graph, operand_context, std::move(tensor_mgrs), std::move(code)};

  const std::string trace_filepath = util::getConfigString(util::config::TRACE_FILEPATH);
  if (!trace_filepath.empty())
  {
    std::unique_ptr<exec::IExecutionObserver> ctp =
        nnfw::cpp14::make_unique<exec::ChromeTracingObserver>(trace_filepath);
    exec->addObserver(std::move(ctp));
  }

  return exec;
}

exec::IExecutor *ExecutorFactory::createDataflowExecutor(ir::Graph &graph, bool parallel)
{
  auto operand_context = std::make_shared<OperandContext>();

  graph.subgraphs().iterate([&](const ir::SubgraphIndex &, const ir::OpSequence &subg) {
    auto subtensor_analyzer = SubTensorAnalyzer{graph};
    subg.accept(subtensor_analyzer);
  });

  // Fix shapes and register tensors
  graph.subgraphs().iterate([&](const ir::SubgraphIndex &subg_index, const ir::OpSequence &subg) {
    auto backend = graph.getLowerInfo(subg_index)->backend();
    auto shape_fixer = graph.backend_resolver()->getBackendContext(backend)->shape_fixer;
    shape_fixer->fix(subg);
    const auto tensor_register =
        graph.backend_resolver()->getBackendContext(backend)->tensor_register;
    tensor_register->registerTensors(subg, graph.getLowerInfo());
  });

  graph.operands().iterate([&](const ir::OperandIndex &ind, const ir::Operand &obj) {
    const auto lower_info = graph.getLowerInfo(ind);
    for (auto factor : lower_info->def_factors())
    {
      auto backend = factor.backend();
      auto tensor_builder = graph.backend_resolver()->getBackendContext(backend)->tensor_builder;

      if (!tensor_builder->isRegistered(ind))
      {
        // These tensors do not exist in any op_seq (No use and def)
        // These tensors cannot be a SubTensor
        assert(obj.parent_info() == nullptr);

        const auto info = obj.info();
        const auto backend_layout = lower_info->def_factors().getOnlyElement().layout();
        // TODO Change tensor info to have permuted shape
        tensor_builder->registerTensorInfo(ind, info, backend_layout, obj.isConstant());
      }

      // Is not SubTensor?
      if (!backend->config()->SupportSubTensorAlloc() || obj.parent_info() == nullptr)
      {
        // To make this never be deallocated, this is a workaround to use static memory planner
        tensor_builder->notifyFirstUse(ind);
      }
    }
  });

  auto tensor_builders = graph.backend_resolver()->tensor_builders();

  for (auto &tensor_builder : tensor_builders)
  {
    tensor_builder->prepare();
  }

  class ExecutionBuilder : public IExecutionBuilder
  {
  public:
    void append(std::unique_ptr<exec::IFunction> &&fn) override
    {
      auto itr = _code_map.find(_next_index);
      if (itr == _code_map.end())
      {
        _code_map[_next_index] = nnfw::cpp14::make_unique<exec::FunctionSequence>();
      }
      _code_map[_next_index]->append(std::move(fn));
    };

    // TODO Remove this method and make `append` to get index value as an argument
    void setNextIndex(const ir::SubgraphIndex next_index) { _next_index = next_index; }

    exec::DataflowExecutor::CodeMap &&releaseCodeMap() { return std::move(_code_map); }

  private:
    ir::SubgraphIndex _next_index;
    exec::DataflowExecutor::CodeMap _code_map;
  };

  auto execution_builder = nnfw::cpp14::make_unique<ExecutionBuilder>();

  // Generate kernels
  graph.subgraphs().iterate([&](const ir::SubgraphIndex &subg_index, const ir::OpSequence &subg) {
    auto backend = graph.getLowerInfo(subg_index)->backend();
    auto constant_initializer =
        graph.backend_resolver()->getBackendContext(backend)->constant_initializer;
    constant_initializer->generate(subg, graph.operands());
    // TODO This approach is temporal. See declaration of `setNextIndex`.
    execution_builder->setNextIndex(subg_index);
    auto kernel_gen = graph.backend_resolver()->getBackendContext(backend)->kernel_gen;
    kernel_gen->generate(subg, execution_builder.get());
  });

  for (const auto &tensor_builder : tensor_builders)
  {
    tensor_builder->allocateConsts();
  }

  // Initialize constant tensors
  for (const auto backend : backend::BackendManager::get().getAll())
  {
    graph.backend_resolver()->getBackendContext(backend)->constant_initializer->run();
  }

  exec::DataflowExecutor::CodeMap code_map = execution_builder->releaseCodeMap();

  for (auto &it : code_map)
  {
    auto subg_index = it.first;
    auto &function_sequence = *(it.second);

    function_sequence.iterate([&](exec::IFunction &ifunc) {
      // NOTE. It may need avoiding prepare() for some operations
      // Ref: https://github.sec.samsung.net/STAR/nnfw/issues/7326
      ifunc.prepare();
      auto backend = graph.getLowerInfo(subg_index)->backend();
      auto tensor_builder = graph.backend_resolver()->getBackendContext(backend)->tensor_builder;
      tensor_builder->postFunctionPrepare();
    });
  }

  for (const auto &tensor_builder : tensor_builders)
  {
    tensor_builder->allocateNonconsts();
  }

  for (auto &tensor_builder : tensor_builders)
  {
    tensor_builder->finalize();
  }

  // Wrap tensors as Object and store them to plan
  for (auto &tensor_builder : tensor_builders)
  {
    tensor_builder->iterate([&](const ir::OperandIndex &index) {
      auto object = tensor_builder->tensorAt(index);
      operand_context->set(index, object);
    });
  }

  // Prepare each TensorManager on each backend
  auto tensor_mgrs = nnfw::cpp14::make_unique<backend::TensorManagerSet>();
  for (auto &tensor_builder : tensor_builders)
  {
    tensor_mgrs->insert(tensor_builder->releaseTensorManager());
  }

  exec::ExecutorBase *exec = nullptr;
  if (parallel)
  {
    exec = new exec::ParallelExecutor{graph, operand_context, std::move(tensor_mgrs),
                                      std::move(code_map)};
  }
  else
  {
    exec = new exec::DataflowExecutor{graph, operand_context, std::move(tensor_mgrs),
                                      std::move(code_map)};
    if (util::getConfigBool(util::config::PROFILING_MODE))
    {
      auto et = std::make_shared<backend::ExecTime>(backend::BackendManager::get().getAll());
      std::unique_ptr<exec::IExecutionObserver> obs =
          nnfw::cpp14::make_unique<exec::ProfileObserver>(et);
      exec->addObserver(std::move(obs));
    }
  }

  const std::string trace_filepath = util::getConfigString(util::config::TRACE_FILEPATH);
  if (!trace_filepath.empty())
  {
    std::unique_ptr<exec::IExecutionObserver> ctp =
        nnfw::cpp14::make_unique<exec::ChromeTracingObserver>(trace_filepath);
    exec->addObserver(std::move(ctp));
  }

  return exec;
}

} // namespace compiler
} // namespace neurun