From 7e890ba8c4e266404a8127903bd9b48cceab9ce1 Mon Sep 17 00:00:00 2001 From: =?utf8?q?=EB=B0=95=EC=A2=85=ED=98=84/On-Device=20Lab=28SR=29/Staff?= =?utf8?q?=20Engineer/=EC=82=BC=EC=84=B1=EC=A0=84=EC=9E=90?= Date: Wed, 22 May 2019 17:08:32 +0900 Subject: [PATCH] [RUA] Introduce Anchor & Shim module (#5243) This commit introduces rua-anchor which provides as a global rua service store, and rua-shim which provides (inlined) Android NN API implementation which delegates the call to the anchored runtime. Signed-off-by: Jonghyun Park --- libs/rua/CMakeLists.txt | 2 + libs/rua/anchor/CMakeLists.txt | 7 ++ libs/rua/anchor/include/rua/Anchor.h | 38 +++++++ libs/rua/anchor/src/Anchor.cpp | 33 ++++++ libs/rua/shim/CMakeLists.txt | 4 + libs/rua/shim/include/rua/Shim.h | 192 +++++++++++++++++++++++++++++++++++ 6 files changed, 276 insertions(+) create mode 100644 libs/rua/anchor/CMakeLists.txt create mode 100644 libs/rua/anchor/include/rua/Anchor.h create mode 100644 libs/rua/anchor/src/Anchor.cpp create mode 100644 libs/rua/shim/CMakeLists.txt create mode 100644 libs/rua/shim/include/rua/Shim.h diff --git a/libs/rua/CMakeLists.txt b/libs/rua/CMakeLists.txt index bcff3ef..07ad9ea 100644 --- a/libs/rua/CMakeLists.txt +++ b/libs/rua/CMakeLists.txt @@ -1,2 +1,4 @@ add_subdirectory(core) add_subdirectory(dyn) +add_subdirectory(anchor) +add_subdirectory(shim) diff --git a/libs/rua/anchor/CMakeLists.txt b/libs/rua/anchor/CMakeLists.txt new file mode 100644 index 0000000..a48d3ef --- /dev/null +++ b/libs/rua/anchor/CMakeLists.txt @@ -0,0 +1,7 @@ +file(GLOB_RECURSE SOURCES "src/*.cpp") + +add_library(rua-anchor STATIC ${SOURCES}) +set_target_properties(rua-anchor PROPERTIES POSITION_INDEPENDENT_CODE ON) +target_include_directories(rua-anchor PUBLIC include) +target_link_libraries(rua-anchor PUBLIC rua-core) +target_link_libraries(rua-anchor PRIVATE rua-dyn) diff --git a/libs/rua/anchor/include/rua/Anchor.h b/libs/rua/anchor/include/rua/Anchor.h new file mode 100644 index 0000000..7a69328 --- /dev/null +++ b/libs/rua/anchor/include/rua/Anchor.h @@ -0,0 +1,38 @@ +/* + * 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. + */ + +#ifndef __RUA_ANCHOR_H__ +#define __RUA_ANCHOR_H__ + +#include + +namespace rua +{ + +/** + * @brief Global Runtime Abstraction Context + * + * "set" will have global effect (within each process). + */ +struct Anchor +{ + static const RuntimeService *get(void); + static void set(const RuntimeService *svc); +}; + +} // namespace rua + +#endif // __RUA_ANCHOR_H__ diff --git a/libs/rua/anchor/src/Anchor.cpp b/libs/rua/anchor/src/Anchor.cpp new file mode 100644 index 0000000..a78cca1 --- /dev/null +++ b/libs/rua/anchor/src/Anchor.cpp @@ -0,0 +1,33 @@ +/* + * 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 "rua/Anchor.h" +#include + +namespace +{ + +const rua::RuntimeService *anchored_service = rua::DynamicBinder::get(); + +} // namespace + +namespace rua +{ + +const RuntimeService *Anchor::get(void) { return anchored_service; } +void Anchor::set(const RuntimeService *service) { anchored_service = service; } + +} // namespace rua diff --git a/libs/rua/shim/CMakeLists.txt b/libs/rua/shim/CMakeLists.txt new file mode 100644 index 0000000..62d0d1c --- /dev/null +++ b/libs/rua/shim/CMakeLists.txt @@ -0,0 +1,4 @@ +add_library(rua-shim INTERFACE) +target_include_directories(rua-shim INTERFACE include) +target_link_libraries(rua-shim INTERFACE rua-core) +target_link_libraries(rua-shim INTERFACE rua-anchor) diff --git a/libs/rua/shim/include/rua/Shim.h b/libs/rua/shim/include/rua/Shim.h new file mode 100644 index 0000000..564c3d3 --- /dev/null +++ b/libs/rua/shim/include/rua/Shim.h @@ -0,0 +1,192 @@ +/* + * 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. + */ + +#ifndef __RUA_SHIM_H__ +#define __RUA_SHIM_H__ + +#include + +// +// Memory +// +inline int ANeuralNetworksMemory_createFromFd(size_t size, int protect, int fd, size_t offset, + ANeuralNetworksMemory **memory) +{ + return rua::Anchor::get()->memory()->createFromFd(size, protect, fd, offset, memory); +} + +inline void ANeuralNetworksMemory_free(ANeuralNetworksMemory *memory) +{ + return rua::Anchor::get()->memory()->free(memory); +} + +// +// Event +// +inline int ANeuralNetworksEvent_wait(ANeuralNetworksEvent *event) +{ + return rua::Anchor::get()->event()->wait(event); +} + +inline void ANeuralNetworksEvent_free(ANeuralNetworksEvent *event) +{ + return rua::Anchor::get()->event()->free(event); +} + +// +// Model +// +inline int ANeuralNetworksModel_create(ANeuralNetworksModel **model) +{ + return rua::Anchor::get()->model()->create(model); +} + +inline int ANeuralNetworksModel_addOperand(ANeuralNetworksModel *model, + const ANeuralNetworksOperandType *type) +{ + return rua::Anchor::get()->model()->addOperand(model, type); +} + +inline int ANeuralNetworksModel_setOperandValue(ANeuralNetworksModel *model, int32_t index, + const void *buffer, size_t length) +{ + return rua::Anchor::get()->model()->setOperandValue(model, index, buffer, length); +} + +inline int ANeuralNetworksModel_setOperandValueFromMemory(ANeuralNetworksModel *model, + int32_t index, + const ANeuralNetworksMemory *memory, + size_t offset, size_t length) +{ + return rua::Anchor::get()->model()->setOperandValueFromMemory(model, index, memory, offset, + length); +} + +inline int ANeuralNetworksModel_addOperation(ANeuralNetworksModel *model, + ANeuralNetworksOperationType type, uint32_t inputCount, + const uint32_t *inputs, uint32_t outputCount, + const uint32_t *outputs) +{ + return rua::Anchor::get()->model()->addOperation(model, type, inputCount, inputs, outputCount, + outputs); +} + +inline int ANeuralNetworksModel_identifyInputsAndOutputs(ANeuralNetworksModel *model, + uint32_t inputCount, + const uint32_t *inputs, + uint32_t outputCount, + const uint32_t *outputs) +{ + return rua::Anchor::get()->model()->identifyInputsAndOutputs(model, inputCount, inputs, + outputCount, outputs); +} + +inline int ANeuralNetworksModel_relaxComputationFloat32toFloat16(ANeuralNetworksModel *model, + bool allow) +{ + return rua::Anchor::get()->model()->relaxComputationFloat32toFloat16(model, allow); +} + +inline int ANeuralNetworksModel_finish(ANeuralNetworksModel *model) +{ + return rua::Anchor::get()->model()->finish(model); +} + +inline void ANeuralNetworksModel_free(ANeuralNetworksModel *model) +{ + return rua::Anchor::get()->model()->free(model); +} + +// +// Compilation +// +inline int ANeuralNetworksCompilation_create(ANeuralNetworksModel *model, + ANeuralNetworksCompilation **compilation) +{ + return rua::Anchor::get()->compilation()->create(model, compilation); +} + +inline int ANeuralNetworksCompilation_setPreference(ANeuralNetworksCompilation *compilation, + int32_t preference) +{ + return rua::Anchor::get()->compilation()->setPreference(compilation, preference); +} + +inline int ANeuralNetworksCompilation_finish(ANeuralNetworksCompilation *compilation) +{ + return rua::Anchor::get()->compilation()->finish(compilation); +} + +inline void ANeuralNetworksCompilation_free(ANeuralNetworksCompilation *compilation) +{ + return rua::Anchor::get()->compilation()->free(compilation); +} + +// +// Execution +// +inline int ANeuralNetworksExecution_create(ANeuralNetworksCompilation *compilation, + ANeuralNetworksExecution **execution) +{ + return rua::Anchor::get()->execution()->create(compilation, execution); +} + +inline int ANeuralNetworksExecution_setInput(ANeuralNetworksExecution *execution, int32_t index, + const ANeuralNetworksOperandType *type, + const void *buffer, size_t length) +{ + return rua::Anchor::get()->execution()->setInput(execution, index, type, buffer, length); +} + +inline int ANeuralNetworksExecution_setInputFromMemory(ANeuralNetworksExecution *execution, + int32_t index, + const ANeuralNetworksOperandType *type, + const ANeuralNetworksMemory *memory, + size_t offset, size_t length) +{ + return rua::Anchor::get()->execution()->setInputFromMemory(execution, index, type, memory, offset, + length); +} + +inline int ANeuralNetworksExecution_setOutput(ANeuralNetworksExecution *execution, int32_t index, + const ANeuralNetworksOperandType *type, void *buffer, + size_t length) +{ + return rua::Anchor::get()->execution()->setOutput(execution, index, type, buffer, length); +} + +inline int ANeuralNetworksExecution_setOutputFromMemory(ANeuralNetworksExecution *execution, + int32_t index, + const ANeuralNetworksOperandType *type, + const ANeuralNetworksMemory *memory, + size_t offset, size_t length) +{ + return rua::Anchor::get()->execution()->setOutputFromMemory(execution, index, type, memory, + offset, length); +} + +inline int ANeuralNetworksExecution_startCompute(ANeuralNetworksExecution *execution, + ANeuralNetworksEvent **event) +{ + return rua::Anchor::get()->execution()->startCompute(execution, event); +} + +inline void ANeuralNetworksExecution_free(ANeuralNetworksExecution *execution) +{ + return rua::Anchor::get()->execution()->free(execution); +} + +#endif // __RUA_SHIM_H__ -- 2.7.4