colin
/
TIM-VX
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add function for lite driver handle (#209) 

Signed-off-by: Zongwu Yang <zongwu.yang@verisilicon.com>
This commit is contained in:
Zongwu.Yang 2021-11-10 20:05:31 +08:00 committed by GitHub
parent 4b5fcf3c64
commit d019a76db5
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
10 changed files with 108 additions and 11 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CMakeLists.txt
View File

@ -8,6 +8,7 @@ option(TIM_VX_ENABLE_NBG_PARSER "Enable NBG parser"
option(TIM_VX_CODE_COVERAGE "Run code coverage with gconv(gcc only" OFF)
option(TIM_VX_USE_EXTERNAL_OVXLIB "Use external OVXLIB" OFF)
option(TIM_VX_BUILD_EXAMPLES "Build demos show general usage" OFF)
option(TIM_VX_ENABLE_VIPLITE "Enable lite driver api support" OFF)
set(CMAKE_CXX_STANDARD 14)
set(CMAKE_POSITION_INDEPENDENT_CODE ON)

19
cmake/A311D.cmake
View File

@ -38,3 +38,22 @@ list(APPEND OVXDRV_LIBRARIES
${PROJECT_BINARY_DIR}/aarch64_A311D_6.4.8/lib/libNNArchPerf.so)
mark_as_advanced(${OVXDRV_INCLUDE_DIRS} ${OVXDRV_LIBRARIES})
if(${TIM_VX_ENABLE_VIPLITE})
message("Downloading A311D VIPLite SDK ...")
file(DOWNLOAD "https://github.com/VeriSilicon/TIM-VX/releases/download/v1.1.28/VIPLite_aarch64_A311D_1.3.5.tgz"
${PROJECT_BINARY_DIR}/VIPLite_aarch64_A311D_1.3.5.tgz
EXPECTED_MD5 "a52839d1f5d37cac8219b0ddec301ddf"
SHOW_PROGRESS)
execute_process(COMMAND
tar xf ${PROJECT_BINARY_DIR}/VIPLite_aarch64_A311D_1.3.5.tgz)
set(VIPLITE_DRV_INCLUDE_DIR ${PROJECT_BINARY_DIR}/viplite/include)
set(VIPLITE_DRV_LIBRARIES)
list(APPEND VIPLITE_DRV_LIBRARIES
${PROJECT_BINARY_DIR}/viplite/drivers/libVIPlite.so
${PROJECT_BINARY_DIR}/viplite/drivers/libVIPuser.so
)
mark_as_advanced(${VIPLITE_DRV_INCLUDE_DIR} ${VIPLITE_DRV_LIBRARIES})
endif()

2
include/tim/lite/handle.h
View File

@ -35,6 +35,8 @@ class HandleImpl;
class Handle {
public:
std::unique_ptr<HandleImpl>& impl() { return impl_; }
bool Flush();
bool Invalidate();
protected:
std::unique_ptr<HandleImpl> impl_;
};

3
samples/CMakeLists.txt
View File

@ -1,5 +1,8 @@
add_subdirectory("benchmark_test")
add_subdirectory("lenet")
if(${TIM_VX_ENABLE_VIPLITE})
add_subdirectory("lenet_lite")
endif()
if(NOT ANDROID_TOOLCHAIN)
add_subdirectory("multi_thread_test")

12
samples/lenet_lite/CMakeLists.txt Normal file
View File

@ -0,0 +1,12 @@
message("samples/lenet_lite")
set(TARGET_NAME "lenet_lite")
aux_source_directory(. ${TARGET_NAME}_SRCS)
add_executable(${TARGET_NAME} ${${TARGET_NAME}_SRCS})
target_link_libraries(${TARGET_NAME} PRIVATE tim-vx)
target_include_directories(${TARGET_NAME} PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}
${PROJECT_SOURCE_DIR}/include
)

2
samples/lenet_lite/lenet_lite_asymu8.cc
View File

@ -110,7 +110,7 @@ static void printTopN(const T* prob, size_t outputCount, size_t topNum) {
#define MEM_ALIGN(x, align) (((x) + ((align)-1)) & ~((align)-1))
int main(int argc, char** argv) {
int main() {
auto exec = tim::lite::Execution::Create(lenet_executable.data(), lenet_executable.size());
if (exec) {
const size_t lenet_output_size = 10;

26
src/tim/CMakeLists.txt
View File

@ -48,10 +48,9 @@ foreach(src_file ${${TARGET_NAME}_SRCS})
endif()
endforeach()
add_library(${TARGET_NAME} ${${TARGET_NAME}_SRCS})
target_link_libraries(${TARGET_NAME} PRIVATE
-Wl,--whole-archive tim_internal -Wl,--no-whole-archive)
target_include_directories(${TARGET_NAME} PRIVATE
set(EXTERNAL_LIBS)
set(INC_DIRS)
list(APPEND INC_DIRS
${PROJECT_SOURCE_DIR}/include
${CMAKE_CURRENT_SOURCE_DIR}/vx
${CMAKE_CURRENT_SOURCE_DIR}/transform
@ -59,12 +58,31 @@ target_include_directories(${TARGET_NAME} PRIVATE
${OVXDRV_INCLUDE_DIRS}
)
if(${TIM_VX_ENABLE_VIPLITE})
aux_source_directory(./lite LITE_SRC)
list(APPEND ${TARGET_NAME}_SRCS
${LITE_SRC})
list(APPEND EXTERNAL_LIBS ${VIPLITE_DRV_LIBRARIES})
list(APPEND INC_DIRS
${CMAKE_CURRENT_SOURCE_DIR}/lite
${VIPLITE_DRV_INCLUDE_DIR}
)
endif()
add_library(${TARGET_NAME} ${${TARGET_NAME}_SRCS})
target_include_directories(${TARGET_NAME} PRIVATE ${INC_DIRS})
target_link_libraries(${TARGET_NAME} PUBLIC
-Wl,--whole-archive tim_internal -Wl,--no-whole-archive ${EXTERNAL_LIBS})
install(TARGETS ${TARGET_NAME} ${TARGET_NAME}
DESTINATION ${CMAKE_INSTALL_PREFIX}/lib)
install(DIRECTORY ${CMAKE_SOURCE_DIR}/include/tim/vx
DESTINATION ${CMAKE_INSTALL_PREFIX}/include/tim)
install(DIRECTORY ${CMAKE_SOURCE_DIR}/include/tim/lite
DESTINATION ${CMAKE_INSTALL_PREFIX}/include/tim)
if(TIM_VX_ENABLE_LAYOUT_INFER)
install(DIRECTORY ${CMAKE_SOURCE_DIR}/include/tim/transform
DESTINATION ${CMAKE_INSTALL_PREFIX}/include/tim)

4
src/tim/lite/execution.cc
View File

@ -140,7 +140,7 @@ Execution& ExecutionImpl::BindInputs(const std::vector<std::shared_ptr<Handle>>&
return *this;
}
vip_status_e status = VIP_SUCCESS;
vip_buffer_create_params_t param = { 0 };
vip_buffer_create_params_t param;
for (uint32_t i = 0; i < handles.size(); i ++) {
auto handle = handles[i];
if (!handle) {
@ -175,7 +175,7 @@ Execution& ExecutionImpl::BindOutputs(const std::vector<std::shared_ptr<Handle>>
return *this;
}
vip_status_e status = VIP_SUCCESS;
vip_buffer_create_params_t param = { 0 };
vip_buffer_create_params_t param;
for (uint32_t i = 0; i < handles.size(); i ++) {
auto handle = handles[i];
if (!handle) {

38
src/tim/lite/handle.cc
View File

@ -27,6 +27,7 @@
#include <cassert>
#include <cstdint>
#include <memory>
#include <iostream>
#include "execution_private.h"
#include "vip_lite.h"
@ -35,6 +36,16 @@
namespace tim {
namespace lite {
bool Handle::Flush() {
auto internal_handle = impl_->internal_handle();
return internal_handle->Flush(HandleFlushType::HandleFlush);
}
bool Handle::Invalidate() {
auto internal_handle = impl_->internal_handle();
return internal_handle->Flush(HandleFlushType::HandleInvalidate);
}
UserHandle::UserHandle(void* buffer, size_t size) {
assert((reinterpret_cast<uintptr_t>(buffer) % _64_BYTES_ALIGN) == 0);
impl_ = std::make_unique<UserHandleImpl>(buffer, size);
@ -44,12 +55,12 @@ UserHandle::~UserHandle() {}
std::shared_ptr<InternalHandle> UserHandleImpl::Register(
vip_buffer_create_params_t& params) {
auto internal_handle = std::make_shared<InternalUserHandle>(
internal_handle_ = std::make_shared<InternalUserHandle>(
user_buffer_, user_buffer_size_, params);
if (!internal_handle->handle()) {
internal_handle.reset();
if (!internal_handle_->handle()) {
internal_handle_.reset();
}
return internal_handle;
return internal_handle_;
}
InternalHandle::~InternalHandle() {
@ -72,5 +83,24 @@ InternalUserHandle::InternalUserHandle(void* user_buffer, size_t user_buffer_siz
}
}
bool InternalUserHandle::Flush(HandleFlushType type) {
vip_status_e status = VIP_SUCCESS;
switch (type) {
case HandleFlushType::HandleFlush: {
status = vip_flush_buffer(handle_, VIP_BUFFER_OPER_TYPE_FLUSH);
break;
}
case HandleFlushType::HandleInvalidate: {
status = vip_flush_buffer(handle_, VIP_BUFFER_OPER_TYPE_INVALIDATE);
break;
}
default:
std::cout << __FUNCTION__ << ":" << __LINE__ << " Unkown HandleFlushType."
<< std::endl;
assert(false);
}
return status == VIP_SUCCESS ? true : false;
}
}
}

12
src/tim/lite/handle_private.h
View File

@ -32,12 +32,18 @@
namespace tim {
namespace lite {
enum class HandleFlushType {
HandleFlush = 0,
HandleInvalidate = 1
};
class InternalHandle;
class HandleImpl {
public:
virtual std::shared_ptr<InternalHandle> Register(
vip_buffer_create_params_t& params) = 0;
virtual std::shared_ptr<InternalHandle>& internal_handle() = 0;
};
class UserHandleImpl : public HandleImpl {
@ -46,16 +52,21 @@ class UserHandleImpl : public HandleImpl {
: user_buffer_(buffer), user_buffer_size_(size) {}
std::shared_ptr<InternalHandle> Register(
vip_buffer_create_params_t& params) override;
std::shared_ptr<InternalHandle>& internal_handle() override {
return internal_handle_;
}
size_t user_buffer_size() const { return user_buffer_size_; }
void* user_buffer() { return user_buffer_; }
private:
void* user_buffer_;
size_t user_buffer_size_;
std::shared_ptr<InternalHandle> internal_handle_ = nullptr;
};
class InternalHandle {
public:
~InternalHandle();
virtual bool Flush(HandleFlushType type) = 0;
vip_buffer handle() { return handle_; };
protected:
vip_buffer handle_;
@ -65,6 +76,7 @@ class InternalUserHandle : public InternalHandle {
public:
InternalUserHandle(void* user_buffer, size_t user_buffer_size,
vip_buffer_create_params_t& params);
bool Flush(HandleFlushType type) override;
};
}