Add function for lite driver handle (#209)

Signed-off-by: Zongwu Yang <zongwu.yang@verisilicon.com>

CMakeLists.txt

@@ -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)

cmake/A311D.cmake

@@ -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()

include/tim/lite/handle.h

@@ -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_;
 };

samples/CMakeLists.txt

@@ -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")

samples/lenet_lite/CMakeLists.txt

@@ -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
+)

samples/lenet_lite/lenet_lite_asymu8.cc

@@ -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;

src/tim/CMakeLists.txt

@@ -48,10 +48,9 @@ foreach(src_file ${${TARGET_NAME}_SRCS})
     endif()
 endforeach()
 
-add_library(${TARGET_NAME} ${${TARGET_NAME}_SRCS})
+set(EXTERNAL_LIBS)
-target_link_libraries(${TARGET_NAME} PRIVATE
+set(INC_DIRS)
-    -Wl,--whole-archive tim_internal -Wl,--no-whole-archive)
+list(APPEND INC_DIRS
-target_include_directories(${TARGET_NAME} PRIVATE
     ${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)

src/tim/lite/execution.cc

@@ -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) {

src/tim/lite/handle.cc

@@ -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()) {
+    if (!internal_handle_->handle()) {
-        internal_handle.reset();
+        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;
+}
+
 }
 }

src/tim/lite/handle_private.h

@@ -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;
 };
 
 }