file(GLOB SOURCES "src/*.cc")
file(GLOB_RECURSE SOURCES_FRONTEND "src/frontend/*.cc")
+file(GLOB SOURCES_BACKEND "src/backend/*.cc")
file(GLOB_RECURSE SOURCES_INTERNAL "src/internal/*.cc")
file(GLOB_RECURSE SOURCES_GRAPH "src/graph/*.cc")
file(GLOB_RECURSE SOURCES_LINEAR "src/linear/*.cc")
file(GLOB_RECURSE SOURCES_CODEGEN "src/codegen/*.cc")
file(GLOB_RECURSE SOURCES_VERIFIER "src/verifier/*.cc")
-set(SOURCES ${SOURCES} ${SOURCES_FRONTEND} ${SOURCES_INTERNAL} ${SOURCES_GRAPH} ${SOURCES_LINEAR} ${SOURCES_CODEGEN} ${SOURCES_VERIFIER})
+set(SOURCES ${SOURCES} ${SOURCES_FRONTEND} ${SOURCES_BACKEND} ${SOURCES_INTERNAL} ${SOURCES_GRAPH} ${SOURCES_LINEAR} ${SOURCES_CODEGEN} ${SOURCES_VERIFIER})
# NOTE For now ARMCompute is necessary
# TODO Remove required package below(should be optional)
-#include "internal/BackendManager.h"
+#include "BackendManager.h"
#include "backend/acl_cl/BackendConfig.h"
#include "backend/acl_cl/TensorBuilder.h"
#include "backend/cpu/InitializerGenerator.h"
#include "backend/cpu/StageGenerator.h"
-namespace internal
+namespace neurun
+{
+namespace backend
{
Backend::Backend(const std::shared_ptr<neurun::backend::IBackendConfig> &backend_config,
Backend BackendManager::get(const std::string &key) { return _gen_map.at(key); }
-} // namespace internal
+} // namespace backend
+} // namespace neurun
-#ifndef __INTERNAL_BACKEND_MANAGER_H__
-#define __INTERNAL_BACKEND_MANAGER_H__
+#ifndef __NEURUN_BACKEND_BACKEND_MANAGER_H__
+#define __NEURUN_BACKEND_BACKEND_MANAGER_H__
#include <memory>
#include <map>
struct IStageGenerator;
struct ITensorBuilder;
-} // namespace backend
-} // namespace neurun
-
-namespace internal
-{
-
class Backend
{
public:
std::map<std::string, Backend> _gen_map;
};
-} // namespace internal
+} // namespace backend
+} // namespace neurun
-#endif // __INTERNAL_BACKEND_MANAGER_H__
+#endif // __NEURUN_BACKEND_BACKEND_MANAGER_H__
// NOT IMPLEMENTED
-} // namespace neurun
} // namespace codegen
+} // namespace neurun
#include "logging.h"
#include "util/EnvVar.h"
-#include "internal/BackendManager.h"
+#include "backend/BackendManager.h"
#include "backend/IInitializerGenerator.h"
#include "backend/IStageGenerator.h"
public:
BackendResolver(const neurun::graph::operand::Set &operands)
{
- _backend_manager = std::make_shared<::internal::BackendManager>(operands);
+ _backend_manager = std::make_shared<backend::BackendManager>(operands);
const auto &backend_all_str =
::nnfw::util::EnvVar{std::string("OP_BACKEND_ALLOPS")}.asString("none");
}
public:
- const ::internal::Backend &getBackend(const std::type_index &type) { return _gen_map[type]; }
+ const backend::Backend &getBackend(const std::type_index &type) { return _gen_map[type]; }
private:
- std::unordered_map<std::type_index, ::internal::Backend> _gen_map;
- std::shared_ptr<::internal::BackendManager> _backend_manager;
+ std::unordered_map<std::type_index, backend::Backend> _gen_map;
+ std::shared_ptr<backend::BackendManager> _backend_manager;
};
} // namespace codegen
// Lower
{
- auto _backend_resolver = neurun::codegen::BackendResolver(_operands);
+ auto _backend_resolver = codegen::BackendResolver(_operands);
_operations.iterate([&](const operation::Index &, operation::Node &node) {
auto backend = _backend_resolver.getBackend(typeid(node));
node.lower_info(nnfw::make_unique<operation::LowerInfo>(backend));
namespace operation
{
-LowerInfo::LowerInfo(const internal::Backend &backend) : _backend(backend)
+LowerInfo::LowerInfo(const backend::Backend &backend) : _backend(backend)
{
// DO NOTHING
}
#include <string>
-#include "internal/BackendManager.h"
+#include "backend/BackendManager.h"
namespace neurun
{
class LowerInfo
{
public:
- LowerInfo(const internal::Backend &backend);
- const internal::Backend &backend() const { return _backend; }
+ LowerInfo(const backend::Backend &backend);
+ const backend::Backend &backend() const { return _backend; }
private:
- internal::Backend _backend;
+ backend::Backend _backend;
};
} // namespace operation